prácticas de máquina sencilla con fpga -...

Prácticas de Máquina Sencilla con FPGA

TITULACIÓN: Enginyeria Tècnica Industrial en Electrònica Industrial

AUTOR: Alan Morato Gomis

DIRECTOR: Enrique F. Cantó Navarro

FECHA: junio del 2011.

Prácticas de Máquina Sencilla con FPGA Índice General

1

1 Índice General

2 Introducción Pág. 3 2.1 Antecedentes Pág. 3

2.2 FPGA Pág. 3

2.2.1 Historia de la FPGA Pág. 4

2.3 Spartan-3 XC3S200 FT256 de Xilinx Pág. 5

2.4 Starter Board Kit Pág. 7

2.5 Lenguaje VHDL Pág. 8

2.6 La Máquina Sencilla Pág. 9

2.6.1 Formato de las Instrucciones Pág. 10

2.6.2 Fases de la Ejecución de una Instrucción Pág. 10

3 Memoria Descriptiva Pág. 12 3.1 Simplificaciones para la Implementación Pág. 12

3.1.2 Códigos Genéricos de Partida Pág. 13 3.1.2.1 Reg – Registro Pág. 14

3.1.2.2 Reg1 – Registro de 1 bit Pág. 15

3.1.2.3 Mux4 – Multiplexor de 4 entradas Pág. 15 3.1.2.4 Mux2 – Multiplexor de 2 entradas Pág. 16

3.1.2.5 inc - Incrementador Pág. 16

3.1.2.6 ALU – Unidad Aritmético Lógica Pág. 16

3.1.2.7 UD – Unidad de Datos Pág. 16 3.1.2.8 UC – Unidad de Control Pág. 17

3.1.2.9 RAM – Memoria RAM Pág. 18

3.1.2.10 ROM – Memoria ROM Pág. 19 3.1.2.11 RAM_pack – Paquete de la memoria RAM Pág. 19

3.1.2.12 ROM_pack – Paquete de la memoria ROM Pág. 19

3.1.2.13 led7seg – Led 7 segmentos Pág. 20 3.1.2.14 dbug – Debug Pág. 20

3.1.2.15 MaquinaSencilla – Máquina Sencilla Pág. 20

3.1.2.16 MaquinaSencilla_test – Máquina Sencilla test bench Pág. 21

3.1.2.17 MaquinaSencilla.ucf – Máquina Sencilla ucf Pág. 21

3.2 Manual de Prácticas Pág. 22

3.3 Proceso General de Implementación de la Máquina Sencilla Pág. 22

3.3.1 Unidad de Datos Pág. 22

3.3.2 Unidad de Control Pág. 23

3.3.3 Memoria Pág. 23

3.3.4 MáquinaSencilla.VHDL Pág. 24

3.3.5 Simulación Pág. 24

3.3.6 Programación de la FPGA Pág. 25

3.4 Las Máquinas Sencillas Implementadas Pág. 25

3.4.1 Máquina Sencilla 1 Pág. 25









Prácticas de Máquina Sencilla con FPGA Índice General

2


4 Conclusiones Pág. 59

5 Posibles Mejoras Pág. 60

6 Anexo Manual de Prácticas Pág. 61

7 Bibliografía y Referencias Pág. 119

Prácticas de Máquina Sencilla con FPGA Introducción

3

2 Introducción

2.1 Antecedentes

Este proyecto, titulado como Prácticas de Máquina Sencilla con FPGA, tiene como

objetivo preparar las prácticas que realizarán los futuros alumnos de Grado en Ingeniería

Electrónica Industrial y Automática.

Las prácticas están relacionas entorno a la Máquina Sencilla. Hasta el momento, los

estudiantes, a lo largo de los años sólo han estudiado la Máquina Sencilla teóricamente, y

nunca se ha hecho nada práctico entorno a la Máquina Sencilla. Esto ha sido una de las

motivaciones para crear unas prácticas de Máquina Sencilla.

En las prácticas, el alumno tendrá que:

Diseñar la máquina sencilla. Hacer el diseño de todos sus componentes y de su

jerarquía de bloques.

Simular la máquina sencilla diseñada. Mediante el software de Xilinx, el alumno

comprobará que su diseño funciona correctamente observando las formas de onda

de las señales de la máquina sencilla diseñada.

Implementar físicamente la máquina sencilla. El diseño se implementará en una

FPGA. Se podrá observar el funcionamiento real de la máquina sencilla mediante

leds y displays 7 segmentos. Además, se dispondrán de dos relojes, el real de 50

MHz y el manual. Eso facilitará la observación del funcionamiento.

Para la implementación física se utilizan FPGAs. Las FPGAs utilizadas son de la familia

Spartan – 3de Xilinx[1], y están integradas en una placa de pruebas llamada Starter Board

Kit[2]. Para la programación de las FPGAs se utiliza el programa Xilinx ISE 12.3[3]

. El

lenguaje de descripción hardware que se utiliza para diseñar las máquinas sencillas es el

VHDL[4].

Se ha dado por supuesto que el alumno no tiene ningún conocimiento sobre este lenguaje

ni sobre el software ISE 12.3. Por eso, en este proyecto, se ha redactado un manual de

prácticas.

En las prácticas, cada alumno tendrá que implementar una máquina sencilla distinta. En

este proyecto se han implementado un total de 10 máquinas sencillas. El objetivo de

implementar estas máquinas sencillas ha sido detectar las posibles complicaciones con las

que se puede encontrar el alumno e intentar simplificarlas al máximo. Una de las

decisiones principales que se ha tomado para simplificar la problemática, ha sido generar

unos ficheros genéricos, que se pueden aprovechar, casi en su totalidad, para implementar

cualquier máquina sencilla. El alumno, modificando sólo parcialmente estos códigos podrá

implementar distintas máquinas sencillas

2.2 FPGA

La máquina sencilla se puede implementar físicamente de muchas maneras. Se puede

implementar con ASICs (Circuito Integrado de Aplicación Específica), CPLDs (Complex

Programmable Logic Device), etc.

Se ha decidido implementar la máquina sencilla con FPGAs por varios motivos:


4

- El Departamento de Ingeniería Electrónica, Eléctrica y Automática ya posee una

cierta cantidad de FPGAs Spartan – 3 integradas en el Starter Board Kit. Porque se

utilizan en otras asignaturas. Así que utilizando estas FPGAs se ahorra el coste de

comprar nuevo material.

- La programación de las FPGAs se puede hacer con VHDL. Que se trata de un

lenguaje de alto nivel y relativamente fácil de aprender y utilizar.

- La flexibilidad de programación que ofrece la FPGA no la ofrece la CPLD.

- Una FPGA se puede reprogramar, mientras que un ASIC no.

- La placa de pruebas donde se encuentra integrada la FPGA Spartan-3 ofrece

bastantes posibilidades para hacer la implementación de la máquina sencilla más

interactiva.

FPGA es el acrónimo de Field Programmable Gate Array. Se trata de un dispositivo

semiconductor que contiene bloques de lógica cuya interconexión y funcionalidad puede

ser configurada „in situ‟ mediante un lenguaje de programación especializado, en este caso,

el VHDL. [4]

2.2.1 Historia de la FPGA

La FPGA es la evolución del PLD y el ASIC.

Los PLDs empezaron con los primeros dispositivos PROM y se le añadió versatilidad con

los PAL, que permitieron un mayor número de entradas y la inclusión de registros.

Los ASIC siempre han tenido el problema que requieren una considerable inversión de

tiempo y dinero. Con el tiempo se intentó reducir esta inversión de tiempo y dinero, para

ello se pasó a la modularización de los elementos de los circuitos. Por ejemplo, se pasó a

crear ASICs basados en celdas.

El paso definitivos fue combinar las dos estrategias con un mecanismo de interconexión

que se podía programar utilizando fusibles, antifusibles o celdas RAM.

Los circuitos que resultaron fueron las FPGAs que son similares en capacidad y

aplicaciones a los PLD más grandes.

Las FPGAs se han utilizado históricamente como controladores,

codificadores/decodificadores y en microprocesadores hechos a medida.


5

2.3 Spartan-3 XC3S200 FT256 de Xilinx

En este proyecto se utiliza una FPGA Spartan-3 modelo XC3S200 FT256 de Xilinx,

empresa líder en el sector de las FPGAs. Esta FPGA está integrada en la placa de pruebas

Starter Board Kit.

La FPGA de esta placa incluye:

- 200.000 puertas lógicas equivalentes de capacidad

- 4.320 CLBs (Bloques Lógicos Configurables)

- 12 block RAMs de 18Kbits. En total 216Kbits de RAM distribuida en bloques.

- 12 18x18 multiplicadores hardware

- 4 DCMs (Digital Clock Managers)

- Hasta 173 señales I/O definidas por el usuario

Las block RAM son memorias configurables y síncronas. En ellas se pueden almacenar

cantidades relativamente grandes de datos de la manera más eficiente posible dentro de la

FPGA.

En la implementación de las memorias de la máquina sencilla se hace uso de estos bloques.

Cada CLB de esta FPGA tiene 4 slices agrupados por parejas e interconectados, tal y como

se ve en la siguiente imagen:

Figura 1. Contenido de CLB de la FPGA


6

A su vez, cada slice está formado por dos LUTs, 2 Flip-Flops y un conjunto de

multiplexores, puertas lógicas y otro elementos que los interconectan:

Figura 2. Diagrama Simplificado de un Slice


7

2.4 Starter Board Kit

En la placa de pruebas, hay:

PROM de configuración programable in-system Xilinx XCF02S Platform Flash de

2 Mbits

- 1 Mbit de datos no volátiles o de almacenamiento de código de aplicación

disponible después de la configuración de la FPGA.

- Jumpers que permiten a la FPGA leer datos de la PROM o desde otras

fuentes.

1 Mbyte de Fast Asynchronous SRAM.

- Dos SRAMs de 256 k x 16 ISSI IS61 LV25616AL-10T a 10ns.

- Arquitectura de memoria configurable.

Array único de 256k x 32 SRAM.

2 arrays independientes SRAM de 256 k x 16.

- Chip select individual por dispositivo.

- Byte enables individuales.

Display port de 3 bits y 8 colores VGA.

Puerto serie de RS-232 de 9 pines.

- Conector hembra DB9 de 9 pines.

- Traductor transceiver/level RS-232.

- Utiliza cable serie straight-through para conectar-se al puerto serie del

ordenador.

- Segundo canal RS-232 de transmisión y recepción disponibles en los puntos

de prueba de la placa.

Puerto PS/2 – style para ratón o teclado.

4 displays de siete segmentos LED

8 interruptores.

8 salidas LED individuales.

4 pulsadores.

Reloj de 50 MHz.

Zócalo para reloj auxiliar.

Configuración de la FPGA seleccionable con jumpers.

Pulsador para forzar la reconfiguración de la FPGA.

LED indicador de que se ha configurado la FPGA correctamente.


8

3 puertos de expansión de 40 pines.

Puerto JTAG para cable de descarga de bajo coste.

Cable Digilent JTAG download/debugging que conecta con el puerto paralelo del

PC.

Port donwload/debug JTAG compatible con Xilinx Parallel Cable IVi el MultiPro

Desktop Tool.

Entrada adaptadora de AC para las fuentes de alimentación internacionales de +5V

no reguladas incluidas.

LED indicador de Power-on

Reguladores on-board de 3.3V, 3.5V y 1.2V.

Figura 3. Starter Board Kit

2.5 Lenguaje VHDL

El leguaje que se utiliza para la síntesis y la implementación de la máquina sencilla es el

VHDL.

VHDL es el acrónimo que representa la combinación de VHSIC y HDL, donde VHSIC es

el acrónimo de Very High Integrated Circuit y HDL es a su vez el acrónimo de Hardware

Description Language.

Es un lenguaje definido por el IEEE, Institute of Electrical and Electronics Engineers, y

usado por ingenieros para describir circuitos digitales. Otros métodos para diseñar circuitos

son la captura de esquemas con herramientas CAD y los diagramas de bloques, pero éstos


9

no son prácticos en diseños complejos. Otros lenguajes para el mismo propósito son

Verilog y ABEL.

El VHDL se trata de un lenguaje de descripción de hardware a alto nivel que puede

utilizarse para modelar, documentar, simular, verificar y sintetizar sistemas digitales.

Proporciona soporte suficiente para especificar su comportamiento o su estructura,

incluyendo las jerarquías. Por lo tanto, es útil para metodologías de diseño ascendientes

(bottom-up) y descendientes (top-down).

La semántica y construcciones del lenguaje permiten diseñar bancos de pruebas (test-bench)

mediante los cuales es pueden hacer simulaciones de los sistemas modelados.

Aunque puede ser usado de forma general para describir cualquier circuito se usa

principalmente para programa PLD, FPGA, ASIC y similares.

2.6 La Máquina Sencilla[6]

La máquina sencilla se trata de un computador simplificado. Un computador se define

como una máquina capaz de resolver problemas ejecutando, de manera secuencial, un

programa.

Un programa se trata de una secuencia de instrucciones que describen como ejecutar una

tarea determinada. En el caso de la máquina sencilla, el programa es hecho a base de

lenguaje máquina.

El leguaje máquina se trata de un conjunto de instrucciones primitivas que entiende un

computador.

Este computador simplificado tiene principalmente los siguientes bloques:

Memoria: Parte del computador encargada de almacenar las instrucciones del

programa y los datos relacionados mientras se ejecuta el programa. Hay de dos

tipos:

- RAM: almacena datos del programa y del usuario.

- ROM: almacena datos y programas propios del computador.

Unidad Central de Proceso (CPU): su función es ejecutar los programas

almacenados en memoria y ejecutar las operaciones sobre los datos. Tiene dos

partes:

- Unidad de Datos (UD): ejecuta las operaciones según lo que le ordena la

Unidad de Control. Está compuesta por distintos componentes:

Unidad Aritmético Lógica (ALU): realiza las operaciones

aritméticas (sumas, restas, multiplicaciones, etc.) y lógicas (and, or,

xor, nor, etc.)

Registros generales: memoria de alta velocidad usada para

almacenar resultados intermedios

Registros específicos: memoria de alta velocidad con funciones

especiales. Suelen ser:

o Contador de Programa (PC): contiene la dirección de la

palabra de memoria donde se encuentra la siguiente

instrucción a ejecutar.

o Registro de Instrucciones (IR): contiene el código a

ejecutar


10

o Registro de Estado (SR): sus bits memorizan situaciones

especiales como “resultado cero”, “desbordamiento”, etc.

- Unidad de Control (UC): parte de la CPU encargada de gobernar el resto

del computador. Para cada instrucciones del programa, la UC decide que

operaciones tiene que realizar la UD y el resto de bloques del computador.

Buses: son las vías de comunicación entre los distintos bloques del computador.

Hay de tres tipos:

- Bus de datos: a través de él se realiza las transferencia de datos y de

instrucciones desde la memoria hasta la CPU (lectura) o des de la CPU a la

memoria (escritura). Es bidireccional.

- Bus de direcciones: a través de él, la CPU envía las direcciones de

memoria donde se encuentran las instrucciones que se han de leer o las

direcciones de memoria o periféricos donde se han de leer o escribir los

datos. Es unidireccional.

- Bus de control: a través de él se transmiten las señales de control: lectura,

escritura, reloj, etc.). Es bidireccional.

2.6.1 Formato de las Instrucciones

Instrucción: es un código binario con dos partes diferentes:

Código de operación: identifica la operación que se ejecutará.

Código de direccionamiento: indica cómo encontrar los operandos necesarios para

ejecutar la operación.

Modos de direccionamiento: son los distintos modos que hay para indicar cómo encontrar

los operandos. Los más utilizados son:

Modo inmediato: el código de direccionamiento de la instrucción contiene el

operando directamente.

Modo absoluto o directo: el código de direccionamiento de la instrucción contiene

la dirección de memoria donde se encuentra el operando.

Modo indirecto: el código de direccionamientos de la instrucción contiene la

dirección de memoria donde está la dirección donde está el operando.

2.6.2 Fases de la Ejecución de una Instrucción

En general, se puede decir que la ejecución de una instrucción está dividida en 4 fases:

1) Fetch: búsqueda en memoria de la instrucción, almacenamiento de la instrucción

en IR e incremento del PC, que apuntará a la siguiente instrucción.

2) Decodificación: decodificación de la instrucción, se analiza el código de operación.

3) Búsqueda: se buscan los operandos en memoria o se evalúa el Status Register.


11

4) Ejecución: ejecución de la instrucción y almacenamiento de los resultados en

memoria.

La activación de los bloques correspondientes de la Unidad de Datos y el seguimiento de la

buena secuencia de operaciones lo realiza la Unidad de Control siguiendo un grafo de

estados. Este grafo de estados se trata de una máquina de estados finitos. Las condiciones

de salto de un estado a otro de la máquina de estados las imponen las señales de entrada a

la Unidad de Control, como puede ser el código de operación, el flag Z, etc.

En el grafo de estados de la UC, cada estado lleva asociado un vector binario de salida.

Este vector almacena los bits de control que manda la Unidad de Control hacia la Unidad

de Datos y la memoria. Pueden ser bits de habilitación de registros, bits de selección de

multiplexores, la señal de lectura/escritura de memoria, etc.

Prácticas de Máquina Sencilla con FPGA Memoria Descriptiva

12

3 Memoria Descriptiva

En este documento se describe el proceso general de implementación de la máquina

sencilla en VHDL, las distintas decisiones que se han tomado para la simplificación de la

implementación, las distintas máquinas sencillas que se han implementado en este proyecto

y el Manual de Prácticas.

3.1 Simplificaciones para la Implementación

En este apartado se explican las decisiones que se han tomado para intentar simplificar al

máximo el proceso de implementación de la máquina sencilla.

El primer problema que se presenta para preparar las prácticas que cara al alumno es que el

alumno no conoce el leguaje VHDL. Y muy probablemente, nunca ha utilizado un

lenguaje de descripción hardware. Así que hay dos opciones, enseñarle el leguaje VHDL a

fondo para que luego el alumno se sepa valer por sí mismo para diseñar la máquina sencilla

desde cero, o bien, enseñar al alumno el lenguaje VHDL de la manera más sencilla y

práctica posible, de tal manera que sólo tenga que saber lo justo y necesario para

implementar una máquina sencilla en VHDL.

Como el objetivo de las prácticas es implementar una máquina sencilla, y no aprender a

diseñar hardware en VHDL, se ha decidido que al alumno sólo se le enseñará la base

necesaria de VHDL para que pueda implementar una máquina sencilla sin problemas. Y

además, se ha escrito un manual de prácticas donde se explica la teoría necesaria de VHDL

de la manera más sencilla posible.

El segundo dilema que ha aparecido durante el proyecto, está también relacionado con el

VHDL. Porque en VHDL hay muchos métodos posibles para llegar a un mismo fin. Hay

muchos tipos de descripciones para llegar a definir un mismo circuito. En VHDL hay tres

formas generales de descripción:

- Descripción de comportamiento

- Descripción de flujo de datos

- Descripción estructural

Para los componentes de nivel más bajo en la jerarquía de bloques, se ha combinado la

descripción de comportamiento con la de flujo de datos. Y para componentes que abarcan

más subcomponentes, como por ejemplo la Unidad Datos, que abarca registros y

multiplexores, se ha utilizado principalmente descripción estructural.

Pero no sólo hay distintos tipos de descripción, sino que también hay distintas maneras de

organizar los archivos o componentes. Por ejemplo, se puede describir toda la máquina

sencilla entera en un solo archivo, y en él describir todos los componentes y

subcomponentes de la máquina sencilla. O también, se puede definir un archivo para cada

componente de la máquina sencilla: un archivo para componente de tipo registro, otro para

tipo multiplexor, otro para tipo Unidad de Datos, etc.

En este proyecto se ha decidido que cada tipo de componente se describirá en un archivo

aparte. De esta manera, cabe la posibilidad de intentar hacer archivos genéricos para

algunos tipos de componentes.

De hecho, esto es lo que se ha hecho en el proyecto. Se han descrito unos componentes

genéricos en unos archivos, que se pueden aprovechar para cualquier máquina sencilla.


13

Estos códigos genéricos el alumno los tendrá desde un buen inicio. Esto simplifica mucho

el proceso de implementación. Porque el alumno se ahorra mucha cantidad de descripción

en VHDL. Y como menos descripción en VHDL tenga que hacer, menos lenguaje VHDL

hay que enseñarle.

3.1.2 Códigos Genéricos de Partida

Los códigos genéricos de partida que se han diseñado son los siguientes:

UD

Unidad de Datos. Se trata de una Unidad de Datos genérica. No se puede

aprovechar totalmente, pero el código sirve de pauta.

UC

Unidad de Control. Se trata de una Unidad Control genérica. No se puede

aprovechar totalmente, pero el código sirve de pauta.

Reg1

Registro de 1 bit. Totalmente aprovechable para cualquier máquina sencilla.

Reg

Registro. A cada registro se le puede determinar, individualmente, su tamaño en

bits. Totalmente aprovechable para cualquier máquina sencilla.

Mux4

Multiplexor de 4 entradas. A cada multiplexor se le puede determinar,

individualmente, el tamaño de sus entradas/salida en bits. Totalmente aprovechable

para cualquier máquina sencilla.

Mux2


individualmente, el tamaño de sus entradas/salida en bits. Totalmente aprovechable

para cualquier máquina sencilla.

Inc

Incrementador. Se trata del bloque “+1” que siempre suele ir adjunto al registro

“PC”. Se puede determinar el tamaño de su entrada/salida en bits. Totalmente

aprovechable para cualquier máquina sencilla.

ALU

Unidad Aritmético-Lógica. Este es un archivo ejemplo, cada máquina sencilla tiene

su propia ALU. Aunque este archivo puede servir de pauta.


14

RAM

Memoria RAM de la máquina sencilla. Este archivo es suficientemente genérico

para que funcione en cualquier máquina sencilla.

RAM_pack

Paquete de la memoria RAM. Se trata de un archivo auxiliar para la memoria. De

este archivo sólo hay que modificar un par de constantes.

ROM

Memoria ROM de la máquina sencilla. Este archivo es suficientemente genérico

para que funcione en cualquier máquina sencilla.

ROM_pack

Paquete de la memoria ROM. Se trata de un archivo auxiliar para la memoria. De

este archivo sólo hay que modificar un par de constantes.

MaquinaSencilla

La máquina sencilla. Es el archivo que recoge todos los componentes: UD, UC y

memoria(s). No es totalmente aprovechable, pero sirve de pauta.

MaquinaSencilla_test

Se trata de un archivo necesario para poder simular la máquina sencilla en cuestión.

Totalmente aprovechable para cualquier máquina sencilla.

Led7seg

Led de 7 segmentos. Se trata de un archivo necesario para poder utilizar los

displays de 7 segmentos que tiene el kit Spartan-3. Totalmente aprovechable para

cualquier máquina sencilla.

Dbug

Debug. Se trata de un archivo donde se gestionan las señales que se mostrarán

mediante leds o el display. Totalmente aprovechable para cualquier máquina

sencilla.

3.1.2.1 Reg – Registro

Este se trata del código que implementa un Registro general en VHDL. El alumno no tiene

que entrar a analizar este código. Él sólo tiene que saber que en su port map hay genérico

que sirve para determinar el tamaño en bits del registro.

Como todo componente, lo primero que se declara son los puertos. Lo primero que hay es

el genérico, donde se determina una constante que indica el tamaño en bits del registro. Es

decir, indica el tamaño en bits del vector de entrada y del vector de salida del registro. A


15

continuación, ya se declaran los puertos de entrada y salida. Es importante saber el orden,

en el caso del componente de tipo registro el port map es el siguiente:

PORT MAP (<reloj>,<reset>,<enable>,<in>,<out>);

La descripción del comportamiento de este componente se hace mediante un proceso y un

serie de condiciones.

El proceso es sensible a la señales de reloj y reset. Cuando hay un flanco ascendente de la

señal de reloj y la señal de habilitación está activada la salida del registro toma como valor

la entrada del mismo. Y cuando la señal de reset está activada la salida del registro pasa a

estar toda a nivel bajo. Para evitar problemas de que la señal de reset no esté definida en un

principio ni como „0‟ ni como „1‟, se inicializa la señal a „0‟. Es importante remarcar que

el reset del registro es asíncrono.

3.1.2.2 Reg1 – Registro de 1 bit

Este se trata del código que implementa en VHDL un registro general de tamaño 1 bit. El

alumno no tiene que entrar a analizar este código. Se ha tenido que crear un componente

especial para registros de 1 bit porque la los puertos de entrada y salida del componente

reg han de ser vectores, y en este caso la entrada y la salida no son vectores sino simples

std_logic.

Como todo componente, lo primero que se declara son los puertos de entrada y salida. Es

importante saber el orden, en el caso del componente de tipo registro el port map es el

mismo que el componente de tipo registro:

PORT MAP (<reloj>,<reset>,<enable>,<in>,<out>);

La descripción del comportamiento de este componente es sencillo. Lo que se hace es

transformar el bit de entrada al registro y el bit de salida a vectores de 1 solo bit. Entonces,

como son tipo vectores, se puede crear un componente interno del tipo reg.

3.1.2.3 Mux4 – Multiplexor de 4 entradas

Este se trata del código que implementa en VHDL un multiplexor de 4 entradas. El alumno

sólo tiene que saber que el componente tiene un genérico para determinar el tamaño del

dato de entrada/salida y el orden de las señales de su port map.

Como todo componente empieza declarando los puertos de entrada y salida. Su port map

es el siguiente:

PORT MAP (<in00>,<in01>,<in10>,<in11>,<bits de selección>,<out>);

Y para describir su comportamiento, se utiliza la estructura “with select – when”. Donde

según el valor de los bits de selección la salida del multiplexor toma una de las entradas.


16

3.1.2.4 Mux2 – Multiplexor de 2 entradas

Este se trata del código que implementa en VHDL un multiplexor de 2 entradas. El alumno

sólo tiene que saber que el componente tiene un genérico para determinar el tamaño del

dato de entrada/salida y el orden de las señales de su port map.

Como todo componente empieza declarando los puertos de entrada y salida. Su port map

es el siguiente:

PORT MAP (<in0>,<in1>,<bit de selección>,<out>);

Y para describir su comportamiento, se utiliza la estructura “with select – when”. Donde

según el valor de los bits de selección la salida del multiplexor toma una de las entradas.

3.1.2.5 inc - Incrementador

Este se trata del código que implementa el bloque “+1” que suele ir adjunto al registro PC.

El alumno sólo tiene que saber que hay un genérico para determinar el tamaño en bits del

vector de entrada/salida y el orden de las señales de su port map:

PORT MAP (<in>,<out>);

El comportamiento de este componente se trata de una simple suma. El vector de entrada

se transforma a tipo unsigned para poder operar aritméticamente con él, se le suma 1 y se

vuelve a transformar a std_logic_vector.

3.1.2.6 ALU – Unidad Aritmético Lógica

Este es el código que describe la ALU de la máquina sencilla de ejemplo. El alumno no lo

podrá aprovechar completamente, pero lo podrá usar como pauta.

Primero se describen los puertos de entrada y salida. En el caso del ejemplo, como entradas

hay, dos vectores de datos y la señal de selección de la operación, y como salidas, la señal

del flag Z y el vector con el resultado de la operación.

Para describir el comportamiento se crean señales auxiliares que almacenan los datos de

entrada transformados a unsigned, para poder operar aritméticamente con ellos. Y la salida

se escoge con un “with select – when”.

3.1.2.7 UD – Unidad de Datos

Este es el código que describe la Unidad de Datos de la máquina sencilla de ejemplo. El

código está dividido en 4 partes:

- Puertos. Al principio del código se describen los puertos de entrada y salida de este

registro. Esta parte se modificará según la máquina sencilla en cuestión. Siempre

suelen haber puertos típicos como, el bus de direcciones o el bus de datos. Pero el

tamaño no siempre es el mismo. Y habrá puertos característicos de cada Unidad de

Datos, por ejemplo, en el código hay un puerto de salida para el Flag Z, pero no

todas las máquinas sencillas tienen Flag Z.

En los puertos, aparte de los puertos básicos de entrada y salida que se pueden

determinar fácilmente haciendo un esquema de la caja que representa la UD,

también hay definidos unos puertos que empiezan por la palabra dbug. Estos son

puertos de salida de la UD que se usan para poder saber el estado de ciertos


17

registros internos de la UD como por ejemplo, el registro PC o el IR. Estos puertos

habrá que configurarlos según su tamaño y/o añadir/quitar nuevos registros donde

es interesante poder saber su estado en cada momento.

- Señales. Después de los puertos se definen las señales internas de la UD. Estas

señales, en general, son los puertos de salida de los distintos componentes que

forman la UD. Por ejemplo, “PC” es la salida del registro PC, “MUX” es la salida

del multiplexor de 4 entradas. Esta parte de código, lo más probable es que el

alumno sí tenga que modificarla. Puede ser que haya que cambiar sólo el nombre de

las señales, o que haya que cambiar el rango porque la señal es de otro tamaño, o

que sobren señales, o que falten, y se tengan que crear de nuevo. En general, tiene

que haber una señal por cada señal que va desde un puerto de un componente

interno de la UD, hasta otro puerto de otro componente interno de la UD.

- Componentes. En esta parte se declaran todos los componentes de la UD. La

descripción que se tiene que dar de cada componente incluye: nombre, tipo de

componente, tamaño de los genéricos, descripción de que señal de la UD va a cada

puerto del componente.

El orden en el que se asignan las señales a los puertos de cada componente es

importante. Se tiene que seguir el mismo orden que se ha seguido al definir los

puertos en el componente.

- Gestión de señales. Hay algunas señales que necesitan ser asignadas a puertos, o

que se tienen que dividir en varias señales, o señales que se les tiene que ajusta el

rango, etc. Esto es lo que se hace en esta última parte del código. Por ejemplo, de la

señal de salida del registro IR, los dos bits más altos tienen que asignarse al puerto

de salida “CO”. O en otros casos, la señal de salida de la ALU, tendrá que asignarse

a varios sitios, a memoria y a un registro acumulador, por ejemplo.

3.1.2.8 UC – Unidad de Control

Este es el código que implementa la máquina de estados finitos y la tabla con los bits de

control.

Como todo componente, el código empieza con las declaración de sus puertos. Los puertos

serán las señales de control de salida, como la señal de lectura/escritura, los bits de

habilitación, etc. y la señales que indican el estado de la Unidad de Datos, como el código

de operación, el Flag Z, etc.

Así que lo primero que hay que hacer con este código es la configuración de puertos.

Siguiendo el código, vienen la declaración de señales. Para cualquier UC siempre habrá

dos señales:

- La señal “o”, que almacena los bits de control de la UC. De esta señal hay que

modificar su tamaño en bits. Porque las no todas las máquinas sencillas tienen

la misma cantidad de bits de control de salida.

- La señal “s”, que almacena el estado actual de la Unidad de Control. De esta

señal hay que modificar sus posibles valores, que son los posibles estados en

los que puede estar la máquina sencilla: S0, S1, S2, etc.


18

Así que lo segundo que hay que hacer con este código es la configuración de las señales.

La siguiente parte del código implementa la máquina de estados en sí. Se trata de un

proceso sensible a las señales de clock y reset. Siempre que hay un flanco ascendente de

reloj se ejecuta el proceso y se evalúa a que estado tiene que pasar la máquina. Y siempre

que la señal de reset esté activa, la máquina de estados vuelve al estado inicial, que en

general, es el estado S0.

Para describir la secuencia de estados se utiliza estructuras “case is – end case” anidadas.

Por lo tanto, el alumno sí que tendrá que saber la sintaxis de esta estructura del VHDL. La

secuencia que seguirá dependerá de las señales de entrada a la UC. En el caso del ejemplo,

depende de “CO” y “FZ”.

Así que el tercer paso a realizar es la implementación de la máquina de estados.

Ahora ya se tiene la secuencia de estados que seguirá la máquina sencilla. Falta definir los

valores que tendrán de la UC en cada estado. Es decir, falta implementar en VHDL la tabla

con los bits control.

Para ello, se vuelve a utilizar un proceso y la estructura “case is – end case”. Y a casa

estado se le asigna el vector de bits de control correspondiente a la señal “o”. Por lo tanto,

sólo habrá que modificar los vectores de bits, que es transcribir tal cual la filas de la tabla

al código VHDL.

Así que el cuarto paso consiste en implementación de la tabla con los bits de control.

Por último, hay que asignar un valor al puerto de salida llamado “dbug_state”. Este puerto

tiene que informar del estado actual de la UC. Así que a este puerto se le tiene que asignar

un valor numérico representativo del estado actual. Lo normal es que se le asigne el

número del estado. Por ejemplo, para el estado S12, a “dbug_state” se le asigna “1100”

que es 12 en binario.

Así que el quinto, y último paso, consiste en asignar un valor numérico a cada estado y

asignarlo al puerto “dbug_state”.

3.1.2.9 RAM – Memoria RAM

Este es un código genérico que implementa una memoria RAM genérica. El alumno sólo

tiene que saber que hay un genérico para determinar la inicialización de la memoria y el

orden de las señales de su port map. El código es totalmente aprovechable para cualquier

máquina sencilla. Su port map es:

PORT MAP (<reloj>,<lect/escritura>,<data in>,<bus direcciones>,<data out>);

Este código se apoya de un paquete llamado ram_pack que se explica a continuación. En el

código RAM, se crea una señal interna que es del tipo “t_vectores”. Cuando se define una

señal con este tipo se está diciendo que la señal es un array de vectores. Y de hecho, esto es

la memoria RAM en sí. Se hace así para poder leer/escribir los vectores de entrada/salida

de la memoria de golpe, sin tener que hacerlo bit a bit. Además esta señal del tipo

“t_vectores” se inicializa con una función diseñada en “RAM_pack”.

La descripción del comportamiento de este componente es la siguiente. Con el valor del

bus de direcciones se selecciona un vector de todo el array de vectores. Y según si el bit de

lectura:


19

a) Si R*/W = „1‟ el valor del puerto de entrada se escribe en la posición de memoria

determinada

b) Si R*/W = „0‟ el vector que hay en la posición de memoria determinada se asigna

al puerto de salida de la memoria.

Hay que destacar que la escritura es asíncrona, mientras que la lectura no lo es.

3.1.2.10 ROM – Memoria ROM

Este es un código genérico que implementa una memoria ROM genérica. El alumno no

tiene que modificar nada de este código. La manera de asignar las señales a los puertos es

distinta a la de la RAM, porque no tiene los mismos puertos. El port map de la ROM es:

PORT MAP (<bus direcciones>,<data out>);

El comportamiento de una memoria ROM es bastante sencillo de describir. Simplemente

se trata de un bloque que saca el dato de la dirección de memoria a la que se apunta con el

bus de direcciones.

Hay que destacar que se trata de un componente asícrono.

3.1.2.11 RAM_pack – Paquete de la memoria RAM

Se trata de un archivo auxiliar para la memoria. De este archivo sólo hay que modificar 2

de constantes. Estas 2 constantes indican el tamaño del bus de datos y bus de direcciones

de la memoria RAM .

Pero aparte de estas dos constantes, en el paquete también se definen tipos de datos y se

diseña una función.

Tipos de datos nuevos:

- RAM_type: este tipo indica que el dato de este tipo es una matriz de dos

dimensiones, donde cada una de sus dimensiones tiene un rango natural. Sirve para

guardar la inicialización de la memoria, es decir el programa, en una matriz

- t_vectores_RAM: este tipo indica que el dato de este tipo es un array de vectores, y

no una matriz de 2 dimensiones. Sirve para que el sintetizador sintetice la memoria

RAM con un bloque de memoria RAM específico de la FPGA.

Función diseñada:

- función( <tipo RAM_type>) return t_vectores_RAM. A esta función se le pasa un

dato tipo RAM_type y devuelve la misma matriz transformada en tipo

t_vectores_RAM, es decir, devuelve un array de vectores. Sirve para poder guardar

la inicialización en la memoria RAM.

3.1.2.12 ROM_pack – Paquete de la memoria ROM

Es el equivalente de RAM_pack pero para la memoria ROM. El código es el mismo pero

adaptando los nombres de los puertos, señales, constantes y variables a los de la memoria

ROM.


20

3.1.2.13 led7seg – Led 7 segmentos

Se trata del código que adapta un dato de entrada para que pueda ser mostrado en

hexadecimal por los 3 displays led de 7 segmentos.

3.1.2.14 dbug – Debug

Este es un bloque donde se ha descrito código que no interesa que el alumno tenga que

analizar. Se ha hecho así para simplificar la implementación de la máquina sencilla. En

este código tiene 3 funciones principales:

- Declarar el componente tipo led7seg, al cual se le pasa el dato a mostrar por

los displays 7 segmentos.

- Asignar la señal dbug_led que contiene el vector a mostrar mediante los 8

leds de la placa al puerto de salida de la máquina sencilla.

- Rectificar efectos de rebote en los pulsadores. Al implementarse físicamente

la máquina sencilla, se observó que en los pulsadores se producían rebotes

aleatorios que hacían que la máquina sencilla no funcionase correctamente.

Para corregir este efecto, se compara la señal actual del pulsador con la

señal de hace unos 5 ms para saber si se ha tratado de un rebote o de una

verdadera pulsación.

3.1.2.15 MaquinaSencilla – Máquina Sencilla

Este es el código que implementa el componente de máxima jerarquía en la máquina

sencilla de ejemplo. El alumno tendrá que modificarlo según la máquina sencilla, pero hay

algunas partes que se pueden aprovechar.

Lo primero que se declaran son los puertos. Esta declaración de puertos se puede

aprovechar totalmente para cualquier máquina sencilla.

Seguidamente, viene la declaración de señales. Aquí sí que habrá que configurarlas según

cada máquina sencilla. Sólo hay 3 señales, dbug_led, dbug_in y dbug_clk que se pueden

aprovechar totalmente.

A continuación viene la inicialización de la memoria. En esta inicialización se escribe el

programa que ejecutará la máquina sencilla. Las instrucciones se tiene que escribir en

hexadecimal y asignarles un dirección de memoria. El alumno tendrá que modificar el

programa, pero puede aprovechar la primera línea de la declaración de la constante.

Esta constante es del tipo RAM_type o ROM_type, según si se trata de una memoria RAM

o ROM. Estos tipos se declaran en RAM_pack y ROM_pack respectivamente, e indican

que la constante es una matriz de dos dimensiones.

Seguidamente, se declaran los componentes de la máquina sencilla. Que principalmente

son la Unidad de Datos, la Unidad de Control y la(s) memoria(s). De la declaración de

estos tres componentes habrá que modificar las señales que se asignan a sus puertos en

cada máquina sencilla.

Hay un componente, dbug, que se puede aprovechar totalmente y el alumno no lo tiene que

modificar.

Finalmente, en este código se hace una gestión de las señales que tienen que mostrarse

mediante leds o displays, y también se hace la selección del reloj. Utilizando la estructura


21

“with select – when” en función de los interruptores de la placa que están activos se escoge

la señal a mostrar por los 8 leds y por los 4 displays 7 segmentos y el reloj con el que

funciona la máquina.

3.1.2.16 MaquinaSencilla_test – Máquina Sencilla test bench

Este se trata de un código que implementa un test bech para poder simular la máquina

sencilla. Con este código se consigue dar unos valores a las señales de entrada de la

máquina sencilla:

- Al reloj de 50MHz se le asigna el periodo correspondiente.

- A la señal de reset se la inicializa a „1‟ y se pone a „0‟ pasados 100 ns.

- A los interruptores selectores de las señales a mostrar y del reloj utilizado se

le asignan “0x03”. Básicamente para que, en a simulación, la máquina

funcione con el reloj de 50 MHz.

3.1.2.17 MaquinaSencilla.ucf – Máquina Sencilla ucf

Este es el código que forma el archivo .ucf de la máquina sencilla. La función de este

archivo es unir los puertos de la máquina sencilla con I/Os de la placa Spartan – 3. El

código es totalmente aprovechable, el alumno sólo tiene que saber a qué I/Os se ha

asignado cada puerto. En la imagen se pueden ver dónde se ha asignado cada puerto de la

máquina sencilla.

1) dbug_led. Displays 7 segmentos.

2) dbug_in. 8 Leds.

3) rst. Señal de reset

4) clk_user. Reloj manual.

5) sw[5:3]. Interruptores que seleccionan la señal a mostrar por los 4 displays 7

segmentos

6) sw[2:1]. Interruptores que seleccionan la señal a mostrar por los 8 leds.

7) sw[0]. Interruptor que selecciona el reloj con el que funciona la máquina

sencilla. „1‟ para 50 MHz y „0‟ para reloj manual.

En la implementación del reloj manual, surgió un problema de síntesis. El sintetizador no

dejaba utilizar los buses dedicados de reloj de la FPGA a este reloj. Así que hubo que


22

describir específicamente que, el reloj manual no utilizaría las rutas dedicadas a la señal de

reloj.

3.2 Manual de Prácticas

Uno de los objetivos de este proyecto ha sido redactar un manual de prácticas para el

alumno.

El manual de prácticas que se ha redactado es un manual pensado para que el alumno,

siguiendo todos los pasos que se marcan, llegue a implementar la máquina sencilla de

ejemplo.

Pero cómo el alumno tendrá que implementar otra máquina sencilla distinta, en el manual

están indicadas las modificaciones típicas que hay que hacer para implementar distintas

máquinas sencillas. Por ejemplo, en la máquina sencilla de ejemplo sólo hay memoria

RAM, pero hay máquinas sencillas que también tienen memoria ROM, pues en el manual

se ha indicado cómo se haría para implementar una memoria ROM. Otro ejemplo, la ALU

no es siempre la misma en cada máquina sencilla, cada máquina sencilla tiene su propia

ALU, pues en el manual se dan unas indicaciones de cómo habría que modificar el código

para implementar una ALU con otras operaciones aritmético lógicas. Así pues, en general,

en el manual se describen las modificaciones que hay que hacer en los códigos genéricos

de partida para implementar distintas máquinas sencillas.

En el manual, también se explica cómo utilizar las distintas herramientas del programa

Xilinx ISE 12.3. Y todo de la manera más entendedora posible, con imágenes, esquemas,

etc.

El manual se encuentra anexo al final de esta memoria del proyecto, en el apartado 6

Anexo Manual de Prácticas.

3.3 Proceso General de Implementación de la Máquina Sencilla

En este apartado se describe, sin entrar en detalles, el proceso general para implementar

máquinas sencillas que se ha seguido durante el proyecto. Que es el mismo proceso que se

describe en el manual de prácticas con todo tipo de detalles. Por lo tanto, es el proceso de

implementación que deberá seguir el alumno en las prácticas.

En general, se sigue una metodología de diseño ascendiente (bottom-up). Porque primero

se diseñan los bloques de menos nivel en la jerarquía, y se va subiendo de nivel.

Como ya se ha explicado en el anterior apartado, el alumno parte con unos códigos en

VHDL que son bloques genéricos de toda máquina sencilla.

El componente de la máquina sencilla, se ha subdividido en 3 componentes principales: la

Unidad de Datos, la Unidad de Control y la memoria.

3.3.1 Unidad de Datos

El primer bloque que se diseña es la Unidad de Datos. Para ello, siguiendo con el método

bottom-up, primero se diseñan todos los componentes internos de la UD.

A partir de los códigos de partida reg, reg1, mux2, mux4, ALU y UD se crean sus

respectivos archivos VHDL.


23

En el archivo UD.VHDL se declaran, por defecto, todos los componentes de la UD. Así

que lo que hay que hacer en el archivo UD.VHDL es:

- Configurar bloques. En cada máquina sencilla hay una Unidad de Datos

diferente, no todas tienen los mismos componentes. Así que hay que

añadir/eliminar registros y multiplexores y darle el tamaño adecuado en bits.

- Rediseñar a ALU según la máquina sencilla en cuestión.

- Configurar puertos y señales. Añadir/modificar/eliminar puertos y señales

del bloque UD según los bloques que se han utilizado en la UD.

- Configurar puertos dbug. Añadir/modificar/eliminar los puertos de debug

necesarios para la UD en cuestión.

3.3.2 Unidad de Control

A partir del código de partida llamado UC se crea su respectivo archivo VHDL. En este

archivo, lo que hay que hacer es:

- Configurar puertos. Con cada máquina sencilla varían las señales de

control que la UC manda hacia la UD y la memoria. Como también varían

las señales de entrada a la UC. Así que hay que añadir/modificar/eliminar

los puertos que hay por defecto en el archivo UC.VHDL.

- Configurar señales. En el archivo por defecto, y en todas las Unidades de

Control, hay dos señales:

La señal “o”, que almacena los bits de control de la UC. De esta

señal hay que modificar su tamaño en bits. Porque las no todas las

máquinas sencillas tienen la misma cantidad de bits de control de

salida.

La señal “s”, que almacena el estado actual de la Unidad de Control.

De esta señal hay que modificar sus posibles valores, que son los

posibles estados en los que puede estar la máquina sencilla: S0, S1,

S2, etc.

- Configurar la máquina de estados. Por defecto, está implementada la

máquina de estados de la máquina sencilla de ejemplo. Se tiene que

modificar la secuencia de estados según el grafo de estados de la máquina

sencilla en cuestión.

- Configurar la tabla con los bits de control. Se tiene que modificar la tabla

con los bits de control que hay implementada por defecto, y asignar un

estado de los bits de control para cada estado.

- Configurar dbug_state. Se trata de un puerto de salida de la UC para saber

en qué estado se encuentra la máquina sencilla cuando se ha implementado

físicamente. Hay que dar un valor numérico a cada estado.

3.3.3 Memoria

Según el tipo de memoria de la máquina sencilla, según si es RAM y/o ROM, se crean los

ficheros VHDL a partir de los códigos RAM y ROM, respectivamente.

Estos dos archivos son muy genéricos, y sirven para cualquier máquina sencilla. Así que

no se ha de modificar nada.


24

A parte de el archivo de memoria en sí, hay que crear un archivo auxiliar, un paquete. Cada

tipo de memoria tiene su paquete que es, RAM_pack y ROM_pack respectivamente.

De estos dos archivos auxiliares, sí que hay que modificar una pequeña parte. La función

de estos paquetes, aparte de otras, es determinar el tamaño del bus de datos y bus de

direcciones de la memoria. Así que hay que configurar sus tamaños en función de la

máquina sencilla en cuestión.

3.3.4 MáquinaSencilla.VHDL

Por último, hay que crear el archivo MáquinaSencilla.VHDL a partir del código

MáquinaSencilla. Este es el bloque de máxima jerarquía, y abarca todos los bloques

creados hasta el momento: UD, UC y memoria(s). Aparte, contiene el bloque llamado dbug.

Lo que hay que hacer en este archivo es:

- Configurar señales. Todas las señales que conectan UD con UC y con

memoria(s) hay que añadirlas/modificarlas/eliminarlas.

- Configurar inicialización de memoria. La inicialización de la memoria es

el programa que ejecutará la máquina sencilla, hay que crear un programa

que la máquina sencilla en cuestión entienda.1

- Configurar señales dbug. A final del código, se determina qué señales se

mostrarán por los leds y LCDs de la placa Spartan-3. Hay que

modificar/añadir/eliminar las señales que interese debugear.

Finalmente, hay que crear el archivo MaquinaSencilla.ucf. Se trata del archivo que une

puertos de la máquina sencilla con I/Os de la placa Spartan-3. De este archivo no se tiene

que modificar nada, pero sí saber cuáles son las uniones que se hacen. En el manual de

prácticas que explican estas uniones.

Una vez se llega a este punto, el siguiente paso es simular la máquina sencilla.

3.3.5 Simulación

Antes de simular se tiene que crear el archivo tipo test bench para dar unos valores

iniciales a los puertos de entrada de la máquina sencilla. El fichero se crea a partir del

código de partida llamado maquinasencilla_test. Este código no hace falta que lo

modifique el alumno, es totalmente aprovechable.

Una vez creado el archivo, se puede pasar a simular la máquina con el programa iSIM

Simulator.

En la simulación se comprueba el buen funcionamiento de la máquina sencilla, se observa

que la secuencia de estados sea la esperada según el programa, que la memoria RAM

almacene correctamente los resultados esperados con la ejecución del programa, que los

registros vayan tomando los valores esperados, etc.

Cuando se determina que la simulación es correcta, y que por lo tanto, la máquina sencilla

funciona correctamente, se pasa a implementar físicamente la máquina sencilla, es decir,

programar la FPGA.

1Es decir, crear un programa con instrucciones propias de la máquina sencilla en cuestión.


25

3.3.6 Programación de la FPGA

Primero se crea el archivo de programación con la herramienta Generate Programming

File, y luego se pasa a programar la FPGA con el software ISE iMPACT.

Una vez programada la FPGA, gracias a las señales dbug se pueden observar las señales

internas de la máquina sencilla, y por lo tanto, se puede comprobar que: siga la misma

secuencia de estados que en la simulación, que los registros vayan tomando los mismos

valores que en la simulación, etc.

Una vez se ha comprobado el buen funcionamiento, ya se ha implementado la máquina

sencilla en la FPGA correctamente.

3.4 Las Máquinas Sencillas Implementadas

Todas las máquinas sencillas implementadas se han extraído de los exámenes de años

anteriores de la asignatura Sistemas Digitales I. Así que las máquinas sencillas no se han

diseñado desde cero.2

3.4.1 Máquina Sencilla 1

Se trata de la máquina sencilla de ejemplo. Es la primera máquina sencillas que todos los

alumnos implementarán a modo de ejemplo. Es la máquina sencilla que se implementa si

se siguen todos los pasos del Manual de Prácticas.

La máquina presenta la siguiente Unidad de Datos.

Figura 4. Unidad de Datos de la MS1

2Pero en algunos casos, se ha encontrado algún error en la solución y se ha rediseñado alguna parte.


26

Las operaciones que puede realizar la ALU son:

ALU1 ALU0 Operación

0 0 A+B

0 1 A xor B

1 0 B

1 1 -

Tabla 1. Operaciones ALU MS1

El juego de instrucciones de esta máquina es el siguiente:

- Suma

ADD F,D (D) ← (D)+(F)

FZ ← 1 si (D)+(F)=0

Formato:

CO1 CO0 F6 F5 F4 F3 F2 F1 F0 D6 D5 D4 D3 D2 D1 D0

0 0 @F @D

- Movimiento

MOV F,D (D) ← (F)

FZ ← 1 si (F)=0

Formato:


0 1 @F @D

- Comparación

CMP F,D FZ ← 1 si (F)-(D)=0

Formato:


1 0 @F @D

- Salto

BEQ D PC ← D si FZ = 1

Formato:


1 1 X @D

La Unidad de Control se puede interpretar como la siguiente máquina de estado finitos:


27

Figura 5. Máquina de Estados de la MS1

La tabla con los bits de control es la siguiente:

MX1 MX0 ALU1 ALU0 R*/W en_PC en_IR en_A en_B en_FZ

S0 0 0 X X 0 1 1 0 0 0

S12 1 0 X X 0 0 0 0 1 0

S6 1 1 X X 0 0 0 1 0 0

S7 1 1 0 0 1 0 0 0 0 1

S9 X X 0 1 0 0 0 1 0 0

S10 1 1 1 0 1 0 0 0 0 1

S11 1 1 X X 0 1 1 0 0 0

Tabla 2. Bits de Control MS1

En el Manual de Prácticas, el programa que se propone para que lo ejecute la máquina

sencilla es el siguiente:

Dirección

en hex.

Instrucción

Ensamblador Binario Hexadecimal

0 MOV 0,c 1011010011100110 B4E6

1 MOV 0,i 1011010011100111 B4E7

2 CMP i,b 0111001111100101 73E5

3 BEQ end 1100000000001000 C008

4 ADD a,c 0011001001100110 3266

5 ADD l,i 0011000001100111 3467

6 CMP 0,0 0111010011101001 74E9

7 BEQ while 1100000000000010 C002

8 BEQ 8 1100000000001000 C008

… … … …

64 Operando a 0000000000000011 0003

65 Operando b 0000000000000100 0004

68 Número 1 0000000000000001 0001

69 Número 0 0000000000000000 0000

Tabla 3. Programa MS1


28


Se trata de la máquina sencilla del examen de Febrero de 2002.

La Unidad de Datos de esta máquina tiene registros de propósito general X, Y, el registro

acumulador A y los registros IR y PC.


La ALU, como se puede observar en la imagen, puede realizar las operaciones de suma,

multiplicación o transferir la entrada I1.

El juego de instrucciones de esta máquina sencilla es el siguiente:

- Cargar el registro A

LDA F A ← (F)

Formato:

CO1 CO0 F13 F12 F11 F10 F9 F8 F7 F6 F5 F4 F3 F2 F1 F0

0 0 @F

- Guardar el registro A en memoria

STA D (D) ← A

Formato:

CO1 CO0 D13 D12 D11 D10 D9 D8 D7 D6 D5 D4 D3 D2 D1 D0

0 1 @D


29

- Saltar a la dirección

JMP D IR ← (D)

PC = D+1

Formato:

CO1 CO0 D13 D12 D11 D10 D9 D8 D7 D6 D5 D4 D3 D2 D1 D0

1 0 @D

- Mover dato de una dirección a otra

MOV F,D (D) ← (F)

Formato:


1 1 @F

0 X @D

- Multiplicar y acumular

MAC F,D A ← A+ (F)*(D)

Formato:


1 1 @F

1 X @D




30


en_PC en_IR en_A en_X en_Y MX_@ MX_D MX_I1 ALU1 ALU0 R*/W

S0 1 1 0 0 0 1 0 X X X 0

S1 0 0 0 1 0 0 0 X X X 0

S2 0 0 1 0 0 0 0 X X X 0

S3 0 0 0 0 0 0 X 0 0 0 1

S4 1 1 0 0 0 0 0 X X X 0

S5 1 1 0 0 0 1 0 X X X 0

S6 0 0 0 0 1 0 0 X X X 0

S7 0 0 0 0 0 0 X 1 0 0 1

S8 0 0 0 0 1 X 1 1 1 1 0

S9 0 0 1 0 0 X 1 0 1 0 0

Tabla 4. Bits de Control de MS2

El programa que se ha implementado para que lo ejecute esta máquina sencilla es el

siguiente:

Dirección

en hex.

Instrucción


0 LDA 5 0000000000000101 0005

1 MOV 0,6 1100000000000100 C004

2 0000000000000110 0006

3 JMP 9 1000000000001001 8009

4 Número 0 0000000000000000 0000

5 Número 1 0000000000000001 0001

7 Número 3 0000000000000011 0003

8 Número 4 0000000000000100 0004

9 MAC 3,4 1100000000000111 C007

A 1100000000001000 C008

B STA 6 0100000000000110 4006

C JMP 12 1000000000001100 800C

Tabla 5. Programa de MS2


31



La Unidad de Datos de esta máquina un registro de propósito general B, el registro


El registro acumulador A es accesible por el usuario con varias instrucciones. El registro B

no es visible para el usuario.



transferir la entrada I1 o transferir la entrada I2.


- Mover de memoria al registro A

MOV A, d A ← (d)

Formato:

CO2 CO1 CO0 d12 d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0

0 0 0 @d


32

- Mover literal al registro A

MOV A, #d A ← d

Formato:


0 0 1 X

#d

- Mover de A a memoria

MOV d, A (d) ← A

Formato:


0 1 X @d

- Sumar A con un dato de memoria

ADD A, d A ← A + (d)

Z ← FZ

Formato:


1 0 0 @d

- Sumar A con un literal

ADD A, #d A ← A + d

Z ← FZ

Formato:


1 0 1 X

#d

- Salto incondicional

JMP d PC ← d

Formato:


1 1 0 @d

- Salto condicional

JZ d PC ← d; si Z=1

Formato:


1 1 1 @d


33




en_PC en_IR en_A en_B en_Z MX_@ MX_D ALU1 ALU0 R*/W

S0 1 1 0 0 0 0 1 X X 0

S1 0 0 0 1 0 1 1 X X 0

S2 0 0 1 0 0 1 1 X X 0

S3 1 0 1 0 0 0 1 X X 0

S4 1 0 0 1 0 0 1 X X 0

S5 0 0 1 0 1 X 0 1 X 0

S6 0 0 0 0 0 1 X 0 0 1

S7 1 1 0 0 0 1 1 X X 0

Tabla 7. Bits de Control de la MS3


34


siguiente:

Dirección

en hex.

Instrucción


0 MOV A,#5 0010000000000000 2000

1 Número 5 0000000000000101 0005

2 MOV 20,A 0100000000010100 4014

3 MOV A,@20 0000000000010100 0014

4 MOV 21,A 0100000000010101 4015

5 MOV A,@21 0000000000010101 0015

6 ADD A,@21 1000000000010101 8015

7 ADD A,#9 1010000000000000 A000

8 Número 9 0000000000001001 0009

9 JZ 0 1110000000000000 E000

A MOV 21,A 0100000000010101 4015

B JMP 11 1100000000001011 C00B

Tabla 8. Programa de la MS3


Se trata de la máquina sencilla del examen de Noviembre de 2008.

La Unidad de Datos de esta máquina un registro de propósito general T, el registro




transferir la entrada I1 o transferir la entrada I2.


35


- Salto condicional

JSZ d PC ← d; si FZ=1

Formato:

CO1 CO0 d5 d4 d3 d2 d1 d0

0 0 @d

- Guardar A en memoria

STA d (d) ← A

Formato:


0 1 @d

- Sumar A con un dato de la memoria

ADD d A ← A + (d)

FZ=1 si A + (d) = 0

Formato:


1 0 @d

- Multiplicar A por 2

MUL2 A ← 2*A

FZ=1 si 2*A = 0

Formato:

CO2 CO1 E d4 d3 d2 d1 d0

1 1 0 X

- Carga el registro A con un literal

LDA d A ← k

FZ=1 si k = 0

Formato:

CO2 CO1 E d4 d3 d2 d1 d0

1 1 1 X

k


36




en_PC en_IR en_T en_A en_FZ MX1 MX2 ALU1 ALU0 R*/W

S0 1 1 1 0 0 0 0 X X 0

S1 0 0 0 0 0 X X X X 0

S2 1 1 1 0 0 1 0 X X 0

S3 0 0 0 0 0 1 0 0 1

S4 0 0 1 0 0 1 0 X X 0

S5 0 0 0 1 1 X X 1 X 0

S6 0 0 1 0 0 X 1 0 0 0

S8 1 0 1 0 0 0 0 X X 0

S9 0 0 0 1 1 X X 0 1 0



37


siguiente:

Dirección

en hex.

Instrucción


0 LDA 5 11100000 E0

1 Número 5 05

2 JSZ 0 00000101 00

3 STA 12 01001100 4C

4 LDA 9 11100000 E0

5 #9 00001001 09

6 ADD 12 10001100 8C

7 MUL2 11000000 C0

8 STA 13 01001101 4D

9 LDA 0 11100000 E0

A #0 00000000 00

B JSZ 9 00001001 09



Se trata de la máquina sencilla del examen de Septiembre de 2003.

La Unidad de Datos de esta máquina un registro de propósito general B, C, el registro




38


resta, transferir la entrada A o transferir la entrada B.


- Cargar A con un inmediato

LDI A A ← dat

Formato:

CO2 CO1 CO1 d4 d3 d2 d1 d0

0 0 0 X X X X X

Dat[15:8]

Dat[7:0]

- Sumar el contenido de A con un inmediato

ADI A ← A + dat

Formato:


1 0 0 X X X X X

Dat[15:8]

Dat[7:0]

- Restar el contenido de A con un inmediato

SBI A ← A - dat

Formato:


1 1 0 X X X X X

Dat[15:8]

Dat[7:0]

- Cargar A con el contenido de una dirección de memoria

LDD addr A ← (addr)

Formato:


0 0 1 X X X X X

addr[15:8]

addr[7:0]

- Guardar el contenido del registro A a una dirección de memoria

STD addr (addr) ← A

Formato:


0 1 1 X X X X X

addr[15:8]

addr[7:0]


39

- Sumar el contenido de A con el dato de una dirección de memoria

ADD addr A ← A + (addr)

Formato:


1 0 1 X X X X X

addr[15:8]

addr[7:0]

- Restar el contenido de A con el dato de una dirección de memoria

SBD addr A ← A - (addr)

Formato:


1 1 1 X X X X X

addr[15:8]

addr[7:0]




40


eIR ePC eCH eCL eAH eAL eBH eBL MX@ MXC MXO ALU1 ALU0 R*/W

S0 1 1 0 0 0 0 0 0 0 X X X X 0

S1 0 1 1 0 0 0 1 0 0 0 X X X 0

S2 0 1 0 1 0 0 0 1 0 0 X X X 0

S3 0 0 1 1 0 0 1 0 1 1 X X X 0

S4 0 0 0 0 0 0 0 1 1 X X X X 0

S5 0 0 0 0 1 1 0 0 X X X 0 1 0

S6 0 0 1 1 0 0 0 0 1 1 1 0 0 1

S7 0 0 0 0 0 0 0 0 1 X 0 0 0 1

S8 0 0 0 0 1 1 0 0 X X X X 0 0

S9 0 0 0 0 1 1 0 0 X X X X 1 0



siguiente:

Dirección

en hex.

Instrucción


0 LDI 5 00000000 00

1 Número 5

00000000 00

2 00000101 05

3 ADI 6 10000000 80

4 Número 6

00000000 00

5 00000110 06

6 SBI 3 11000000 C0

7 Número 3

00000000 00

8 00000011 03

9 STD 25 01100000 60

A Número 25

00000000 00

B 00100101 25

C LDD 40 00100000 20

D Número 40

00000000 00

E 01000000 40

F ADD 42 10100000 A0

10 Número 42

00000000 00

11 01000010 42

12 SBD 25 11100000 E0

13 Número 25

00000000 00

14 00100101 25

… … … …

40 Número 1

00000000 00

41 00000001 01

42 Número 7

00000000 00

43 00000111 07



41


Se trata de la máquina sencilla del examen de Diciembre de 2008.

La Unidad de Datos de esta máquina un registro de propósito general X, Y, el registro




resta o transferir la entrada I2.



JMP d PC ← d

Formato:


0 0 0 X X X X X

d

- Salto relativo

BRA d PC ← PC2 + d

Formato:


0 0 1 X X X X X

d


42

- Sumar dos inmediatos

ADD k1,k2 A ← k1 + k2

Formato:


0 1 0 X X X X X

k1

k2




en_PC en_IR en_A en_X en_Y MX1 MX2 ALU R*/W

S0 1 1 0 0 0 0 1 X 0

S1 1 0 0 0 1 0 1 X 0

S2 1 1 0 0 0 1 1 0 0

S3 0 0 0 1 1 X 0 0 0

S4 1 1 0 0 0 1 1 1 0

S5 1 0 0 1 1 0 1 0 0

S6 0 0 1 0 0 X X 1 0



43


siguiente:

Dirección

en hex.

Instrucción


0 ADD 3,2 01000000 40

1 Número 3 00000011 03

2 Número 2 00000010 02

3 BRA 5 00100000 20

4 Número 5 00000101 05

… … … …

A JMP 10 00000000 00

B Número 10 00001010 0A



Se trata de la máquina sencilla del examen de Noviembre de 2006.

La Unidad de Datos de esta máquina un registro de propósito general R, el registro




resta, transferir la entrada I1 o transferir la entrada I2.


44


- Cargar el registro A con un inmediato

LIA k A ← k

Formato:

d11 d10 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0 CO3 CO2 CO1 CO0

X X X X X X X X X X X X 0 0 0 1

k


JMP k PC ← k

Formato:


X X X X X X X X X X X X 1 0 0 1

k

- Guardar el contenido de A en memoria

STA k (k) ← A

Formato:


X X X X X X X X X X X X 1 1 0 1

k

X X X X X X X X X X X X X X 0 0

- Sumar el contenido de A con un inmediato

LIA +k A ← A+k

Formato:


X X X X X X X X X X X X 0 0 1 0

k

- Cargar en A, el contenido de la dirección de memoria que apunta (PC +

inmediato)

LRA +k A ← (PC+k)

Formato:


X X X X X X X X X X X X 0 1 1 0

k

- Salto relativo positivo

JMP +k PC ← PC+k

Formato:


X X X X X X X X X X X X 1 0 1 0

k


45

- Restar al contenido de A un inmediato

LIA -k A ← A-k

Formato:


X X X X X X X X X X X X 0 0 1 1

k

- Cargar en A, el contenido de la dirección de memoria que apunta (PC - inmediato)

LRA -k A ← (PC – k)

Formato:


X X X X X X X X X X X X 0 1 1 1

k

- Salto relativo negativo

JMP -k PC ← PC - k

Formato:


X X X X X X X X X X X X 1 0 1 1

k




46


en_PC en_IR en_A en_R MX_@ MX_A MX_I1 R*/W

S0 1 1 0 0 1 X X 0

S1 0 0 0 0 X X X 0

S2 1 0 1 0 1 1 0 0

S3 1 0 0 1 1 X 1 0

S4 0 0 1 0 0 0 X 0

S6 1 1 0 0 0 X X 0

S8 1 1 0 0 1 X X 0

S9 0 0 0 0 0 X 0 1



siguiente:

Dirección

en hex.

Instrucción


0 LIA 9 0000000000000001 0001

1 Número 9 0000000000001001 0009

2 LIA -3 0000000000000011 0003

3 Número3 0000000000000011 0003

4 LIA +7 0000000000000010 0002

5 Número 7 0000000000000111 0007

6 STA 20 0000000000001101 000D

7 Número 20 0000000000100000 0020

8 0000000000000000 0000

9 LRA -5 0000000000000111 0007

A Número 5 0000000000000101 0005

B LRA +2 0000000000000110 0006

C Número 2 0000000000000010 0002

D STA 21 0000000000001101 000D

E Número21 0000000000100001 0021

F 0000000000000000 0000

10 JMP +5 0000000000001010 000A

11 Número 5 0000000000000101 0005

12 JMP 12 0000000000001001 0009

13 Número 12 0000000000010010 0012

… … … …

16 JMP -5 0000000000001011 000B

17 Número 5 0000000000000101 0005



47



La Unidad de Datos de esta máquina un registro acumulador A y los registros IR, PC y FZ.



resta, transferir la entrada I1 o transferir la entrada I2.


- Cargar el registro A con el dato de una dirección de memoria

MOV d A ← (d)

Formato:

CO2 CO1 CO0 d9 d8 d7 d6 d5 d4 d3 d2 d1 d0

0 0 0 d

- Cargar el registro A con un inmediato

MOV #k A ← k

Formato:


0 0 1 X X K


48

- Sumar al registro A un dato de una dirección de memoria

MOV d A ← A + (d)

Formato:


0 1 0 d


STO d (d) ← A

Formato:


1 0 X d


JMP d PC ← d

Formato:


1 1 0 X X X X X X X X X X

- Sumar al registro A un inmediato

ADD #k A ← A + k

Formato:


0 1 1 X X K


49




en_PC en_IR en_A en_Z MX_@ MX_A MX_I2 ALU1 ALU0 R*/W

S0 1 1 0 0 0 X X X X 0

S1 0 0 0 0 X X X X X 0

S2 0 0 1 1 1 0 0 0 1 0

S3 0 0 1 0 X 1 X X X 0

S4 0 0 1 1 1 0 0 1 X 0

S5 0 0 1 1 X 0 1 1 X 0

S6 0 0 0 1 1 X X 0 0 1

S7 1 1 0 0 1 X X X X 0

S8 1 0 0 0 0 X X X X 0



50


siguiente:

- Memoria ROM:

Dirección

en hex.


0 MOV #4 0010000000100 0804

1 ADD #5 0110000000101 1805

2 STO 2 1000000000010 1002

3 ADD 1 0100000000001 0801

4 SKPZ 1110000000000 1C00

5 MOV 0 0000000000000 0000

6 SKPZ 1110000000000 1C00

7 JMP 8 1100000001000 1808

Tabla 18. Programa en ROM de la MS8

- Memoria RAM: Dirección

en hex.


0 #0 00000000 00

1 #1 00000001 01

Tabla 19. Programa en RAM de la MS8


51



La Unidad de Datos de esta máquina un registro de propósito general R, un registro




resta, transferir la entrada I, transferir la entrada R o restar 1 a la entrada I.


- Mover al registro A un inmediato

MOV d A ← d

Formato:

CO2 CO1 CO0 d7 d6 d5 d4 d3 d2 d1 d0

0 0 0 d


52

- Cargar el registro A con un dato de la memoria

LDA d A ← (d)

Formato:


0 0 1 d


STA d (d) ← A

Formato:


0 1 X d

- Sumar al registro A un dato de una dirección de memoria

ADD d A ← A + (d)

Formato:


1 0 0 d

- Restar al registro A un dato de una dirección de memoria

SUB d A ← A - (d)

Formato:


1 0 1 d

- Salto relativo

BRA d PC ← PC + d

Formato:


1 1 0 d


JMP d PC ← d

Formato:


1 1 1 d


53




eIR ePC eA eR MX@1 MX@2 MXR1 MXR0 MXI ALU2 ALU1 ALU0 R*/W

S0 1 1 0 0 0 0 X X X X X X 0

S1 0 0 0 1 1 1 0 1 X X X X 0

S2 0 0 1 0 1 1 1 1 X X X X 0

S3 0 0 1 0 1 1 0 1 X X X X 0

S4 0 0 0 0 1 1 X X 0 0 0 0 1

S5 0 0 1 0 X X 0 0 0 0 1 0 0

S6 0 0 1 0 X X 0 0 0 0 1 1 0

S7 0 0 0 1 1 1 1 1 X X X X 0

S8 0 0 1 0 0 0 1 1 0 X X X 0

S9 1 1 0 0 1 0 1 1 1 0 1 0 0

S10 1 1 0 0 1 0 X X X 0 0 1 0



54


siguiente:

- Memoria ROM:

Dirección

en hex.


0 MOV #5 00000000101 005

1 STA 0 01000000000 200

2 LDA 1 00100000001 101

3 ADD 2 10000000010 402

4 SUB 3 10100000011 503

5 BRA 5 11000000101 605

… … … …

A JMP 4 11100000100 704

Tabla 21. Programa en ROM de la MS9

- Memoria RAM: Dirección

en hex.


1 #9 00001001 09

2 #1 00000001 01

3 #7 00000111 07

4 #10 00001010 0A

Tabla 22. Programa en RAM de la MS9



La Unidad de Datos de esta máquina un registro de propósito general T, dos registros

acumuladores X e Y, y los registros IR y PC.



55


resta, transferir la entrada B o sumar 1 a la entrada A.


- Cargar al registro X un inmediato

LDIX d X ← d

Formato:

CO3 CO2 CO1 CO0 d3 d2 d1 d0

0 0 0 0 X

d

- Cargar al registro Y un inmediato

LDIY d Y ← d

Formato:


0 0 0 1 X

d

- Cargar al registro X un dato de memoria

LDDX d X ← (d)

Formato:


0 0 1 0 X

d

- Cargar al registro Y un dato de memoria

LDDY d Y ← (d)

Formato:


0 0 1 1 X

d

- Sumar al registro X un inmediato

ADIX d X ← X+ d

Formato:


0 1 0 0 X

d

- Sumar al registro Y un inmediato

ADIY d Y ← Y + d

Formato:


0 1 0 1 X

d


56

- Sumar al registro X un dato de memoria

ADDX d X ← X + (d)

Formato:


0 1 1 0 X

d

- Sumar al registro Y un dato de memoria

ADDY d Y ←Y + (d)

Formato:


0 1 1 1 X

d

- Restar al registro X un inmediato

SBIX d X ← X - d

Formato:


1 1 0 0 X

d

- Restar al registro Y un inmediato

SBIY d Y ← Y - d

Formato:


1 1 0 1 X

d

- Sumar al registro X un dato de memoria

SBDX d X ← X - (d)

Formato:


1 1 1 0 X

d

- Sumar al registro Y un dato de memoria

SBDY d Y ←Y - (d)

Formato:


1 1 1 1 X

d

- Sumar 1 al registro X

INCX X ← X +1

Formato:


1 0 X 0 X


57

- Sumar 1 al registro Y

INCY Y ←Y + 1

Formato:


1 0 X 1 X




eIR ePC eX eY eT MX1 MX2 MX3 ALU1 ALU0 R*/W

S0 1 1 0 0 0 0 X 0 X X 0

S1 0 0 0 0 0 X X X X X 0

S3 0 1 0 0 1 0 X 0 X X 0

S4 0 0 1 0 0 X X 1 1 1 0

S5 0 0 0 1 0 X X 1 1 1 0

S6 0 0 1 0 0 X 0 1 0 0 0

S7 0 0 0 1 0 X 1 1 0 0 0

S8 0 0 0 0 1 1 X 0 X X 0

S9 0 0 1 0 0 X 0 1 0 1 0

S10 0 0 0 1 0 X 1 1 0 1 0

S11 0 0 1 0 0 X 0 1 1 0 0

S12 0 0 0 1 0 X 1 1 1 0 0



58


siguiente:

Dirección

en hex.


0 LDIX #5 00000000 00

1 #5 00000101 05

2 LDIY #5 00010000 10

3 #5 00000101 05

4 LDDX 64 00100000 20

5 @64 01000000 40

6 LDDY 64 00110000 30

7 @64 01000000 40

8 ADIX 4 01000000 40

9 #4 00000100 04

A ADIY 01010000 50

B #4 00000100 04

C ADDX 01100000 60

D @64 01000000 40

E ADDY 01110000 70

F @64 01000000 40

10 SBIX 10 11000000 C0

11 #10 00001010 0A

12 SBIY 10 11010000 D0

13 #10 00001010 0A

14 SBDX 64 11100000 E0

15 @64 01000000 40

16 SBDY 64 11110000 F0

17 @64 01000000 40

18 INCX 10000000 80

19 INCY 10010000 90

… … … …

40 #9 00001001 09


Prácticas de Máquina Sencilla con FPGA Conclusiones

59

4 Conclusiones

A continuación se hace un resumen de las conclusiones más importantes que se pueden

extraer de este proyecto:

- De las 10 máquinas sencillas que se han implementado, hay algunas más

complicadas que otras. Bien porque tienen más componentes de por sí. O porque

tiene más instrucciones y por lo tanto la máquina de estados se complica más. O

porque tiene memoria RAM y memoria ROM. O porque en la Unidad de Datos hay

más interconexiones entre componentes, etc.

- Cuando se le coge práctica implementando máquina sencillas, se puede

implementar una máquina sencilla nueva en 2 horas. El tiempo de implementación

de la primera máquina sencilla, cuando aún no se tiene experiencia, se estima que

pueda tardar de 4 a 6 horas en implementar y comprobar que funciona

correctamente.

- Finalmente, se han conseguido preparar unas prácticas de máquina sencilla bastante

didácticas e interactivas. Sobre todo por la interactividad conseguida en la

implementación física, gracias al reloj manual, a los leds y a los displays 7

segmentos.

Estas prácticas se espera que ayuden mucho al alumno a acabar de entender

perfectamente el funcionamiento de la máquina sencilla.

- Hay un aspecto que puede hacer dudar al alumno de si la máquina sencilla funciona

bien. Y es el hecho de que en la simulación se pueden ver “X”, es decir, valores

indeterminados, y en la realidad no. Este punto ya se explica en el manual de

prácticas, pero es importante remarcarlo.

- Se espera que con el manual de prácticas el profesor de prácticas se ahorre muchas

explicaciones. Aún así, hay máquinas sencillas que tienen particularidades que

quizá el alumno no es capaz de resolver con la ayuda del manual. Es importante la

presencia de un profesor que guíe a los alumnos en esos detalles.

- En las prácticas el alumno recibirá el enunciado de la máquina sencilla, pero no el

grafo de estados, ni la tabla con los bits de control. El alumno tendrá que resolver

primero el ejercicio teóricamente, e implementar la máquina a partir de esa

solución. Así que conviene que esa solución teórica esté bien hecha. Quizá la

resolución del enunciado podría ser una estudio previo de la práctica.

- En las resoluciones teóricas que habían hechas previamente a este proyecto, se han

detectado algunos errores en los bits de control. En la memoria descriptiva de este

proyecto se ha puesto la solución correcta.

Prácticas de Máquina Sencilla con FPGA Posibles Mejoras

60

5 Posibles Mejoras

A continuación se hace un listado de las posibles mejoras que podría recibir este proyecto:

- La actual placa de pruebas, Starter Board Kit de Xilinx, sólo tiene 4 displays de 7

segmentos. Pero hay placas que tienen pantallas LCD. Una mejora sería utilizar

estas pantallas, porque en esas pantallas se puede mostrar mucha más información a

la vez que con los 4 displays 7 segmentos.

- Las máquinas sencillas implementadas están pensadas para resolverse en un

examen de 1h. Y por lo tanto, algunas tienen un juego de instrucciones muy

reducido, o el conjunto de instrucciones no da para realizar un programa que tenga

algo de sentido. Una posible mejora sería rediseñar las máquinas sencillas para

poder tener juegos de instrucciones más amplios y que den la posibilidad de crear

programas que tengan algo de sentido.

- En la implementación física que se hace, se puede observar cualquier señal y

registro interno de la máquina sencilla excepto las celdas de memoria. Un mejora

sería adaptar la implementación para que se pueda observar el contenido de las

memorias de la máquina sencilla.

- Para hacer la implementación física aún más interactiva, se podría diseñar un

software que adquiriese datos de la máquina sencilla que se ha implementado

físicamente para representar la Unidad de Datos gráficamente en el ordenador

observar desde ahí como circulan las distintas señales y datos por la máquina

sencilla. Para enviar información de la placa de pruebas al ordenador se puede usar

el cable RS 232.

Prácticas de Máquina Sencilla con FPGA Anexo Manual de Prácticas

61

6 Anexo Manual de Prácticas3

Prácticas de Máquina Sencilla

Manual de Prácticas

3 El encabezado y número de página es el correspondiente a la memoria y no a manual


62

0 Índice4

1 Introducción Pág. 4

2 Archivos VHDL de Partida Pág. 4

3 Jerarquía de los Archivos VHDL de Partida Pág. 6

4 Proceso General de Implementación Pág. 6 4.1 Unidad de Datos Pág. 6

4.2 Unidad de Control Pág. 7

4.3 Memoria Pág. 7

4.4 MáquinaSencilla.VHDL Pág. 7

4.4 MáquinaSencilla.VHDL Pág. 7

4.5 Simulación Pág. 8

4.6 Programación de la FPGA Pág. 8

5 La Máquina Sencilla Pág. 9 5.1 Enunciado Pág. 9

5.2 Programa a Ejecutar Pág. 11

6 Implementación de la Máquina Sencilla Pág. 12 6.1 Creación del Proyecto Pág. 12

6.2 Unidad de datos Pág. 12

6.2.1 Creación de ficheros Pág. 12

6.2.2 Diseño de la ALU Pág. 13

6.2.3 UD.VHDL Pág. 13

6.2.4 Análisis del Código UD.VHDL Pág. 13

6.3 Unidad de Control Pág. 15

6.3.1 Análisis del código UC.VHDL Pág. 15

6.4 Memorias Pág. 16

6.4.1 Memoria RAM Pág. 16

6.4.2 Análisis de RAM_pack y ROM_pack Pág. 16

6.5 MaquinaSencilla.VHDL Pág. 16

6.5.1 Análisis MaquinaSencilla.VHDL Pág. 16

6.6 Simulación Pág. 19

6.6.1 Comprobación del buen funcionamiento Pág. 23

6.7 Programación de la FPGA Pág. 23

6.7.1 Comprobación del buen funcionamiento Pág. 28

Anexo 1 Crear proyecto Pág. 29

Anexo 2 Crear archivos VHDL,

paquetes, ucf y test_bench Pág. 30 Anexo 2.1 Crear Archivo VHDL Pág. 30

Anexo 2.2 Crear Archivo VHDL package Pág. 31

4 La página indicada en el índice no se corresponde con el número de la página porque la numeración de este

documento es la numeración de la memoria, y no la del manual de prácticas.


63

Anexo 2.3 Crear Archivo MaquinaSencilla_test Pág. 32

Anexo 2.4 Crear Archivo MaquinaSencilla.ucf Pág. 34

Anexo 3 Análisis de la ALU Pág. 34

Anexo 4 Lenguaje VHDL Pág. 39 Anexo 4.1 Puertos Pág. 39

Anexo 4.2 Señales Pág. 39

Anexo 4.3 Determinar Tamaño de Vectores de Bits Pág. 40

Anexo 4.4 Palabra Others y valor „X‟ Pág. 40

Anexo 4.5 With select – when Pág. 41

Anexo 4.6 Process – end process Pág. 41

Anexo 4.7 When y case is - when Pág. 41

Anexo 4.8 Concatenación Pág. 42

Anexo 5 Check syntax Pág. 42

Anexo 6 Sintaxis para Declarar Componentes Pág. 43

Anexo 7 Port map de cada Componente Pág. 44

Anexo 8 Análisis de UD.VHDL Pág. 45 Anexo 8.1 Puertos de la UD Pág. 45

Anexo 8.2 Bus de direcciones Pág. 46

Anexo 8.3 Señales de la UD Pág. 46

Anexo 8.4 Comportamiento de UD.VHDL Pág. 46

Anexo 9 Análisis de UC.VHDL Pág. 48 Anexo 9.1 Puertos de UC.VHDL Pág. 48

Anexo 9.2 Señales de UC.VHDL Pág. 49

Anexo 9.3 Análisis Máquina de Estados de UC.VHDL Pág. 50

Anexo 9.4 Implementación de la Tabla con los Bits de Control Pág. 51

Anexo 9.5 El Puerto dbug_state Pág. 52

Anexo 10 Análisis RAM_pack y ROM_pack Pág. 52

Anexo 11 Inicialización de Memoria Pág. 53

Anexo 12 Gestión de Puertos de MaquinaSencilla.VHDL Pág. 54

Anexo 13 Sintetizar un Diseño Pág. 56

Anexo 14 Implementar un Diseño Pág. 57

Anexo 15 Cuando no Coincide Simulación y Realidad Pág. 58


64

1 Introducción Este manual de prácticas pretende ser una guía para que el alumno pueda implementar

cualquier máquina sencilla en una FPGA. La FPGA que utiliza el alumno es de la familia

Spartan – 3 de Xilinx, y está integrada en el Starter Board kit de Xilinx. Así que, para

programar esa FPGA se requiere del uso del programa Xilinx ISE. La versión utilizada en

este manual es la 12.3.

Este manual parte de la base que el alumno tiene distintos archivos de texto con código en

VHDL. Estos archivos contienen distintos genéricos de máquinas sencillas. La idea es que

modificando estos códigos el alumno pueda implementar distintas máquinas sencillas.

2 Archivos VHDL de Partida Los ficheros de texto con código VHDL que el alumno tendrá son bloques genéricos de las

máquinas sencillas en general. Y son:

- UD

Unidad de Datos. Se trata de una Unidad de Datos genérica.

- UC

Unidad de Control. Se trata de una Unidad Control genérica.

- Reg1

Registro de 1 bit.

- Reg

Registro. A cada registro se le puede determinar, individualmente, su tamaño en

bits .

- Mux4


individualmente, el tamaño de sus entradas/salida en bits.

- Mux2


individualmente, el tamaño de sus entradas/salida en bits.

- Inc

Incrementador. Se trata del bloque “+1” que siempre suele ir adjunto al registro

“PC”.

- ALU

Unidad Aritmético-Lógica. Este es un archivo ejemplo, cada máquina sencilla tiene

su propia ALU. Aunque este archivo puede servir de pauta.

- RAM

Memoria RAM de la máquina sencilla. El alumno no hace falta que modifique este

archivo, puesto que este archivo es suficientemente genérico para que funcione en


- RAM_pack

Paquete de la memoria RAM. Se trata de un archivo auxiliar para la memoria. En

este archivo, el Alumno sí tiene que hacer alguna modificación según la máquina


- ROM

Memoria ROM de la máquina sencilla. El alumno no hace falta que modifique este

archivo, puesto que este archivo es suficientemente genérico para que funcione en



65

- ROM_pack

Paquete de la memoria ROM. Se trata de un archivo auxiliar para la memoria. En

este archivo, el alumno sí tiene que hacer alguna modificación según la máquina


- MaquinaSencilla

La máquina sencilla. Es el archivo que recoge todos los componentes: UD, UC y

memoria(s).

- MaquinaSencilla_test

Se trata de un archivo necesario para poder simular la máquina sencilla en cuestión.

El alumno no tiene que modificar nada de este archivo.

- Led7seg

Led de 7 segmentos. Se trata de un archivo necesario para poder utilizar los

displays de 7 segmentos que tiene el kit de la Spartan-3. El alumno no tiene que

modificar nada.

- Dbug

Debug. Se trata de un archivo donde se gestionan las señales que se mostrarán

mediante leds o los displays. El alumno no tiene que modificar nada.

El alumno dispondrá también de un archivo que no es .VHDL, sino .ucf:

- MaquinaSencilla.ucf

Este archivo se encarga indicar a qué entradas/salidas de kit de la Spartan-3 van

conectadas los distintos puertos de la máquina sencilla. Une los distintos puertos de

la máquina sencilla con interruptores, leds y displays de la Starter Board. Por

ejemplo, une el puerto de reset con el interruptor “L14”. El alumno no hace falta

que modifique nada de este archivo. Pero sí saber en qué interruptor están

asignadas las distintas señales de la máquina sencilla.


66

3 Jerarquía de los Archivos VHDL de Partida En la siguiente imagen se observa la jerarquía de los archivos de partida:

Figura 1. Jerarquía de Componentes

Esta jerarquía hay que tenerla presente en todo el diseño de la máquina sencilla. Hay que

saber en todo momento en qué nivel de la jerarquía se está trabajando.

En este manual de prácticas, la secuencia de diseño que se propone es ascendente, bottom-

up. Además el orden de abajo a arriba según se ha dibujado en la jerarquía. Se empieza con

el componente reg y se acaba con maquinasencilla_test. En el siguiente apartado de este

manual se describe la secuencia de diseño general que se seguirá par implementar la

máquina sencilla.

4 Proceso General de Implementación En general, se sigue una metodología de diseño ascendiente (bottom-up). Porque primero

se diseñan los bloques de menos nivel en la jerarquía, y se va subiendo de nivel.

El componente de la máquina sencilla, se ha subdividido en 3 componentes principales: la

Unidad de Datos, la Unidad de Control y la memoria.

4.1 Unidad de Datos

El primer bloque que se diseña es la Unidad de Datos. Para ello, siguiendo con el método

bottom-up, primero se diseñan todos los componentes internos de la UD.


67

A partir de los códigos de partida reg, reg1, mux2, mux4, ALU y UD se crean sus

respectivos archivos VHDL.

En el archivo UD.VHDL se declaran, por defecto, todos los componentes de la UD. Así

que lo que hay que hacer en el archivo UD.VHDL es:

- Rediseñar a ALU según la máquina sencilla en cuestión

- Configurar bloques. Añadir/eliminar registros y multiplexores y darle el

tamaño adecuado en bits.

- Configurar puertos y señales. Añadir/modificar/eliminar puertos y señales

del bloque UD según los bloques que se han utilizado en la UD.

- Configurar puertos dbug. Añadir/modificar/eliminar los puertos de debug

necesarios para la UD en cuestión.

4.2 Unidad de Control

A partir del código de partida llamado UC se crea su respectivo archivo VHDL. En este

archivo, lo que hay que hacer es:

- Configurar puertos. Añadir/modificar/eliminar los puertos que hay por

defecto en el archivo UC.VHDL.

- Configurar señales.

- Configurar la máquina de estados. Modificar la secuencia de estados

según el grafo de estados de la máquina sencilla en cuestión.

- Configurar la tabla con los bits de control.

- Configurar dbug_state.

4.3 Memoria

Según el tipo de memoria de la máquina sencilla, según si es RAM y/o ROM, se crean los

ficheros VHDL a partir de los códigos RAM y ROM, respectivamente.

Estos dos archivos son muy genéricos, y sirven para cualquier máquina sencilla. Así que

no se ha de modificar nada.

A parte de el archivo de memoria en sí, hay que crear un archivo auxiliar, un paquete. Cada

tipo de memoria tiene su paquete que es, RAM_pack y ROM_pack respectivamente.

De estos dos archivos auxiliares, sí que hay que modificar una pequeña parte.

4.4 MáquinaSencilla.VHDL

Por último, hay que crear el archivo MáquinaSencilla.VHDL a partir del código

MáquinaSencilla. Este es bloque de máxima jerarquía, y abarca todos los bloques creados

hasta el momento: UD, UC y memoria(s). Aparte, contiene el bloque llamado dbug.

Lo que hay que hacer en este archivo es:

- Configurar señales.

- Configurar inicialización de memoria. Hay que crear un programa que la

máquina sencilla en cuestión entienda.

- Configurar señales dbug.

Finalmente, hay que crear los archivos MaquinaSencilla.ucf, dbug y led7seg.


68

Una vez se llega a este punto, el siguiente paso es simular la máquina sencilla.

4.5 Simulación

Antes de simular se tiene que crear el archivo tipo test bench para dar unos valores

iniciales a los puertos de entrada de la máquina sencilla. El fichero se crea a partir del

código de partida llamado maquinasencilla_test. Este código no hace falta que lo

modifique el alumno, es totalmente aprovechable.

Una vez creado el archivo, se puede pasar a simular la máquina con el programa iSIM

Simulator.

En la simulación se comprueba el buen funcionamiento de la máquina sencilla.

Cuando se determina que la simulación es correcta, y que por lo tanto, la máquina sencilla

funciona correctamente, se pasa a implementar físicamente la máquina sencilla, es decir,

programar la FPGA.

4.6 Programación de la FPGA

Primero se crea el archivo de programación con la herramienta Generate Programming

File, y luego se pasa a programar la FPGA con el software ISE iMPACT.

Una vez se ha programado la FPGA se puede comprobar el funcionamiento, y si es

correcto, ya se ha implementado la máquina sencilla en la FPGA correctamente.


69

5 La Máquina Sencilla El manual de prácticas sigue el ejemplo de implementación de una máquina sencilla de

ejemplo. A continuación está el enunciado de la máquina sencilla.

5.1 Enunciado

Lo primero que hay que hacer es interpretar el enunciado de la máquina sencilla. En este

caso, tenemos una unidad de datos así:

Figura 2. Unidad de Datos

La líneas discontinuas que aparecen en la imagen representan señales procedentes de la

Unidad de Control. Y encima de cada componente, de color rojo, aparece el nombre del

código de partida con el que se crea el componente.

En la imagen también aparece el bloque de memoria RAM. Cómo se puede observar, su

bus de direcciones es de 7 bits, por lo tanto la memoria podrá almacenar hasta 27 palabras

(128). A partir del bus de entrada y de salida de la memoria se puede deducir el tamaño de

cada palabra de la memoria, que es de 16 bits. Por lo tanto la memoria a utilizar será una

memoria de 128 x 16 bits.

En la imagen no salen especificadas las operaciones que puede realizar la ALU. Según los

bits de selección de la ALU, ésta realizará las siguientes operaciones:


0 0 A+B

0 1 A xor B

1 0 B

1 1 -

Tabla 1. Tabla de Operaciones de la ALU


70

Todas las instrucciones que puede ejecutar esta máquina sencilla tienen un tamaño de 16

bits. Los dos bits de mayor peso forman el Código de Operación, los siguientes 7 bits

forman el operando Fuente y los 7 bits de menor peso forman el operando Destino. Las

instrucciones son:

- Suma

ADD F,D (D) ← (D)+(F)

FZ ← 1 si (D)+(F)=0

Formato:


0 0 @F @D

- Movimiento

MOV F,D (D) ← (F)

FZ ← 1 si (F)=0

Formato:


0 1 @F @D

- Comparación

CMP F,D FZ ← 1 si (F)-(D)=0

Formato:


1 0 @F @D

- Salto

BEQ D PC ← D si FZ = 1

Formato:


1 1 X @D

A partir de aquí ya se puede determinar cómo debe ser la máquina de estados finitos que

describirá a la Unidad de Control de esta máquina sencilla. Es necesario realizar bien esta

máquina de estados, porque a partir de ella se diseña la Unidad de Control. No es necesario

llegar a tener el diagrama muy simplificado.

A continuación está representado el gráfico de estados completo y simplificado:


71

Figura 3. Máquina de Estados

Ahora se puede diseñar la tabla con los bits de control de cada uno de los estados:

S0 S12 S6 S7 S9 S10 S11

MX1 0 1 1 1 X 1 1

MX0 0 0 1 1 X 1 1

ALU1 X X X 0 0 1 X

ALU0 X X X 0 1 0 X

L/E 0 0 0 1 0 1 0

PC ←@+1 1 0 0 0 0 0 1

IR ← M 1 0 0 0 0 0 1

A ← M 0 0 1 0 1 0 0

B ← M 0 1 0 0 0 0 0

FZ ← Z 0 0 0 1 0 1 0

Tabla 2. Tabla de Bits de Control

5.2 Programa a Ejecutar

Ahora es el momento de diseñar el programa que ejecutará esta máquina sencilla.

Observando las instrucciones que puede ejecutar esta máquina hay que pensar alguna

aplicación que podría tener. Lo interesante es que sea un programa que utilice todas las

instrucciones.

En este caso se ha creado un programa que realiza la operación de multiplicar dos números,

a x b = c. El programa queda en la memoria queda así: Dirección Instrucción OP Op. F Op. D

@0h MOV 0,c 10 1101001 1100110

@1h MOV 0,i 10 1101001 1100111

@2h CMP i,b 01 1100111 1100101

@3h BEQ end 11 xxxxxxx 0001000

@4h ADD a,c 00 1100100 1100110

@5h ADD l,i 00 1100000 1100111


72

@6h CMP 0,0 01 1101001 1101001

@7h BEQ while 11 xxxxxxx 0000010

@8h BEQ 8 11 xxxxxxx 0001000

Tabla 3. Tabla del Programa 1

Como se puede observar, aparte de determinar la secuencia de instrucciones hay que tener

claros dos puntos:

- La posición de memoria que ocupará cada instrucción. También hay que tener

claro si vamos a separar la memoria de programa de la memoria de datos, o si

estará todo junto. En este caso se ha separado, puesto que en estas primeras 8

direcciones de la memoria no hay ningún dato como “0” ó “1”.

- La traducción en bits que representa cada instrucción. Porque es necesario más

adelante.

Este programa utiliza implícitamente otras direcciones de la memoria. Por ejemplo:

En la instrucción “ MOV 0,c”, que significa que cargamos el valor “0” en la variable “c”,

se le tienen que indicar la dirección donde se encuentra el valor “0”, que en este caso es en

“@1101001”, o en hexadecimal: “@69”. Por lo tanto, la memoria, tiene que tener por

defecto el valor “0” cargado en la dirección @69 antes de que se ejecute el programa.

En la siguiente tabla, se expresan todas las dirección que el programa anterior utiliza

indirectamente: Dirección Descripción Valor incial

@64h Operando a “valor deseado”

@65h Operando b “valor deseado”

@66h Operando c xxxxxxx

@67h Variable i xxxxxxx

@68h Número 1 0000001

@69h Número 0 0000000

Tabla 4. Tabla del Programa 2

6 Implementación de la Máquina Sencilla

6.1 Creación del Proyecto

Lo primero que hay que hacer es crear un proyecto. En el Anexo 1 se explica el proceso

para crear un nuevo proyecto.

Una vez se ha creado el proyecto, se puede empezar a crear ficheros VHDL. Siguiendo el

Proceso General de Implementación, descrito en el apartado 4, se empieza por la Unidad

de Datos.

6.2 Unidad de datos

6.2.1 Creación de ficheros

Lo primero que se tiene que hacer es crear ficheros VHDL, donde se pegarán los distintos

ficheros de texto con código VHDL que el alumno tiene de un buen inicio.

Para empezar, se hará uso sólo de los ficheros que afecten a la Unidad de Datos de esta

máquina sencilla. Como ya se ha visto en el enunciado, la Unidad de Datos de esta

máquina sencilla tiene los siguientes bloques:

- Registro PC, Registro A, Registro B, Registro IR. Estos bloques se crearan a

partir del fichero “reg”.


73

- Multiplexor de 4 entradas. Este bloque se creará a partir del fichero “mux4”.

- Sumador. Este bloque se creará a partir del fichero “inc”.

- ALU. Este bloque se creará a partir del fichero “ALU”.

- Registro Flag Z. Este bloque se creará a partir del fichero “reg1”.

El proceso de creación de nuevos ficheros VHDL está descrito en el Anexo 2.1.

Cuando se han creado todos estos archivos VHDL, en la izquierda se puede observar la

jerarquía de los archivos. De momento, sólo se puede ver que reg está dentro de reg1.

Si se está siguiendo el ejemplo, se tienen que haber creado los siguientes ficheros: ALU,

reg, reg1, inc, mux2,mux4.

Siguiendo con el Proceso General de Implementación, el siguiente paso es rediseñar la

ALU.

6.2.2 Diseño de la ALU

El archivo ALU.vhd que se ha creado en el apartado anterior se trata de de una ALU

concreto de la máquina sencilla de ejemplo. Seguramente no sirve para otras máquinas

sencillas, así que, si se tiene intención de crear otra máquina sencilla que no sea la del

ejemplo, habrá que rediseñar la ALU.

En el Anexo 3, se hace un análisis del código para saber cuáles son los puntos que suelen

variar de la ALU de una máquina sencilla a otra.

Si se está implementando la máquina sencilla de ejemplo, no hace falta modificar el código.

Si se ha tenido de rediseñar la ALU, hay que hacer una comprobación de la sintaxis del

código escrito antes de continuar. El proceso para comprobar la sintaxis de código se

explica en el Anexo 5.

Cuando se ha llegado a este punto, ya se tienen diseñados todos los tipos de componentes

que van a formar la Unidad de Datos. Ahora hace falta decir cuántos componentes tipo

“reg” habrán, qué nombre tendrá cada registro y cómo estarán conectados con el resto de

componentes de la UD. Y lo mismo para el resto de tipos de componentes, “reg1”, “ALU”,

“mux4”, etc.

6.2.3 UD.VHDL

Para ello se crea un bloque, una caja, que estará un nivel por encima en la jerarquía, de tal

forma que abarcará todos los componentes de la Unidad de Datos. Este bloque nuevo de

jerarquía superior se creará a partir del fichero de partida llamado “UD”. Para crear el

fichero .VHDL se hace siguiendo los pasos del Anexo 2.1

Si se ha hecho bien, lo primero que se ve es que en la jerarquía, en la izquierda, algunos

componentes, automáticamente, se han situado dentro del bloque de UD. Esto se interpreta

como que son de una jerarquía inferior a UD. Sin embargo, puede ser que algún tipo de

componente aún no se sitúe dentro de UD, es normal.

A continuación hay que analizar el archivo UD.VHDL para adaptarlo a la UD de la

máquina sencilla que se esté diseñando.

6.2.4 Análisis del Código UD.VHDL

Lo primero que se describe, como en cualquier bloque, son las definiciones de los puertos

de entrada y de salida del bloque. En este caso, la UD se representaría así:


74

Figura 4. Esquema Bloque Unidad de Datos

Es aconsejable dibujarse un esquema como este para cada Unidad de Datos para tener más

claro que puertos tiene que tener en cada caso. El análisis de los puertos de esta Unidad de

Datos se hace en el Anexo 8.1. Es aconsejable leérselo para saber cuáles son las

modificaciones que hay que hacer en los puertos de UD para otras máquinas sencillas.

El bus de direcciones, que en este caso se le ha llamado “addr” es especial. El análisis de

su modificación se hace en el Anexo 8.2.

Siguiendo con el código, ahora vienen las señales internas de la UD. En el Anexo 8.3 se

hace un análisis para saber qué señales se pueden modificar.

Seguidamente de la palabra reservada “begin” va la descripción del comportamiento este

componente, UD. El análisis del comportamiento está hecho en el Anexo 8.4.

Es importante leerse este anexo porque en él se explica, primero cómo declarar

componente y segundo, la gestión de señales que se hace al final de este código.

Cuando se llega a este punto, es necesario comprobar sintaxis como se explica en el Anexo

5.

Si no hay problemas de sintaxis, siguiendo con el Proceso General de Implementación, se

pasa a diseñar la Unidad de Control.


75

6.3 Unidad de Control

El objetivo de este apartado es implementar la máquina de estados finita y sus bits de

control en lenguaje VHDL.

Lo primero que se tiene que hacer es crear un fichero .VHDL a partir del código de partida

llamado “UC”. El procedimiento se explica en el Anexo 2.1.

A continuación, hay que analizar el código de partida para saber qué partes hay que

modificar para implementar otras máquinas sencillas que no sean la de ejemplo.

6.3.1 Análisis del código UC.VHDL

La Unidad de Control se trata de otro componente más, así que como todo componente se

empieza definiendo sus puertos de entrada y salida:

Figura 5. Esquema del Bloque de Unidad de Control

El análisis de los puertos de hace en el Anexo 9.1.

Una vez declarados los puertos, se pasa a describir el comportamiento del componente.

Pero antes se declaran su señales internas. La explicación de las señales de la UC, y las

modificaciones que se tienen que hacer, se encuentran en el Anexo 9.2

Una vez declaradas las señales se pasa a declarar el comportamiento de la UC.

En esta parte del código se utilizan dos estructuras del VHDL que aún no se habían visto:

-“process-end process”: explicado en el Anexo 4.6

- “If-then-elseif-endif”: su utilización es la misma que la del leguaje C.

Esta parte se trata de la descripción en VHDL de la máquina de estados finita de la UC.

Y por lo tanto, se tendrá que modificar para cada máquina sencilla.

El análisis de esta parte, junto con la explicación de las modificaciones que se podrían

hacer, está hecho en el Anexo 9.3.

Una vez determinada la secuencia de estados que puede seguir la máquina sencilla, hay

que determinar los valores que tomarán los bits de control de la UC en cada estado. Se trata

de implementar la tabla de los bits de control en VHDL. Esto se hace con un “process –


76

end process” y una asignación de señales a puertos. Su explicación se encuentra en el

Anexo 9.4.

Finalmente, lo que hay que hacer en la UC es darle un valor numérico a cada estado. Este

valor numérico es el que saldrá por el puerto “dbug_state” y servirá para saber en qué

estado se encuentra la máquina. La explicación se encuentra en el Anexo 9.5.

Una vez se llega a este punto, se ha completado la Unidad de Control. Siguiendo con

Proceso General de Implementación, se pasa a implementar las memorias.

6.4 Memorias

Este apartado tiene como objetivo implementar la memoria de la máquina sencilla. En este

caso, la máquina sencilla sólo tiene un tipo de memoria, RAM. Pero puede ser que alguna

máquina sencilla tenga memoria RAM y memoria ROM.

6.4.1 Memoria RAM

El alumno tiene, de partida, un fichero que se llama “RAM”. Este fichero se ha de convertir

en un fichero .VHDL como se explica en el Anexo 2.1

Del fichero RAM.VHDL el alumno no ha de modificar nada.

El alumno también tiene un fichero de partida llamado “RAM_pack”. A partir de este

código se tiene que crear un “VHDL Package” y no un archivo .VHDL. Los pasos para

crear un VHDL package se explican en el Anexo 2.2.

Una vez creado el archivo RAM_pack, se tiene que modificar.

6.4.2 Análisis de RAM_pack y ROM_pack

Este fichero no hace falta que se analice totalmente, porque el alumno sólo tiene que

modificar una parte muy pequeña del código. La explicación se encuentra en el Anexo 10.

Una vez se llega a este punto ya se tienen completadas: la Unida de Datos, la Unidad de

Control y la(s) memoria(s).

Ahora hace falta crear un fichero que interconecte estos componentes que se han creado.

Se tiene que crear un fichero de un nivel superior en la jerarquía que los abarque.

Este fichero que se tiene que crear estará en el nivel más alto de la jerarquía. Los puertos

de entrada y salida de este bloque son entradas y salidas físicas del Starter Board kit: leds,

switches, el reloj, etc.

6.5 MaquinaSencilla.VHDL

El alumno tiene un código de partida llamado “MaquinaSencilla”, con este código se tiene

que crear un “VHDL Module”, como se explica en el Anexo 2.1.

Además también es el momento de crear los ficheros “dbug.VHDL” y “led7seg.VHDL” a

partir de los códigos dbug y led7seg.

6.5.1 Análisis MaquinaSencilla.VHDL

Librerías y puertos

En este fichero, como en todo componente, se empieza determinando qué librerías utiliza

el código y los puertos de entrada y salida:


77

Figura 6. Código MaquinaSencilla, puertos

El alumno no tiene que modificar ninguno de los puertos.

Como se puede ver, en este caso se utiliza el paquete “RAM_pack” porque esta máquina

sencilla tiene memoria RAM.

Si la máquina sencilla tiene memoria ROM y RAM, hay que usar las dos librerías, por lo

tanto, se tiene que escribir:

Figura 7. Código MaquinaSencilla, librerías

Siguiendo con el código, a continuación viene la declaración se señales de este

componente:

Figura 8. Código MaquinaSencilla, señales

Para saber cuáles son las señales que hay que definir es aconsejable hacerse un esquema

donde se representen todas las entradas y salidas de la UD, UC y memoria. Por ejemplo, en

este caso el esquema es:


78

Figura 9. Esquema bloque MaquinaSencilla

Todas las entradas y salidas de la UD, UC y memoria tiene que definirse como señales.

El alumno tiene que modificar el nombre y/o rango de bits de las señales que hay en el

código de partida. Probablemente tenga que crear nuevas señales o eliminar señales

inexistentes en su máquina sencilla, como podría ser, por ejemplo, la señal FZ.

Además hay tres señales que el alumno tiene que dejar tal y como están: dbug_led,

dbug_in y dbug_clk.

Inicialización de memoria(s)

La siguiente parte del código realiza la inicialización de la(s) memoria(s). La inicialización

es el programa que ejecutará a máquina sencilla. La explicación de cómo inicializar

memorias está en el Anexo 11.

Declaración de los componentes: UD ,UC ,memoria(s)

Una vez preparada la inicialización de las memorias se puede pasar a definir los

componentes que forman la máquina sencilla, que son la UD, UC y memoria(s).

El método para declarar componentes en este bloques es exactamente el mismo método

que se ha utilizado para declarar los componentes de la Unidad de Datos en el archivo

UD.VHDL

Figura 10. Código MaquinaSencilla, componentes.


79

Lo único que hay que saber, y tener muy en cuenta, es el orden en el que se han declarado

los puertos de cada componente, porque aquí se tienen que asignar las señales en el mismo

orden.

Los port map de las memorias RAM y ROM se explican en el Anexo 7.

El alumno no tiene que modificar el último componente, llamado “dbug”. Se trata de un

componente que se utiliza para depurar ( o “debugear”) partes de la máquina sencilla

cuando se ha implementado físicamente.

Gestión de puertos

Siguiendo con el código, ahora viene una parte que sirve para gestionar los puertos de

entrada y salida de la máquina sencilla. Esta parte del código de explica en el Anexo 12.

Llegado a este punto sólo hace falta hacer 2 comprobaciones para saber si todo el código

escrito no tiene errores de sintaxis y es sintetizable.

Para hacer la comprobación de sintaxis se hace como se explica en el Anexo 5.

Para comprobar si es sintetizable, se explica en el Anexo 13.

Si el código se ha sintetizado sin problemas, se puede pasar a implementar el diseño. La

explicación de cómo implementar el diseño está en el Anexo 14.

Si se ha sintetizado e implementado el diseño correctamente se puede pasar a programar la

FPGA para implementar físicamente la máquina sencilla. Pero antes es mejor simular la

máquina con el simulador que tiene el programa. De esta manera sabremos si la máquina

sencilla ejecuta correctamente el programa que tiene en memoria y, por lo tanto, se puede

decir que funciona correctamente.

6.6 Simulación

Este apartado pretende ser una guía para llegar a simular la máquina sencilla del ejemplo.

Lo primero que hay que hacer es crear un fichero de “test bench” a partir del archivo de

partida llamado “MaquinaSencilla_test”. La explicación de cómo hacerlo se encuentra en

el Anexo 2.3.

Una vez creado el test bench se tiene que hacer clic en “simulation”:

Figura 11. Selector de Simulación.


80

Luego se selecciona el archivo “MaquinaSencilla_test” y se hace doble clic en “Simulate

Behavioral Model”:

Figura 12. Herramienta Simulate Behavioral Model.

Entonces se abrirá otro programa nuevo, el ISim Simulator, el simulador.

Para que se abra el simulador, tiene que estar cerrado, sino la consola avisará de un error y

no se abrirá el simulador.

Este simulador tiene la pantalla dividida en 2 ventanas principales. A la izquierda hay

como un explorador de señales y componentes. En esta ventana se pueden buscar las

señales internas de la máquina sencilla. De la misma manera que cuando se exploran

carpetas en el explorador de Windows.

Por ejemplo, si se quiere observar la señal de salida del registro PC, se puede acceder a ella

entrando en: maquinasencilla_test\uut\UD. Si se hace clic en UD, se puede encontrar la

señal PC en la derecha.


81

Figura 13. Explorador de señales.

A la derecha de la pantalla, hay una ventana de fondo negro. Ahí se representan las señales

y se puede observar cómo varían con el tiempo. Por defecto, hay algunas señales, se

pueden borrar. Y para observar las señales que son de interés lo que hay que hacer es

buscarlas en el explorador de la izquierda y arrastrarlas a la ventana de fondo negro.

Una vez se han arrastrado todas las señales de interés, y por lo tanto, se tiene un wave

configuration, se puede guardar el archivo. Esto sirve para ahorrarse el tener que hacer la

selección de señales cada vez que se abre el programa.

Los botones para controlar la simulación se encuentran al final de la barra de menú

superior:

Figura 14. Herramientas de simulación.

El primer icono sirve para hacer un reset de la simulación. Cuando se añade una nueva

señal a la simulación es necesario hacer un reset para poder verla representada

temporalmente.

El segundo no es útil para simular un máquina sencilla


82

El tercero, sirve para simular el tiempo determinado a la derecha. En el caso de la imagen,

1 µs. Este es el que se usa para iniciar la simulación. Hay máquinas sencilla que en 1 µs no

han acabado de ejecutar su programa, entonces hay que darle un tiempo de simulación más

grande, lo suficiente para que termine de ejecutar el programa.

Para observar mejor las señales, hay opciones de zoom:

Figura 15. Herramientas de zoom.

Es aconsejable hacer clic primero en el tercer icono, Zoom to full view, entonces se verá la

forma de onda cuadrada del reloj. Y después hacer zoom con el primer icono hasta algo

razonable.

Hay algunas señales, como pueden ser registros de 16 bits, que no es muy cómodo

observarlas en su valor binario. Se pueden observar en hexadecimal haciendo clic derecho

sobre la señal y cambiando el radix:

Figura 16. Observar en hexadecimal.


83

En el explorador, no solo se pueden encontrar señales, también se pueden encontrar las

memorias. Haciendo clic en la pestaña memory¸ debajo del explorador:

Figura 17. Pestaña de memoria.

En las memorias se puede observar tanto la inicialización como el valor final que toma

cada celda de memoria al haberse ejecutado el programa. En el caso de una máquina

sencilla es de interés mirar el estado final de la memoria RAM:

Figura 18. Memoria RAM.

Si se hace doble clic en ram, se abre una tabla donde cada casilla de la tabla es una celda

de la memoria, y dentro está el dato que contiene la celda. No hay que confundir ram con

mem_init, o programa_RAM. Eso son las inicializaciones.

6.6.1 Comprobación del buen funcionamiento

Cómo primera aproximación para determinar si la máquina sencilla funciona bien, se

puede observar cómo evoluciona la señal “s”. En ella se ve el estado actual de la máquina

sencilla. Si la secuencia de estados es la esperada según el programa que se ha hecho, se

pueden hacer otras comprobaciones como que la memoria RAM tenga los resultados de las

operaciones correctamente guardados en sus celdas.

Si la secuencia de estados no es la esperada, habrá que investigar de dónde viene el error.

Primero detectar el primer estado erróneo, mirar CO, asegurarse de que se haya descrito

correctamente la máquina de estados en la UC, e ir tirando hacia atrás hasta encontrar el

origen del problema.

6.7 Programación de la FPGA En este apartado se explica qué pasos hay que seguir para programar la FPGA con el diseño de la

máquina sencilla que se ha hecho en VHDL.

Primero que todo, hay que crear el fichero maquinasencilla.ucf . Se crea a partir del código de

partida llamado maquinasencilla.ucf. La explicación de cómo hacerlo está en el Anexo 2.4.


84

Este archivo ucf se encarga de indicar a qué entradas/salidas de la placa van conectadas los

distintos puertos de la máquina sencilla. Une los distintos puertos de la máquina sencilla con

interruptores, leds y displays de la placa. Por ejemplo, une el puerto de reset con el interruptor

“L14”. El alumno no hace falta que modifique nada de este archivo. Pero sí saber en qué interruptor están asignadas las distintas señales de la máquina sencilla.

En la siguiente imagen se describe dónde se ha conectado cada puerto de la máquina sencilla:

8) dbug_led. Displays 7 segmentos.

9) dbug_in. 8 Leds.

10) rst. Señal de reset

11) clk_user. Reloj manual.

12) sw[5:3]. Interruptores que seleccionan la señal a mostrar por los 4 displays 7

segmentos

13) sw[2:1]. Interruptores que seleccionan la señal a mostrar por los 8 leds.

14) sw[0]. Interruptor que selecciona el reloj con el que funciona la máquina

sencilla. „1‟ para 50 MHz y „0‟ para reloj manual.

Figura 19. Asignación de puertos en la placa

Una vez creado el archivo .ucf hay que crear el fichero de programación de la FGPA. Para ello se tiene que hacer doble clic en Generate Programming File. (Se ha de estar en Implementation y

tener seleccionado el componente de máxima jerarquía, que es MaquinaSencilla).


85

Figura 20. Generate Programming File

Cuando se hace doble clic se vuelve a sintetizar la máquina sencilla. Una vez sintetizada, automáticamente pasa a Implementar el Diseño y finalmente pasa a Generar el Archivo de

Programación.

De los tres pasos se obtiene el veredicto, que como ya se ha visto puede ser totalmente correcto,

con warnings o erróneo. Los warnings hay que mirarlos con detalle y intentar solucionarlos.

Cuando se ha generado el archivo correctamente hay que hacer doble clic en Manage

Configuration Project:

Figura 21. Manage Configuration Prjoect

Entonces se abrirá un programa llamado ISE iMPACT.

Ahora se puede conectar la placa Spartan – 3 mediante el conector JTAG – Puerto Paralelo al PC. Y también el cable de alimentación.

Una vez conectados los cables hay que seguir estos pasos:

1) Doble clic en Boundary Scan


86

Figura 22. Boundary Scan

2) Clic botón derecho en la ventana principal y clic en Initialize Chain

Figura 23. Initialize Chain

3) El programa detectará la FPGA y memoria.

Figura 24. FPGA y memoria detectadas

La FPGA es el bloque llamado xc3s200

4) Ahora hay que cargar el programa a la FGPA, para ello se tiene que hacer doble clic en el

bloque de la FPGA y se abre una ventana:


87

Figura 25. Seleccionar maquinasencilla.bit

En la ventana hay que seleccionar maquinasencilla.bit. Este es archivo que se genera con la

herramienta Generate Programming File.

5) Antes de programar la FPGA, es muy aconsejable pulsar el pulsador para forzar la

reconfiguración de la FPGA. Este pulsador es el siguiente:

Figura 26. Pulsador de reconfiguración

6) Ahora, teniendo seleccionada la FPGA (se tiene que ver de color verde) se hace clic

derecho en la pantalla principal y se selecciona Program:

Figura 27. Program


88

7) Entonces se abrirá una ventana. Hay que darle a OK y se empezará a programar la FPGA.

Figura 28. Clic OK

El otro bloque que aparece al lado de la FPGA hay que dejarlo como sale por defecto, en bypass.

6.7.1 Comprobación del buen funcionamiento Para comprobar que la máquina sencilla programada en la FPGA funciona correctamente se puede

hacer comparando las señales que se pueden mostrar mediante los leds y displays con la simulación

hecha en el PC.

Para poder ver mejor su funcionamiento, el reloj de la máquina sencilla debe ser el manual, así que

el sw[0] tiene que estar a „0‟.

Entonces, con el pulsador de paso a paso se puede ir haciendo avanzar la máquina sencilla estado a

estado. Recordar que para reiniciar la máquina sencilla y que vuelva al estado 0 y a la primera

instrucción del programa, está el botón de reset. Observar figura 19.

Una primera comprobación puede ser observar si se sigue la misma secuencia de estados que en la

simulación.

Luego se puede pasar a comprobar los valores que van tomando registros, señales y buses.

En este punto, se verá la diferencia entre simulación y implementación real. Porque en la

simulación, cuando una celda de la memoria vale “X”, se observa “X”, pero en la realidad no hay

“X”, hay o bien „1‟ o bien „0‟. Y por eso, cuando en la simulación un registro, señal o bus marca que su valor es “X” en la implementación real saldrá un valor “aleatorio”.

En ocasiones, puede ser que la señal simulada y la real no coincidan exactamente. Todo tiene su

explicación lógica. La explicación se encuentra en el Anexo 15.


89

Anexo 1 Crear proyecto

Para crear un proyecto nuevo, hay que abrir el programa Xilinx ISE.

Una vez abierto, hay que hacer clic en la opción “New project…”, a la izquierda de la

pantalla.

Figura 29. New project

Se abre una nueva ventana, donde hay que indicar el nombre del proyecto y localización

donde se guardará. El nombre es indiferente, MS1 por ejemplo, y la dirección debe ser

alguna de fácil localización. Una vez hecho hay que darle a next.

Figura 30. Nombre del proyecto


90

En la siguiente ventana hay que dejar todas las opciones como indica esta imagen y darle a

next.

Figura 30. Propiedades de proyecto

En la siguiente ventana hay que darle a next directamente. Simplemente es informativa.

Anexo 2 Crear archivos VHDL, paquetes, ucf y test_bench

Anexo 2.1 Crear Archivo VHDL

Hay que seguir los 5 pasos siguientes:

1) Project → New source.

Figura 31. New source


91

2) En la ventana que se abre hay que seleccionar el tipo “VHDL Module”. El nombre

del archivo es importante que se utilicen los propuestos: reg para registro, mux2

para multiplexor de 2 entradas, etc. La localización del archivo hay que dejar la que

sale por defecto.

Figura 32. VHDL Module

3) Las siguientes dos ventanas se pueden pasar: next y finish.

Ahora ya se ha creado un archivo .VHDL. En la ventana más grande, en el centro, está el

código VHDL. Por defecto, el programa ya escribe unas líneas de código.

4) Todo el código que genera el programa por defecto se tiene que borrar, ya que no

es de interés.

5) Una vez limpiado el código, hay que poner el código de partida que se esté creando.

Por ejemplo, si se está creando el archivo reg.VHDL hay que pegar el código de

partida reg.

6) Guardar el archivo.

Anexo 2.2 Crear Archivo VHDL package

Se siguen los mismo pasos en el Anexo 2.1, con la diferencia que en el paso dos, se escoge

la opción de VHDL package.

Si se han seguido los 5 pasos correctamente, se puede observar que este fichero creado no

aparece en la jerarquía. Esto es correcto. Este fichero se encuentra en las librerías. Para

acceder a la librerías hay que hacer clic en la pestaña. En la imagen se puede ver dónde

está la pestaña:


92

Figura 33. RAM_pack

Anexo 2.3 Crear Archivo MaquinaSencilla_test

Para hacerlo, se hace como si se creara un archivo .VHDL normal pero hay que seleccionar

“VHDL Test Bench”:

Figura 34. VHDL Test Bench


93

Como nombre del archivo hay que poner “MaquinaSencilla_test”.

En la siguiente ventana es importante seleccionar “MaquinaSencilla”. Porque se quiere

asociar el test bench al archivo de máxima jerarquía:

Figura 35. Asociar con MaquinaSencilla

A continuación se le da a next y finish. Y se pega el código del archivo de partida en este

archivo nuevo creado. Y se guarda.


94

Anexo 2.4 Crear Archivo MaquinaSencilla.ucf

Para crear un archivo .ucf hay que seguir los mismos pasos que para crear un archivo

VHDL normal, pero hay que seleccionar Implementation Constraits File:

Figura 36. Implementation Constraits File

Una vez se ha creado el archivo .ucf, se pega el código de partida. Y se guarda.

Anexo 3 Análisis de la ALU

Primero que todo, hay que entender la ALU como un caja que tiene unas entradas y unas

salidas. De hecho, cualquier archivo VHDL tiene que entenderse así. Una ALU siempre

suele tener entradas de datos, entrada de selección y salidas.

La caja que representaría la ALU del ejemplo de máquina sencilla es la siguiente:

Figura 37. Esquema del bloque de la ALU

En el código, lo primero que hay que determinar son las entradas y las salidas de la caja.

Lo que se llaman puertos.


95

En el archivo de partida, ALU, hay lo siguiente:

Figura 38. Puerto de la ALU

La explicación general de los puertos en lenguaje VHDL está en el Anexo 4.1.

Una vez definidos los puertos, hay que definir el comportamiento interno de la caja. En el

caso de este ejemplo, el comportamiento se ha descrito así:

Figura 39. Señales y comportamiento de la ALU

La explicación teórica de qué es una señal y cómo se declara se encuentra en el Anexo 4.2.

En este ejemplo hay 4 señales definidas. Se puede decir que, en general, todas ellas se

pueden aprovechar para cualquier ALU. A continuación está la explicación de cada señal:

- signal aux : std_logic_vector (15 downto 0);

aux se trata de una señal auxiliar. Su función es recoger la operación que realiza

la ALU, ya sea una multiplicación, una suma o directamente una de sus

entradas. Su tamaño ha de ser el mismo tamaño que el puerto de salida de la

ALU “o”. En este caso 16 bits.

Si se requiere una ALU con una salida de otro tamaño, se puede cambiar el

rango “(15 downto 0)” por el deseado.

- signal ua,ub,usum : std_logic_vector(aux‟range);


96

La función de las señales “ua” y “ub”, que es la abreviatura de “unsigned a” y

“unsigned b”, es recoger los datos de entrada a la ALU que entran por los

puertos “a” y “b”, pero transformados a enteros sin signo.

Es necesario transformar los datos de entrada a enteros sin signo para poder

realizar las operaciones aritméticas de suma, resta, multiplicación, etc.

La función de la señal “usum”, que es la abreviatura de “unsigned suma”, es

recoger el resultado de la operación aritmética que se realiza con “ua” y “ub”.

En este caso, recoge la operación de sumar.

Como se puede ver, el tamaño de estas tres señales viene determinado como

“(aux‟range)”, eso significa que, el rango de estas 3 señales es el mismo rango

que el de la señal “aux”.

En la misma parte del código se puede observar otra definición:

- constant X : std_logic_vector (aux‟range) := (others => „X‟);

Se trata de una constante llamada “X”. Es un vector del mismo rango que “aux”.

Además, a está constante se le da un valor inicial.

Se pueden asignar valores iniciales tanto a señales como a constantes. Para

hacerlo se utiliza el comando “:=<asignación>”.

En este caso, la asignación es “(others=>‟X‟)”. La explicación de esta

sentencia se encuentra en el Anexo 4.4.

Resumiendo, esta constante X es un vector de bits no definidos y se puede

aprovechar para todas las máquinas sencillas.

Después de la definición de las señales y constantes viene la palabra clave begin. Todo el

código que va entre begin y end representa el comportamiento de la caja en sí.

Hay que tener presente en todo momento que se trata de descripción de hardware y no de

software. Esto quiere decir que no se trata de un código que se ejecuta línea por línea, con

una secuencia determinada. Sino que simplemente de definen las conexiones entre señales,

puertos y las modificaciones que reciben.

Lo primero que se determina en el comportamiento de esta ALU es:

Figura 40. Transformaciones a unsigned

La línea 22 asigna el puerto de entrada de la caja llamado a, a la señal interior de la caja

llamada ua. Pero antes, se transforma el tipo del puerto a de tipo std_logic_vector a tipo

unsigned. Esto se hace porque para poder operar aritméticamente es necesario que los

operandos sean números reales y no vectores de bits.

En la línea 23 se hace exactamente lo mismo, pero con el puerto “b”.

En la línea 24 se realiza la operación de sumar en sí. Se suman los dos números reales y se

guarda el resultado en la señal “usum”.

Siempre que la ALU en cuestión necesite realizar una suma, serán necesarias estas 3 líneas

de código. En el caso de que además la ALU necesite hacer una resta, se puede añadir una

cuarta línea como la línea 24 pero cambiando la suma por una resta y asignando la


97

operación a otra señal distinta a “usum” (porque no se pueden asignar dos operaciones a

una misma señal), por ejemplo “ures”.

En el caso de una multiplicación, es distinto, porque por ejemplo, el producto de dos

vectores de de 16 bits da como resultado uno de 32 bits. Así que, la operación de

multiplicar se tendría que asignar a un señal de 32 bits. Y si la salida del la ALU tiene que

ser de 16 bits, de esos 32 bits, se cogen los 16 más significativos, los 16 de menos peso.

Siguientemente va la selección de la operación que tiene que ejecutar la ALU:

Figura 41. Selección de la operación

Esta estructura de código “with selec - when” es característica del VHDL Es el equivalente

al switch o a un encadenamiento de if-else en lenguaje C. Su explicación teórica se

encuentra en el Anexo 4.5.

Su función es asignar un valor a una señal/puerto según una señal de selección. En la ALU,

se tiene que seleccionar una operación en función de sus dos bits de selección.

Los dos bits de selección de la ALU se recogen en el puerto llamado “s”. Por eso se

empieza escribiendo “with s select …”.

A continuación, se pasa a describir las distintas asignaciones según los bits de “s”. Darse

cuenta que estos 4 casos se corresponden con la tabla que da el enunciado de la máquina

sencilla, donde se expresan todas las funciones de la ALU:


0 0 A+B

0 1 A xor B

1 0 B

1 1 -

Tabla 5. Operaciones de la ALU

- Línea 26: “ std_logic_vector(usum) when “00” ”

De la misma manera que antes se ha transformado el tipo de

std_logic_vector a unsigned, ahora se hace el proceso inverso, se transforma

de unsigned a std_logic_vector. Cuando(when) el puerto “s” vale “00”, en la

señal “usum” se guarda el resultado de la suma de los dos puertos “a” y “b”.

- Línea 27: “ a xor b when “01” “

Cuando (when) el puerto “s” vale “01”, a la señal “aux” se le asigna el

resultado de hacer la operación lógica xor con “a” y “b”.

El VHDL tiene palabras reservadas para todas las operaciones lógicas:

and, or, xor, nand, nor, not, etc. Evidentemente, los operandos deben de ser

del tipo std_logic o std_logic_vector.

- Línea 28: “ b when “10” “

Cuando (when) el puerto “s” vale “10”, a la señal “aux” se le asigna el

directamente el valor del puerto de entrada “b”.


98

- Línea 29: “ X when others”

Aquí se hace uso de la constante “X” y de la palabra reservada others, que

ya se ha explicado. Esta línea significa que cuando “s” valga “others”, es

decir, cuando valga cualquier valor que aún no se ha definido (ni 00, ni 01,

ni 10), a la señal “aux” se le asigna “X”.

Hace falta usar “others” (en vez de “11”) porque en la estructura “with

select” tienen que estar determinados todos los posibles casos, incluidos los

casos en que “s” valga “XX”.

A continuación, se trata con el flag Z de la ALU. Esta ALU sí que tiene flag Z y para

implementarlo se utiliza esta línea de código:

Figura 42. Operación para Flag Z

La función de esta línea es asignar al puerto “z” un „1‟ si es que el resultado de la

operación (que se almacena en “aux”) ha dado 0. O en caso de que el resultado haya sido

distinto de 0, asigna a “z” un „0‟. Para ello se utiliza la función or_reduce, que lo que hace

es realizar la operación de or con cada bit del vector en cuestión, “aux”. De tal manera, que

esta operación sólo dará „0‟ cuando todos los bits valgan „0‟. Y como esta asignación está

negada con la palabra reservada not, en caso de que or_reduce(aux) dé „0‟ se asigna un „1‟

a “z”. Para utilizar esta instrucción, hay que hacer uso de la librería llamada std_logic_misc,

así que hay que asegurarse que en la cabecera del código haya escrito: “ use

ieee.std_logic_misc.all; “.

Esta línea es totalmente aprovechable para cualquier ALU que tenga flag z. (Siempre que

se asigne el resultado de las operaciones de la ALU a la señal “aux”.)

Finalmente, falta asignar la señal “aux”, donde tenemos el resultado de la operación, al

puerto de salida de la ALU, que en este caso se ha llamado “o”.

Figura 43. Asignación al puerto


99

Anexo 4 Lenguaje VHDL

Anexo 4.1 Puertos

En este anexo se explica el tema de puertos a partir de un ejemplo de port map. El ejemplo

es el port map de la ALU de la máquina sencilla de ejemplo:

Figura 44. Puertos de un componente

Un puerto se podría definir como una vía de comunicación entre el interior de un

componente y el exterior.

Como se puede observar:

- Todos los puertos, tanto los de entrada como los de salida, van dentro del

paréntesis que se inicia en “port( … );”

La sintaxis genérica es: <nombre>:[in/out] <tipo de señal>;

- Se escribe “in” para determinar que se trata de un puerto de entrada, o “out”

para lo contrario.

- Seguidamente, viene el tipo se señal que entrará/saldrá por el puerto.

Principalmente hay dos tipos:

std_logic: que se trata de una señal de 1 bit

std_logic_vector: que se trata de un vector de bits.

- Para determinar el tamaño del vector: seguidamente del std_logic_vector se

pone entre paréntesis el rango de bits. El orden es importante, porque determina

el peso de los bits. Ejemplos:

std_logic_vector(6 downto 0) se trata de un vector de 7 bits, donde el bit

6 es el de más peso y el 0 el de menos peso.

std_logic_vector(0 upto 6) significa un vector de 7 bits, donde el bit 6 es

el de menos peso y el 0 el de más peso.

- Toda definición de puerto acaba con “;” excepto la última.

- El orden en que se definen los puertos (primero a, después b, etc.) es importante

para más adelante. Hay que procurar seguir un orden lógico, por ejemplo,

primero todas las entradas y luego todas las salidas.

Anexo 4.2 Señales

Una señal se podría definir como una vía de comunicación entre dos partes internas de un

componente. Tomando como ejemplo el código de la ALU de la máquina sencilla de

ejemplo:


100

Figura

45. Señales de un componente

Entre “architecture Behavioral of ALU is” y “begin” tenemos una serie de declaraciones.

Todas las declaraciones que van entre estas líneas de código de llaman señales. Las señales,

son como puertos internos de la caja. Se definen igual que un puerto externo, sólo que la

palabra clave en este caso es SIGNAL, y además, no hay que indicar si es de entrada o

salida.

Anexo 4.3 Determinar Tamaño de Vectores de Bits

Hay varias maneras de determinar el rango o tamaño de un vector de bits:

- Seguidamente del tipo de puerto/señal/variable/constante, por ejemplo tipo

std_logic_vector, se pone entre paréntesis el rango de bits. El orden es

importante, porque determina el peso de los bits. Ejemplos:

std_logic_vector(6 downto 0) se trata de un vector de 7 bits, donde el bit

6 es el de más peso y el 0 el de menos peso.

std_logic_vector(0 upto 6) significa un vector de 7 bits, donde el bit 6 es

el de menos peso y el 0 el de más peso.

- Seguidamente del tipo de puerto/señal/variable/constante, por ejemplo tipo

std_logic_vector, se pone entre paréntesis la referencia a otro

puerto/señal/variable/constante que tiene el mismo rango de bits. Por ejemplo:

std_logic_vector(aux‟range), eso significa que, el rango de este

puerto/señal/variable/constante es el mismo rango que el de la señal

“aux”.

Anexo 4.4 Palabra Others y valor ‘X’

La palabra others, es una palabra reservada del VHDL, sirve para asignar un valor a todos

los elementos de una matriz o vector que aún no se le ha asignado un valor. Por ejemplo:

A :=(others => „0‟); asigna un „0‟ a todas las posiciones de A que no se le

ha asignado aún un valor.

A :=(others => „1‟); asigna un „1‟ a todas las posiciones de A que no se le

ha asignado aún un valor.

Puede ser que se haya escrito A :=(others=>‟X‟) lo que significa que se asigna „X‟ a todas

las posiciones del vector A. Cuando asignamos el valor „X‟ en VHDL significa que ese

elemento no está definido, y cuando simulemos, veremos una “X” en la posición que la

hemos asignado . Aunque, hay que tener en cuenta, que cuando se implemente

físicamente, el bit asignado con una „X‟, será ó „0‟ ó „1‟, pero no „X‟.


101

Anexo 4.5 With select – when

Esta es una estructura del VHDL equivalente al “case” o a una anidación de “if – else” en

leguaje C.

Se evalúa una señal/puerto/variable para ejecutar distintas operaciones según su valor. Por

ejemplo:

Figura

46. With select - when

Cuando “s” valga “10” a “aux” se le asignará “b”. O cuando “s” valga “01”, a “aux” se le

asignará el resultado de hacer “a xor b”.

En esta estructura, todas las posibles combinaciones que puede valer “s” tienen que estar

determinadas, incluso si vale “XX”. Así que se suele hacer uso de la palabra reservada

“others” para referirse a todo el resto de valor que puede tomar “s”.

Como en la primera línea (línea 26) se asigna una operación a la señal “aux”, si en las

siguientes líneas no se pone a que señal se asigna, el compilador interpreta que se asigna a

la misma señal de la primera línea, “aux”.

Anexo 4.6 Process – end process

Todo el código que se escribe entre “process” y “end process” se ejecuta secuencialmente.

Además, si por ejemplo, si se ha escrito “process (clk,rst)”. Eso quiere decir que el proceso

es sensible a los cambios de las señales clk y rst. Eso quiere decir que, siempre que haya un

cambio de estas dos señales, se ejecutará el código secuencialmente una vez.

Anexo 4.7 When y case is - when

When es el equivalente al if. Se utiliza para establecer condiciones. Su sintaxis es:

When <condición> => <operación a realizar>;

case is – when es muy parecido a with select – when. Se evalúa una señal/puerto/variable y

según su valor se toma ejecuta una operación u otra. Su sintaxis es:

case <expresión> is

when <valor 1> => <operación 1>;

when <valor 2> => <operación 2>;

when others =>

end case;

En un “case is – end case” se tienen que determinar todos los casos posibles, así que cada

“case is – end case” se acaba con un “when others=>”


102

Anexo 4.8 Concatenación

Si se escribe “ A&B “, se está concatenando A con B. Es importante no confundir esta

operación con la operación lógica AND. Concatenar significa unir, enlazar, una cosa con

otra. En este caso unimos bits o vectores de bits. Por ejemplo, si tenemos estos 3 vectores:

- A=001

- B=010

- C=000111

El resultado de: A&B&C es “ 001010000111”. Como se puede ver, el resultado es un

vector que sus bits representan el vector A, seguido del vector B y seguido del vector C.

Anexo 5 Check syntax Para saber si las modificaciones que se han hecho en el código están bien hechas, hay que

comprobar la sintaxis con la herramienta “check syntax”. Para utilizarla, se debe de

seleccionar bloque que se quiere comprobar en la ventana de la Hierarchy , y a

continuación, hacer doble clic en “check syntax”, que está debajo, en la ventana de

Processes.

Figura 47. Herramienta Check Syntax

Al hacer doble clic, se ve como en la consola, que es la ventana de abajo del todo, se

procesa una serie de información. Cuando haya terminado de trabajar, al lado de “check

syntax” saldrá simbolizado el resultado. Hay tres tipos de resultado:

- Correcto: el código escrito está completamente correcto.

Figura 48. Check Syntax Correcto

- Correcto con warnings: el código compilará pero hay una/s advertencia/s que

se deben tener en cuenta, porque pueden afectar al buen funcionamiento. En

este caso lo que se tiene que hacer es buscar en la consola donde hay warnings y

intentar resolverlas para que dé una sintaxis totalmente correcta. Puede ser que

algunos warnings no se puedan evitar.


103

- Incorrecto: el código tiene un/unos error/es. Hay que buscar en a consola

dónde están los errores y corregirlos.

Figura 49. Check Syntax Inorrecto

Anexo 6 Sintaxis para Declarar Componentes

A continuación hay una imagen con un ejemplo de declaración de componentes.

Figura 50. Declaración de componentes

<Nombre> : entity <tipo de componente> generic map(<bits genéricos>) port map

(<puertos del componente>);

- <Nombre>: la única restricción de este nombre es que no puede tener el mismo

nombre que una señal/puerto del mismo componente. Nótese que el nombre sí

puede coincidir con el tipo de componente, por ejemplo el componente “ALU”

coincide con el tipo “.ALU”.

- <Tipo de componente>: todos los ficheros que se crean siguiendo el Anexo2.1

se guardan por defecto en la librería “work”. Así que por ejemplo, si se quiere

crear un componente de tipo registro, se utiliza el fichero .reg, por lo tanto, se

escribe “work.reg” en <tipo de componente>.

- <bits genéricos>: de los ficheros ya creados, hay algunos que tienen unos bits

genéricos. En este caso, sirven para determinar el tamaño de los vectores de

entrada/salida que van a sus puertos. Por ejemplo, si se escribe “generic map (7)”

en la declaración de un componente tipo “.reg” significa que la entrada y la

salida de este componente tendrá un tamaño de 7 bits.

Los ficheros de la UD que tienen genéricos son: “reg”,”mux2”,”mux4”,”inc”.

- <puertos del componente>: aquí se escriben los distintos puertos del

componente. Es muy importante el orden. Hay que listar los puertos en el orden

en el que se han definido al crear el tipo de componente. Si hay un puerto de

entrada al que no se asigna ninguna señal se tiene que poner tantas “X” como

bits tenga el puerto de entrada. Como se ve por ejemplo en la línea 24 de este

código.

Es posible que de alguna señal no se tenga que coger todo el rango entero de

bits, sino que sólo una parte de ellos. Entonces se determina el rango de bits que

se utilizan de la señal utilizando las palabras clave “downto” y “upto”. Por

ejemplo, tenemos la señal “señal1” de 5 bits. Y se tiene que asignar a un puerto

de un tamaño de 2 bits, es decir, sobran 3 bits de la señal1. Entonces, en el

“port map” se escribe: “port map(señal1(1 downto 0));”

El port map de cada componente se describe en el anexo 7.


104

Anexo 7 Port map de cada Componente

A continuación se describe el orden de los puertos de los componentes que

siempre tienen el mismo orden de puertos:

Reg1 PORT MAP (<reloj>,<reset>,<enable>,<in>,<out>);

Reg PORT MAP (<reloj>,<reset>,<enable>,<in>,<out>);

Mux4 PORT MAP (<in00>,<in01>,<in10>,<in11>,<bits de selección>,<out>);

Es importante fijarse bien a que puerto del multiplexor va asignada cada

entrada para ponerlas aquí en el orden correcto.

Por ejemplo, la entrada que se selecciona cuando los bits de selección

valen “10” deberá ir en el tercer lugar.

Mux2 PORT MAP (<in00>,<in01>,<bit de selección>,<out>);

Inc PORT MAP (<in>,<out>);

ALU Dependerá de cómo se haya diseñado en cada caso. En el caso del ejemplo es: PORT MAP (<in1>,<in2>,<bits de selección, <bit flag z>,< out>);

RAM PORT MAP (<reloj>,<lect/escrit>,<bus direcciones>,<data in>,<data out>);

ROM PORT MAP (<bus direcciones>,<data out>);


105

Anexo 8 Análisis de UD.VHDL

Este bloque se puede representar así:

Figura 51. Esquema del bloque de UD

Anexo 8.1 Puertos de la UD

Así pues, las entradas y salidas de este bloque quedarían definidas en código VHDL así:

Figura 52. Puertos de UD

Todos los puertos han salido representados en el esquema del bloque UD. Todos excepto los 4

últimos: “dbug_PC”, “dbug_A”, “dbug_B” y “dbug_ IR”.

Estos puertos, que empiezan por “dbug_” son unos puertos de salida de la Unidad de Datos

que sirven para que, una vez implementada físicamente la máquina sencilla en la FPGA, se

puedan observar señales internas de la UD como el registro PC, A, B e IR.

Los puertos de entrada y salida de la UD no siempre son los mismos en todas las máquinas

sencillas. Por ejemplo, esta máquina tiene la señal de enable y de salida del Flag Z, pero

hay otras máquinas sencillas que no tienen Flag Z, así que estos dos puertos puede que

sobren en algunos casos. O hay máquinas sencillas que tienen 3 registros de datos. O

también puede ser que tengan un registro PC pero que su tamaño en vez de 7 bits como en

este caso, sea de 14 bits, por ejemplo. Con lo cual, habría que modificar el rango de bits de

este puerto.


106

Anexo 8.2 Bus de direcciones

Acerca de cambiar el rango de puertos. El rango del bus de direcciones, “addr”, en este

caso es de 7 bits. Es aconsejable que, aunque el bus de direcciones de la máquina sencilla

en cuestión sea mayor de 7 bits, éste se deje en 7 bits. Porque un bus de direcciones de 7

significa que se implementará una memoria de 27 = 128 direcciones, y para el programa

que ejecutará la máquina sencilla, con 128 direcciones da más que de sobra. Entonces

aumentar el tamaño del bus de direcciones significa aumentar la memoria y gastar recursos

innecesariamente. Sólo se cambiará el rango de bits del puerto de salida, el rango de bits de

la señal que se asigna a este puerto será el que tenga que ser. Entonces, lo que habrá que

hacer es coger el rango de bits más representativo de la señal. Lo más común es coger os 7

bits más bajos de la señal.

Anexo 8.3 Señales de la UD

La explicación teórica de que es, en general, una señal se encuentra en el Anexo 4.2.

Figura 53. Señales de UD

Se puede observar, que todas las señales la UD son los puertos de salida de los distintos

componentes que forman la UD. Por ejemplo, “PC” es la salida del registro PC, “MUX” es

la salida del multiplexor de 4 entradas. Hay dos casos especiales, que son “f” y “d”. Estas

dos son señales que recogen parte de la salida del registro IR. Más adelante se explica

mejor que se hace con estas dos señales.

Esta parte de código, lo más probable es que el alumno si tenga que modificarla. Puede ser

que haya que cambiar solo el nombre de las señales, o que haya que cambiar el rango

porque la señal es de otro tamaño, o que sobren señales, o que falten, y se tengan que crear

de nuevo. En general, tiene que haber una señal por cada señal que va desde un puerto de

un componente interno de la UD, hasta otro puerto de otro componente interno de la UD.

Anexo 8.4 Comportamiento de UD.VHDL

Figura 54. Componentes de UD

Con estas 7 líneas se describen los 7 componentes que forman la UD, que son: multiplexor,

registro PC, registro IR, sumador, registro A, registro B, registro Flag Z y la ALU.

La sintaxis para declarar componentes se explica en el Anexo 6.


107

Los port map de los componentes que siempre tiene el mismo orden de puesto están

descritos en el Anexo 7.

Para acabar la Unidad de Datos sólo hace falta gestionar aquellas señales que lo necesiten,

que en general son:

- Señales que tiene que salir fuera de la UD y por lo tanto tienen que asignarse

a un puerto. Las señales típicas a las que hay que asignar un puerto de salida

son: bus de direcciones y las señales a depurar (o “debugear”).

Lo que hay que hacer es coger la señal y asignarla al puerto. Si el tamaño de los

dos no coincide, hay que adaptar el tamaño de la señal del tamaño del puerto.

Por ejemplo, si la señal que se asigna al puerto del bus de direcciones es de 8

bits, y el puerto tiene un tamaño de 7 bits habrá que hacer:

“puerto (6 downto 0) <= señal (6 downto 0);”.

En el caso de esta máquina sencilla, coinciden los bits, así que directamente se

escribe:

Figura 55. Asginación de puertos dbug y addr.

Nótese que hay puertos de salida de la UD a los que ya se le asignado una señal

directamente en la declaración del componente. Por ejemplo, en este caso la

salida de la ALU se asigna directamente al puerto “wdata” en la declaración de

la ALU.

- Señales que se tienen que “fraccionar” y que cada fracción se dirige a un

lugar distinto. Como por ejemplo, en este caso, la señal IR, se tiene que dividir

en operando fuente, operando destino y código de operación. Aquí también hay

que adaptar el tamaño de la señal al puerto:

Figura 56. Asginación de CO, f y d.


108

Anexo 9 Análisis de UC.VHDL

Anexo 9.1 Puertos de UC.VHDL

Figura 57. Puertos de la UC

Los más probable es que los puertos de la UC se tengan que modificar con cada máquina

sencilla. Para modificarlos se hará de la misma manera que se hecho con la Unidad de

Datos. Es aconsejable hacerse el esquema de la caja:

Figura 58. Esquema del bloque de la UC

Si se tiene esto claro, lo único importante a destacar es el puerto de salida “dbug_state”.

Este puerto se utiliza para poder saber en qué estado se encuentra la máquina sencilla

cuando se ha implementado físicamente en la FPGA. Por ejemplo, si la máquina sencilla se

encuentra en el estado “S12”, este puerto de salida sacará “1100”.


109

Anexo 9.2 Señales de UC.VHDL

Figura 59. Señales de la UC

En el caso de una Unidad de Control siempre tendremos 2 señales:

- Señal “o”. Se trata de un vector bits que almacenará todos los bits de control de

la UC. Por lo tanto su tamaño viene determinado por la cantidad de bits de

control. En el caso de la máquina sencilla de ejemplo: ePC (1 bit), eA (1 bit), eB

(1 bit), eFZ (1 bit), eIR (1 bit), rw (1 bit), selMUX (2 bits), selALU (2 bits). En

total 10 bits, por eso el rango es de “(9 downto 0)”. El alumno sólo tendrá que

cambiar el rango de la señal según su UC.

- Señal “s”. Esta señal es del tipo “estados”. Este tipo se ha creado especialmente

para la UC. La definición de este tipo se hace en la línea 16.

Según la definición del tipo “estados”, una señal de este tipo sólo podrá tomar

los valores que hay entre paréntesis. En este caso: S0,S6, S7, etc.

El alumno tendrá que modificar los valores que hay entre paréntesis según su

UC. Por ejemplo, si la UC solo puede tomar 3 estados distintos, se tiene que

poner “type estados is (S0,S1,S2);”


110

Anexo 9.3 Análisis Máquina de Estados de UC.VHDL

El objetivo de estas líneas es implementar la secuencia de estados de la máquina de estados

finitos en VHDL. Se basa

en el uso de la estructura

“when” y “case is – end

case”. Estas dos

estructuras del VHDL se

explican en el Anexo 4.7.

Se empieza con el caso de

que el estado actual, “s”,

sea “S0”. Según el

diagrama, siempre que la

máquina esté en el estado

“S0” tiene que pasar a

“S12” en el siguiente

flanco de subida de reloj.

Esto expresado en VHDL

son las líneas 25 y 26.

Figura 60. Máquina

de Estados en VHDL

Y así se tiene que hacer

para cada estado. Para cada estado tiene que haber un “when” que especifique qué tiene

que hacer en el siguiente flanco de subida del reloj.

Nótese que si hay varios estados que van a parar al mismo estado después de un flanco de

subida del reloj, se pueden agrupar en un “when”. Por ejemplo, los estados finales que

después de un flanco de subida del reloj han de volver al estado “S0” se pueden agrupar en

un “when” como se ha hecho en la línea 45.

Cuando el paso de un estado a otro depende de señales de entrada a la UC, como pueden

ser “CO” y/o “FZ”, se utilizará la estructura “case is – end case”.

Por ejemplo, en el caso del estado S6 depende del

“CO” para pasar a “S7” o “S9”. Si CO=X0 tiene

que saltar a S7. Si CO=X1 tiene que saltar a S9.

Esto en VHDL se expresa como en las líneas 41 y

42. Nótese que no se puede escribir “X0”, hay que

escribir todos los casos que implica “X0”, es decir,

“(”00|10”)”

Recordar que en un “case is – end case” se tienen que determinar todos los casos posibles,

así que cada “case is – end case” se acaba con un “when others=>”

También puede ser que, un salto de un estado a otro dependa de “CO” y además de “FZ”.

En este caso, hay que anidar dos “case is – end case”.


111

Por ejemplo, en el S12, en algunos casos, a partir de CO ya se puede determinar cuál será

el siguiente estado. Pero

hay un caso que no es así.

En el caso de que CO=11

hay que mirar el valor de

FZ para saber si hay que

saltar a S11 o a S0.

Eso en VHDL se hace

con dos “case is – end

case” anidados. Como se hace en las líneas de la 28 a la 38.

Anexo 9.4 Implementación de la Tabla con los Bits de Control

Figura 61. Tabla de Bits de Control en VHDL

El Alumno tiene que modificar las partes enmarcadas en los recuadros rojos:

En la primera parte, hay que poner la tabla de los bits de control. A cada estado asignarle el

vector de bits.

Por ejemplo, en este caso, cuando la máquina sencilla se encuentra en S0 la secuencia de

los bits de control es:

Pues esta misma secuencia es la que se le asigna a S0, en la línea 56 del código.

De esta parte del código, hay que destacar que, a veces, en los bits de selección de la ALU,

o de multiplexores, se da el caso de que es lo mismo poner “10” que “11”, así que en la

tabla se pone “1X”. Bien, pues en la simulación funciona correctamente, pero cuando se

implementa físicamente, no. Así que en estos casos hay que poner, o bien “10”, o bien

“11”, pero no “1X”.

MX1 MX0 ALU1 ALU0 L/E ePC eIR eA eB eFZ

S0 0 0 X X 0 1 1 0 0 0


112

Ahora los bits de cada estado se asignan a la señal auxiliar “o”. Ahora hay que determinar

que representa cada bit de este vector: qué bit es el ePC, cuál el de eA, etc.

Esto se hace como en las líneas de la 65 a la 72. El método es el mismo de asignación de

señales a puertos que ya se ha visto.

Anexo 9.5 El Puerto dbug_state

Finalmente, lo que hay que hacer en la UC es darle un valor numérico a cada estado. Este

valor numérico es el que saldrá por el puerto “dbug_state” y servirá para saber en qué

estado se encuentra la máquina.

Figura 62. Asignación de Valores a dbug_state

Como se puede ver, al S0 se le asigna “0000”, al S12 el “1100”, etc.

El Alumno tendrá que modificarlo según los estados que tenga su máquina sencilla y

asignar el número representativo de cada estado.

Anexo 10 Análisis RAM_pack y ROM_pack

Al principio de este fichero se definen dos constantes:

Figura 63. Constantes a modificar

- “RAM_ADDR”: se trata del número de bits del bus de direcciones de la

memoria. En este caso el bus de direcciones es de 7 bits. El alumno tiene que

modificar este número según los bits del bus de direcciones que tenga la

memoria de su máquina sencilla.

Al asignar el número de bits de bus de direcciones hay que tener el cuenta el

Anexo 8.2


113

- “RAM_DAT”: se trata del número de bits que ocupa cada palabra de la

memoria. Es decir, es el número de bits del dato de salida, o lo que es lo mismo,

del dato de entrada, o lo que es lo mismo el tamaño de cada celda de memoria.

En este caso, una palabra ocupa 16 bits. El alumno tiene que modificar este

número según los bits del bus de datos que tenga la memoria de su máquina

sencilla.

En el caso de que se tenga que crear una memoria ROM, el alumno también tiene los

ficheros “ROM” y “ROM_pack”. Los pasos a seguir son exactamente los mismos:

1) Se crea el fichero “ROM.VHDL” y no se modifica nada.

2) Se crea el “ROM_pack” y se modifican las dos constantes del principio del código,

según bus de direcciones y de datos de la ROM.

Anexo 11 Inicialización de Memoria

Una vez definidas las señales, se puede pasar a preparar la inicialización de la(s)

memoria(s). La(s) memoria(s) deben inicializarse con el programa y los datos que

ejecutará la máquina sencilla. En el caso de la máquina sencilla de ejemplo, el programa

que hay que memorizar en la RAM es el explicado en el apartado 5.2

Figura 64. Programa a guardar en memoria RAM

El alumno tiene que modificar la parte dentro del recuadro rojo.

Lo que hay que hacer es asignar a cada dirección de memoria un valor. La sintaxis general

para hacerlo es: <dirección> => X”<instrucción en hexadecimal>”,

- <dirección>: se trata de la dirección de memoria a la que se le asignará el valor.

Si escribe en número directamente se está expresando a dirección en decimal.

- <instrucción en hexadecimal>: En VHDL, si se escribe X”<número>” el

número se interpreta como un número hexadecimal. Entonces entre las comillas

se escriben las instrucciones en hexadecimal. Por ejemplo, en este caso, la

instrucción BEQ 2 se representa como el siguiente vector de bits:

11XXXXXXX0000010. (Para las “X” se escribe „1‟ ó „0‟). Entonces en

hexadecimal es X“C002”. Que es precisamente lo que se escribe en la dirección

7 de la memoria RAM de este ejemplo.


114

Nótese que, a todas las posiciones de la memoria se le tiene que asignar un valor. Así que

si tenemos un bus de direcciones de 7 bits, quiere decir que tenemos que asignar 128

valores. Pero como se ve en el Anexo 4.4, en VHDL, se puede utilizar la palabra reservada

“others” para asignar un valor a todo dirección a la que aún no se le ha asignado nada. En

la línea 44 se le da un valor a todas las direcciones a las que no se le ha asignado nada. En

este caso se le asigna “X”. Hay que poner tantas X como el tamaño de la celda de la

memoria. En este caso, la celda es de 16 bits, por eso hay 16 “X”.

En el caso de tener que inicializar una memoria ROM, lo único que cambia es la primera

línea. En el caso de una memoria RAM se escribe:

Figura 65. Declaración para memoria RAM

En el caso de una memoria ROM, se escribe:

Figura 66. Declaración para memoria ROM

Nótese que se ha cambiado el nombre de “PROGRAMA” por el de “PROGRAMA_ROM”

para que no coincidan los nombres de los dos programas. Y también se ha cambiado

“RAM_ADDR” y “RAM_DAT” por “ROM_ADDR” y “ROM_DAT” respectivamente.

Anexo 12 Gestión de Puertos de MaquinaSencilla.VHDL

En esta parte del código, es donde se da la opción al usuario de la máquina sencilla de que,

una vez implementada la máquina sencilla físicamente, pueda seleccionar entre el reloj de

50MHZ o el reloj manual, o que pueda decidir si quiere ver el estado del registro A o del

registro PC, etc.

Al principio del código MaquinaSencilla.VHDL, en la declaración de los puertos, se ha

declarado un puerto de entrada llamado “sw”, y de tamaño 6 bits. A este puerto de entrada

se la asignarán distintos switches, distintos interruptores, y con ellos se gestionarán los

puertos de la máquina sencilla. Cada bit de este vector es un interruptor.

Figura 67. Selección de Reloj

Se utiliza una estructura del VHDL que ya se explica en el Anexo 4.5: “with select when”.

Su función es, por lo menos en este caso, la misma que la función del “case is – end case”.

Con el bit 0 de la señal “sw” se escoge el reloj con el que funcionará la máquina sencilla.

Se pueden dar dos casos

- Que sw(0) = „0‟ : el reloj con el que funcionará la máquina será el paso a paso o

manual. Este reloj funciona con un pulsador. Cada vez que el usuario pulsa el

pulsador, se genera un pulso de reloj.

- Que sw(0) no valga „0‟: entonces el reloj que se utiliza es el reloj de 50 MHz.

El alumno no debe modificar nada de esta selección de relojes.


115

Con los bits 1 y 2 de “sw” se puede seleccionar qué señales se ven representadas con los 8

leds que tiene la placa donde está la Spartan 3:

Figura 68. Selección de Señal a Mostrar en Leds

Como los leds de la placa son 8, el tamaño de la señal “dbug_led” también es de 8 bits. Y

por lo tanto, las señales (o operación con señales) que se asignan a “dbug_led” debe tener

un tamaño de 8 bits también.

Aquí se ve una nueva operación lógica que no se había visto hasta ahora. Se llama

concatenación. La concatenación se explica en el Anexo 4.8

Así pues, en la línea 60, lo que se está expresando es que, si los bits 1 y 2 de “sw” valen

“00” a la señal “dbug_led” se le asignará un vector que contiene rw, ePC, eIR, eA, eB, eFZ

y CO. Se puede comprobar que la suma del tamaño de los enables, CO y rw da 8 bits.

En la línea 61, se están asignando los bits de selección de la ALU y del multiplexor. Si se

suma los bits de cada vector se puede comprobar que da 4 bits. Cómo se tiene que asignar

un vector de 8 bits, se concatena con “0000” para acabar de llegar a los 8 bits.

Finalmente, en la línea 62, se asigna “dbug_state”, que es el estado actual de la UC.

El alumno tiene que modificar estas asignaciones según las señales que sean de interés en

la máquina sencilla en cuestión. Por ejemplo, es probable que la máquina sencilla en

cuestión no tenga flag Z, entonces la señal “eFZ” tiene que eliminarse. En los leds se

suelen representar señales de 1 bit, o pocos bits, agrupadas. Las señales de un tamaño

mayor quizá es más apropiado representarlas en hexadecimal con los displays 7 segmentos.

Con los bits 3, 4 y 5 se vector “sw” se puede seleccionar que señal se representa en los

displays BCD de 7 segmentos que incorpora la placa.

Figura 69. Selección de Señal a Mostrar en Displays 7 segmentos

En este caso, dbug_in es un vector de 16 bits, así que las señales (o operaciones con

señales) que se asignan al este vector deben tener un tamaño total de 16 bits. Si la

asignación no llega a los 16 bits, se concatena con ceros para llegar a los 16 bits, como ya

se ha hecho anteriormente.


116

El alumno tiene que modificar estas asignaciones según las señales que sean de interés en

la máquina sencilla en cuestión. Por ejemplo, es probable que la máquina sencilla en

cuestión no tenga un registro B, entonces la señal “dbug_B” tiene que eliminarse. En los

displays 7 segmentos se suelen representar señales de bastantes bits, hasta un máximo de

16 bits por señal, y se representan en hexadecimal.

Anexo 13 Sintetizar un Diseño

Para comprobar si, el archivo en el máximo nivel de la jerarquía, tiene un buena sintaxis y

además en sintetizable se tiene que hace doble clic en “ Synthesize – XST”

Figura 69. Herramienta Synthesize

Al hacer doble clic empezará a intentar sintetizar la máquina sencilla. Mientras está

trabajando se observa esto:


117

Figura 70. Ejecutándose la Síntesis

Cuando acabe nos aparecerá el veredicto representado en un símbolo. Los 3 símbolos

posibles son los mismo que cuando se comprueba la sintaxis, y significan los mismo. En

caso de warnings hay que leerlos, entenderlos y valorar si afectan al funcionamiento de la

máquina sencilla. En caso de errores, hay que detectarlos y corregirlos.

Anexo 14 Implementar un Diseño

Para ello hay que hacer doble clic en Implement Design:

Figura 70. Herramienta Implement Design

Cuando acabe nos aparecerá el veredicto representado en uno de los 3 símbolos. En caso

de warnings hay que leerlos, entenderlos y valorar si afectan al funcionamiento de la

máquina sencilla. En caso de errores, hay que detectarlos y corregirlos.


118

Anexo 15 Cuando no Coincide Simulación y Realidad

Al observar buses y señales, puede ser que no coincida exactamente con la simulación y

que aún así la máquina esté funcionando correctamente. Esto es porque los buses toman

distintos valores pero no siempre se utiliza el valor que tiene el bus. Por ejemplo, en el

caso de la señal de wdata, que es el dato que se escribe en memoria, irá valiendo distintos

valores, pero de todos los valores que toma, sólo interesa aquellos valores que coinciden

con que la señal de R*/W vale „1‟. Porque es entonces cuando realmente se escribe el dato

que hay en el bus en la memoria RAM.

Por lo tanto, cuando una señal no coincida con la simulación, hay que ver si es obligado

que coincida o no. Esto se determina observando a que componente va a parar la señal y

observando si le va a afectar al componente o no.

Esto solo pasa con señales y buses. Los registros deberían seguir exactamente los valores

que marca la simulación.

Prácticas de Máquina Sencilla con FPGA Bibliografía y Referencias

119

7 Bibliografía y Referencias

[1] http://www.xilinx.com

[2] Spartan – 3 Starter Kit Board User Guide:

http://www.digilentinc.com/Data/Products/S3BOARD/S3BOARD_RM.pdf

[3] Xilinx ISE 12.3 Software Manuals, Xilinx, Inc., 2007

[4] Serafín Alfonso Pérez, Enrique Soto, Santiago Fernández, “Diseño de Sistemas Digitales con VHDL”

[5] http://es.wikipedia.org/wiki/FPGA

[6] Sistemas Electrónicos Digitales I, Apuntes de la asignatura

http://www.xilinx.com/

http://www.digilentinc.com/Data/Products/S3BOARD/S3BOARD_RM.pdf

http://es.wikipedia.org/wiki/FPGA

prácticas de máquina sencilla con fpga -...

Documents