Disen126 no, implementacio19 on y mejoras de una unidad de ... · Informe de Proyecto de Graduaci...

Tecnologico de Costa Rica

Escuela de Ingenierıa Electronica

Diseno, implementacion y mejoras de una unidad de comaflotante (FPU) con operaciones no lineales

Informe de Proyecto de Graduacion para optar por el tıtulo de

Ingeniero en Electronica con el grado academico de Licenciatura

Jeffry Ignacio Quiros Fallas

Cartago, 17 de junio, 2016

Resumen

Este trabajo es la continuacion del desarrollo de una unidad aritmetica de coma flotan-

te(FPU), iniciada el semestre anterior, basada en el estandar IEEE 754. Para esta etapa se

integraron a la unidad anterior los modulos de calculo de las operaciones trigonometricas

seno y coseno utilizando arquitecturas de 32 y 64 bits. Las operaciones trigonometricas

se implementaron y verificaron sobre una placa de prototipos (FPGA) utilizando el len-

guaje de descripcion de hardware(HDL) Verilog. Se realizo la verificacion funcional de

las operaciones a nivel de simulacion y sobre la FPGA, donde se obtuvieron porcentajes

de error menores al 1%, respecto al modelo teorico de referencia elaborado en el software

Octave. Ademas, se presenta un estudio completo sobre el rendimiento electrico de la

unidad: consumo de potencia, reportes de tiempos y uso de recursos de hardware.

Palabras clave: Algoritmo CORDIC, representacion IEEE 754 de coma flotante, Unidad

de coma flotante (FPU), Verilog, FPGA.

g

Abstract

The following work describes the enhancement of a floating point unit, based on the IEEE

754 standard. A module for non-linear operations such as the sine and cosine functions,

based on the Cordic algorithm, has been incorporated to the FPU, both for 32-bit and 64-

bit data sizes. Modules were described on Verilog HDL, incorporated into the FPU and

ported to an FPGA board, where they were succesfully tested at 100MHz. Operation

results show an error of less than 1% compared to a reference model based on GNU

Octave. Power, speed and hardware requirements were proven satisfactory as per system

requirements.

Keywords: CORDIC algorithm, IEEE 754 floating point representation, Floating point

unit (FPU), Verilog, FPGA.

A mis queridos padres.

Agradecimientos

Primero que todo quiero agradecer a mis padres, que con su incansable apoyo y fe en mis

capacidades, me impulsaron y no permitieron que me me diera por vencido, por mas que

el camino en algunos tramos pareciera muy largo y difıcil de recorrer. Gracias por todos

los sacrificios que realizaron durante todos estos anos.

Tambien a mis amigos que me acompanaron y brindaron su apoyo, ası como yo les brinde

el mıo en algun momento, y que con su ayuda hoy he podido alcanzar mis metas.

Jeffry Ignacio Quiros Fallas

Cartago, 17 de junio del 2016

Indice general

Indice de figuras iii

Indice de tablas vii

1 Introduccion 1

1.1 Entorno del proyecto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2 Descripcion del problema y justificacion. . . . . . . . . . . . . . . . . . . . 2

1.3 Sıntesis del problema. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.4 Enfoque de la solucion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.5 Procedimiento metodologico. . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.6 Meta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.7 Objetivos y estructura. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.7.1 Objetivo General. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.7.2 Objetivos Especıficos. . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.7.3 Estructura de la tesis. . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 Marco teorico 5

2.1 Estandar IEEE 754 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.1.1 Formatos de precision en coma flotante. . . . . . . . . . . . . . . . 7

2.2 Algoritmo CORDIC para el calculo de operaciones trigonometricas. . . . 10

2.2.1 Fundamento Teorico. . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.3 Arquitecturas de implementacion del algoritmo CORDIC. . . . . . . . . . 14

2.3.1 Arquitectura bit-paralela iterativa. . . . . . . . . . . . . . . . . . . 14

2.3.2 Arquitectura bit-paralela desplegada. . . . . . . . . . . . . . . . . . 15

2.3.3 Arquitectura bit-serie iterativa. . . . . . . . . . . . . . . . . . . . . 17

3 Diseno y verificacion en hardware del modulo de calculo trigonometrico. 19

3.1 Generalidades. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3.2 Implementacion del modelo de referencia de alto nivel CORDIC. . . . . . 20

3.2.1 Implementacion del Algoritmo CORDIC en hoja de calculo. . . . . 20

3.2.2 Implementacion del algoritmo CORDIC en Octave. . . . . . . . . 21

3.3 Hardware propuesto para el algoritmo CORDIC. . . . . . . . . . . . . . . 23

3.3.1 Descripcion del funcionamiento del modulo CORDIC. . . . . . . . 24

3.3.2 Maquina de estados del modulo CORDIC. . . . . . . . . . . . . . 30

i

ii Indice general

3.4 Diseno e implementacion del hardware de pruebas. . . . . . . . . . . . . . 35

3.5 Resultados experimentales. . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3.5.1 Metodologıa de verificacion. . . . . . . . . . . . . . . . . . . . . . . 39

3.5.2 Resultados de pruebas en simulacion y en implementacion de hard-

ware en la FPGA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

3.5.3 Recursos de hardware utilizados. . . . . . . . . . . . . . . . . . . . 47

3.5.4 Consumo de potencia. . . . . . . . . . . . . . . . . . . . . . . . . . 48

3.5.5 Reporte de tiempos. . . . . . . . . . . . . . . . . . . . . . . . . . . 49

4 Modulo para el manejo de la excepcion NaN en las operaciones imple-

mentadas en la FPU. 51

4.1 Interfaz general de la FPU. . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

4.1.1 Descripcion del funcionamiento de la interfaz de la FPU. . . . . . . 53

4.1.2 Modulo de deteccion de resultados NaN. . . . . . . . . . . . . . . . 57

4.1.3 Resultados experimentales. . . . . . . . . . . . . . . . . . . . . . . . 58

5 Conclusiones y Recomendaciones 61

5.1 Conclusiones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

5.2 Recomendaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Bibliografıa 63

A Tablas obtenidas mediante la implementacion del Algoritmo CORDIC

en hoja de calculo y el software Octave. 65

B Diagramas de estado de las maquinas de control. 67

C Scripts mas importantes implementados en Octave 69

D Scripts implementados en Verilog 73

Indice de figuras

2.1 Acomodo de bits para la representacion binaria de un numero en coma

flotante utilizando el estandar IEEE 754-2008, donde s corresponde al bit

de signo, E el exponente y T la mantisa o significando. Fuente: [1]. . . . . 8

2.2 Ordenamiento de bits en el formato de precision simple. Notese que el

ancho de palabra del exponente es 8 bits y el de la mantisa 23, para este

formato de precision. Fuente: [9]. . . . . . . . . . . . . . . . . . . . . . . . 8

2.3 Ordenamiento de bits en el formato de precision doble. Notese que el ancho

de palabra del exponente es 11 bits y el de la mantisa 52, para este formato

de precision. Fuente: [9]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.4 Vector bidimensional antes y despues de ser rotado θ grados. Fuente: [13] . 10

2.5 Pseudo-rotacion de un vector bidimensional. Notese como el vector pseudo-

rotado aumenta su magnitud por un factor de V√

1 + tan2θ, donde V es el

valor original de la magnitud. Fuente: [13] . . . . . . . . . . . . . . . . . . 11

2.6 Arquitectura bit-paralela iterativa para la implementacion en hardware del

algoritmo CORDIC, donde se puede observar que esta arquitectura se

utilizan muy pocos componentes, debido al proceso iterativo que realiza el

algoritmo, lo que permite la reutilizacion de recursos. Fuente: [13] . . . . . 15

2.7 Arquitectura bit-paralela desplegada para la implementacion en hardware

del algoritmo CORDIC. Notese que los componentes en cada etapa se

deben de replicar en la siguiente, por lo que no se reutiliza ninguno, au-

mentado el consumo de recursos. Fuente: [13] . . . . . . . . . . . . . . . . 16

2.8 Arquitectura bit-serie iterativa para la implementacion en hardware del

algoritmo CORDIC. Notese que se tiene la ventaja de que los anchos

de canal son de 1 bit, pero el tiempo de ejecucion de una operacion es

proporcional al ancho de palabra de los operandos. Fuente: [13] . . . . . . 17

3.1 Diagrama de entradas y salidas para el modulo de calculo de seno y coseno,

basado en el algoritmo CORDIC. Esta version del modulo de calculo

trigonometrico contiene el modulo de suma/resta en coma flotante. . . . . 23

iii

iv Indice de figuras

3.2 Diagrama completo de la variacion de la arquitectura CORDIC bit-paralela

iterativa, en la cual, debido al uso de un sumador/restador en coma flotante,

se utiliza solo uno para evitar un excesivo consumo de recursos. Las senales

de color rojo corresponden al bus de reloj, las de color amarillo a las senales

de habilitacion de los registros y los contadores, las de color verde a las

senales de reset de los registros de la arquitectura y las de color negro a los

buses de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3.3 Etapa de la Arquitectura CORDIC, que realiza la operacion de desplaza-

miento de las variables X y Y, direcciona los valores de la ROM, y decide

de cual variable se toma el signo, dependiendo del modo de operacion del

algoritmo. Notese que la operacion de desplazamiento es realizada por dos

restadores de coma fija. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.4 Etapa de la Arquitectura CORDIC, que realiza la suma o resta en coma

flotante, dependiendo de cual variable se este calculando y la iteracion

actual. Notese el uso de un solo sumador/restador para el calculo de las

variables, a diferencia de la arquitectura original, debido a que se usa el

modulo de suma/resta en coma flotante. . . . . . . . . . . . . . . . . . . . 28

3.5 Etapa de la Arquitectura CORDIC, que direcciona a la salida el valor de

la variable Xn o Yn, e invierte el valor del bit de signo, dependiendo de la

operacion y del cuadrante al que pertenezca el angulo a calcular. . . . . . . 30

3.6 Primera parte del diagrama de flujo de la maquina de estados disenado para

el control de los datos en el modulo CORDIC. Esta parte permite realizar

el calculo de las variables X, Y y Z, hasta la iteracion n-1, y aumentar el

valor del contador de variables e iteraciones, para comenzar el proceso de

calculo de variables para la siguiente iteracion. . . . . . . . . . . . . . . . . 33

3.7 Segunda parte del diagrama de flujo de la maquina de estados disenado

para el control de los datos en el modulo CORDIC. Se puede observar

como esta parte permite obtener un resultado final, dependiendo de la

operacion que se este realizando y de a que cuadrante pertenece el angulo

de entrada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

3.8 Ambiente de verificacion desarrollado, para la comprobacion del correcto

funcionamiento de los modulos implementados y la recoleccion de los resul-

tados obtenidos en hardware, para despues ser comparados con los datos

teoricos. Fuente: [4] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3.9 Modulos para la verificacion funcional del algoritmo CORDIC una vez

implementado en la placa de desarrollo Digilent Nexys 4. El multiplexor

implementado en la entrada del modulo de transmision UART cambia la

cantidad de canales de entrada, dependiendo de la arquitectura sintetizada. 36

3.10 Diagrama de flujo disenado para la implementacion de la maquina de con-

trol del proceso de verificacion a nivel de hardware, en el cual se realizan

pruebas con 2048 datos, cuyos resultados son enviados a una computadora

para la posterior comparacion con los resultados teoricos. . . . . . . . . . . 38

Indice de figuras v

3.11 Graficas de los resultados de aplicar la operacion coseno a un barrido de

valores desde 0 hasta 2π, obteniendo resultados teoricos y experimentales

con 8 y 16 iteraciones, en las cuales se observa que con 8 iteraciones, los

resultados difieren con respecto a los valores teoricos, no ası en el caso con

16 iteraciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3.12 Graficas de los resultados de aplicar la operacion seno a un barrido de

valores desde 0 hasta 2π, obteniendo resultados teoricos y experimentales

con 8 y 16 iteraciones, en las cuales se observa que con 8 iteraciones, los

resultados difieren con respecto a los valores teoricos, no ası en el caso con

16 iteraciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

3.13 Grafica del porcentaje de error obtenido al aplicar a la operacion coseno

un barrido de valores desde 0 hasta 2π, utilizando 8 y 16 iteraciones para

el calculo. Notese como el aumento en la cantidad de iteraciones utilizadas

en el calculo reduce los porcentajes de error desde un 400% hasta menos

de un 1%. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.14 Grafica del porcentaje de error obtenido al aplicar a la operacion seno un

barrido de valores desde 0 hasta 2π, utilizando 8 y 16 iteraciones para el

calculo. Notese como el aumento en la cantidad de iteraciones utilizadas

en el calculo reduce los porcentajes de error desde un 400% hasta menos

de un 1% . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

3.15 Grafica de resultados obtenidos en la operacion coseno para la arquitec-

tura de 32 bits. Se despliegan los resultados teoricos y experimentales en

hardware, respectivamente. . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3.16 Grafica de resultados obtenidos en la operacion seno para la arquitectura de

32 bits. Se despliegan los resultados teoricos y experimentales en hardware,

respectivamente. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3.17 Grafica del porcentaje de error de la operacion coseno en 32 bits, donde

se observa que los porcentajes no sobrepasan el 1%. Es importante anotar

que el error aumenta conforme el algoritmo se aproxima a los lımites de su

rango o dominio de operacion, por lo que son esperables. . . . . . . . . . . 46

3.18 Grafica del porcentaje de error de la operacion seno en 32 bits, donde se

observa que los porcentajes no sobrepasan el 1%. Es importante anotar

que el error aumenta conforme el algoritmo se aproxima a los lımites de su

rango o dominio de operacion, por lo que son esperables. . . . . . . . . . . 46

3.19 Graficos del consumo de potencia del modulo CORDIC en las arquitec-

turas de 32 y 64 bits, donde se puede observar en detalle el porcentaje de

consumo que tienen los diferentes componentes del diseno. Fuente: Vivado

Post-Implementation Report. . . . . . . . . . . . . . . . . . . . . . . . . . . 48

4.1 Interfaz General de la FPU, que integra las operaciones suma, resta, seno,

coseno y multiplicacion, ademas de permitir realizar la identificacion y el

manejo de la combinacion de operandos de entrada que generen la excepcion

NaN. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

vi Indice de figuras

4.2 Interfaz general de la FPU detallada, que integra las operaciones suma,

resta, seno, coseno y multiplicacion, ademas del modulo que permite de-

tectar y manejar la combinacion de operandos que generan la excepcion

NaN. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

4.3 Graficos del consumo de potencia del modulo de interfaz general de la

FPU en las arquitecturas de 32 y 64 bits, donde se observar en detalle el

porcentaje de consumo que tienen los diferentes componentes del diseno.

Fuente: Vivado Post-Implementation Report. . . . . . . . . . . . . . . . . . 56

4.4 Modulo de manejo de la excepcion NaN, que permite detectar cuando la

combinacion de valores de entrada para calculo generaran un resultado

NaN, para las operaciones suma, resta, coseno, seno y multiplicacion. . . . 57

4.5 Simulacion de la operacion suma, con valores de operandos de entrada que

generan la excepcion NaN. Notese como la bandera NaN flag se activa al

evaluar los valores de entrada. Fuente: Vivado Simulator . . . . . . . . . . 58

4.6 Simulacion de la operacion coseno, con un valor de operando de entrada

que genera la excepcion NaN. Notese como la bandera NaN flag se activa

al evaluar los valores de entrada. Fuente: Vivado Simulator . . . . . . . . 58

4.7 Simulacion de la operacion multiplicacion, con valores de operandos de

entrada que generan la excepcion NaN. Notese como la bandera NaN flag

se activa al evaluar los valores de entrada. Fuente: Vivado Simulator . . . 59

B.1 Diagrama de estados de la maquina de control que maneja los modulos

implementados para las pruebas en la FPGA y la transmision de datos por

via serial. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

B.2 Diagrama de estados de la maquina de control del Algoritmo CORDIC. . . 68

Indice de tablas

2.1 Valores de los parametros que definen los formatos basicos de numeros en

coma flotante, para los tres formatos binarios y los dos formatos decimales.

Fuente: [1]. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.2 Interpretacion de patrones de bits del estandar IEEE 754 para el formato

de precision simple y doble, para cada uno de los posibles tipos de numero

que se pueden representar. . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3.1 Cambios que se presentan en los valores de salida del algoritmo CORDIC,

dependiendo del cuadrante del cual haya sido desplazado el angulo de entrada. 22

3.2 Resultados obtenidos de la implementacion en Octave del algoritmo CORDIC,

trabajando con diferentes cantidades de iteraciones, para un angulo de en-

trada de 126.467◦, donde se puede observar que el error disminuye conforme

se aumentan las iteraciones que realiza el algoritmo. . . . . . . . . . . . . . 22

3.3 Tabla de verdad que permite definir si se realiza una suma o resta en el

modulo de suma/resta en coma flotante, dando como resultado la imple-

mentacion de una compuerta logica XNOR para esta operacion. . . . . . . 29

3.4 Tabla de verdad, utilizada para el diseno del modulo sign inv, encargado

de cambiar el valor del bit de signo del resultado final, cuando el angulo de

entrada a calcular pertenece al 2do o al 3er cuadrante. . . . . . . . . . . . . 31

3.5 Valores maximos, mınimos y promedio de porcentaje de error de las opera-

ciones seno y coseno para la arquitectura de 32 bits, con 8 y 16 iteraciones,

donde se puede observar de manera numerica como el porcentaje de error

disminuye al aumentar la cantidad de iteraciones utilizadas. . . . . . . . . 43

3.6 Valores maximos, mınimos y promedio de porcentaje de error de las opera-



disminuye al aumentar la cantidad de iteraciones utilizadas. . . . . . . . . 44

3.7 Valores maximos, mınimos y promedio de porcentaje de error de las op-

eraciones seno y coseno para las arquitecturas de 32 y 64 bits, para la

implementacion final con 16 iteraciones. . . . . . . . . . . . . . . . . . . . . 47

3.8 Recursos consumidos por el modulo de calculo CORDIC, para 32 bits,

donde se observa que se utilizan muy pocos recursos debido a la arquitec-

tura iterativa implementada para la solucion de las operaciones. . . . . . . 48

vii

viii Indice de tablas

3.9 Recursos consumidos por el modulo de calculo CORDIC, para 64 bits,

donde se observa que se utilizan muy pocos recursos debido a la arquitec-

tura iterativa implementada para la solucion de las operaciones. . . . . . . 48

3.10 Consumo de potencia del modulo CORDIC para el calculo de las opera-

ciones seno y coseno en las arquitecturas de 32 y 64 bits. . . . . . . . . . . 49

3.11 Reporte de tiempos referente al Setup Slack, para las arquitecturas de 32

y 64 bits, en donde un valor positivo de slack denota que se cumple con

los tiempos en la FPGA, dando cabida a un aumento en la frecuencia de

operacion del modulo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

3.12 Reporte de tiempos referente al Hold Slack, para las arquitecturas de 32



operacion del modulo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

4.1 Recursos consumidos por el modulo de interfaz general de la FPU, para 32

bits, donde se puede notar que los recursos utilizados por las operaciones

implementadas hasta el momento son mınimos, dando cabida a desarrollar

mas operaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

4.2 Recursos consumidos por el modulo de interfaz general de la FPU, para 64



mas operaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

4.3 Consumo de potencia del modulo de interfaz general de la FPU en las

arquitecturas de 32 y 64 bits. . . . . . . . . . . . . . . . . . . . . . . . . . 56

4.4 Combinacion de valores de los operandos de entrada que generan la ex-

cepcion NaN, para las operaciones suma, resta, coseno, seno y multipli-

cacion, en las arquitecturas de 32 y 64 bits. . . . . . . . . . . . . . . . . . . 57

A.1 Resultados obtenidos en hoja de calculo, desplegando valores teoricos, val-

ores obtenidos del algoritmo CORDIC, y el porcentaje de error con difer-

ente cantidad de iteraciones. . . . . . . . . . . . . . . . . . . . . . . . . . . 65

A.2 Valores precalculados de arcotan(2−i) necesarios para el calculo de las op-

eraciones seno y coseno con el algoritmo CORDIC. . . . . . . . . . . . . . 66

Capıtulo 1

Introduccion

1.1 Entorno del proyecto.

El Laboratorio de Diseno de Circuitos Integrados, DCILab, es un laboratorio de la Escuela

de Ingenierıa Electronica, del Instituto Tecnologico de Costa Rica. En este laboratorio se

han impulsado y desarrollado diversos proyectos orientados al procesamiento de senales

sobre dispositivos programables y circuitos integrados, entre los cuales se encuentra el

Sistema de Reconocimiento de Patrones Acusticos, SiRPA.

El SiRPA forma parte de un proyecto de la Escuela de Ingenierıa en Electronica de-

nominado ”Sistema Electronico Integrado en Chip (SoC)”, cuya finalidad es detectar

disparos de armas de fuego y de motosierras, a partir del analisis de patrones de audio

en una red inalambrica de sensores, para monitorizar zonas protegidas a lo largo del te-

rritorio nacional[4]. El SiRPA, entonces, es basicamente la implementacion algorıtmica

software-hardware del proceso de clasificacion de senales, una vez que este sistema ha

sido entrenado para reconocer senales especıficas, con algunos resultados ya mostrados

en [8] [11] [14]. Debido a que el SiRPA se encarga de la extraccion e identificacion de

las caracterısticas de la senal, el calculo de probabilidades y la toma de decisiones, es

que se necesita la implementacion una unidad de coma flotante, dado que el algoritmo

matematico, Modelos Ocultos de Markov [3] [10] (HMM por sus siglas en ingles), que se

escogio para la implementacion del SiRPA, requiere procesar datos en coma flotante.

En el contexto de este proyecto se ha implementado un procesador de aplicacion especıfica

(ASP por sus siglas en ingles) cuya arquitectura esta basada en el juego de instrucciones

(ISA, por sus siglas en ingles) RISC-V [16], desarrollado por la Division de Ciencias de

Computacion de la Universidad de California, Berkeley. El objetivo del procesador es eje-

cutar el HMM, lo que implica el uso intensivo de aritmetica de coma flotante. Ello derivo

en la necesidad de una unidad de coma flotante (FPU, a partir del ingles Floating Point

Unit) aparte, que descargara al ASP de la ejecucion de estas funciones para optimizar

tanto el tiempo de ejecucion como el consumo de potencia. Una primera version de esta

FPU implementaba las operaciones de suma, resta y multiplicacion, ası como el manejo

1

2 1.2 Descripcion del problema y justificacion.

de excepciones cuando se presentan resultados que tiendan al infinito, y el redondeo. Esta

unidad, no obstante, necesitaba mejoras en terminos de velocidad de ejecucion y potencia.

Ademas, existıa la necesidad de implementar algunas operaciones no lineales, necesidad

que derivo en el presente proyecto de graduacion.

Un aspecto importante que se debe tener en cuenta, es que la FPU que se esta implemen-

tando toma como referencia el estandar IEEE 754-2008 [5] [12] y el ISA RISC-V, por lo

que estos dos temas se deberan de investigar y estudiar para la realizacion del proyecto.

1.2 Descripcion del problema y justificacion.

La FPU objetivo de este proyecto se ha pensado en primera instancia como una unidad

independiente que no solo pueda trabajar con el ASP ya mencionado, sino que se pue-

da usar para futuros proyectos que requieran procesar aritmetica de coma flotante. Es

por dicha razon que la FPU debera quedar debidamente documentada, para poder ser

utilizada por un usuario que requiera el desarrollo de algun otro proyecto con la FPU.

En una primera etapa, el estudiante Diego Rodrıguez Valverde implementa las operaciones

aritmeticas suma, resta y multiplicacion [9], tomando como punto de partida la experiencia

con la que se contaba en el DCILab en el desarrollo de FPUs [7], sentando ası las bases

para la implementacion de mas operaciones.

Entre los aspectos a optimizar y desarrollar para este proyecto se incluyen: mejora del

temporizado (timing) de toda la unidad, el manejo de la excepcion NaN (Not a Number),

ası como tambien la implementacion de las operaciones trigonometricas seno y coseno,

ademas de la escalabilidad de la unidad para etapas posteriores de desarrollo.

Para la implementacion de la FPU, se tomara el estandar IEEE 754-2008 como referencia

para el manejo de operaciones en coma flotante, pero este no se va a implementar como

tal, sino que se tomara como punto de partida para definir un estandar propio para el

modulo a disenar.

1.3 Sıntesis del problema.

Inexistencia de operaciones aritmeticas basicas seno y coseno en la primera etapa de

implementacion de la FPU, ası como la operacion de manejo de excepcion NaN, Not a

Number.

1 Introduccion 3

1.4 Enfoque de la solucion.

En este proyecto se uso un enfoque basado en el diseno en ingenierıa y el desarrollo modular

(top-down) de sistemas digitales, partiendo de una especificacion abstracta hasta llegar a

la sıntesis fısica de la solucion sobre un dispositivo programable.

Para ello fue necesario el uso de distintas herramientas de software EDA que apoyaron el

diseno y verificacion de las distintas etapas. Este software incluyo el paquete integrado

de desarrollo sobre FPGAs Vivado de Xilinx, y el software libre de calculo matematico

Octave.

1.5 Procedimiento metodologico.

Como procedimiento metodologico utilizado para el cumplimiento de los objetivos se

siguio el proceso tıpico del diseno en ingenierıa, que incluyo la exploracion del estado del

arte, la propuesta de algunas soluciones, el desarrollo de las que se considero mas viables,y

su posterior verificacion.

En detalle, en primer lugar, se estudio acerca de la aritmetica de coma flotante basada en

el estandar IEEE 754-2008. Seguidamente, se investigo posibles formas o algoritmos que

permitan implementar las operaciones trigonometricas que se desean desarrollar.

Una vez investigado lo anterior, se procedio a desarrollar los modulos utilizando una

estrategia de diseno modular, a traves de la cual se definio la interfaz de entrada-salida,

y la estrategia de interconexion de los bloques que constituyen las diferentes operaciones

trigonometricas.

Seguidamente, los modulos se implementaron utilizando el lenguaje de descripcion de

hardware Verilog, y se verificaron utilizando un proceso de comparacion entre los re-

sultados obtenidos de simulaciones Post-Implementation, y los resultados obtenidos del

software Octave.

Por ultimo se integro los modulos disenados y desarrollados al procesador de aplicacion

especıfica, sobre el cual se ejecutaran rutinas matematicas complejas para corroborar el

funcionamiento conjunto de ambas unidades.

1.6 Meta.

Desarrollar un procesador de aplicacion especıfica con soporte de operaciones de coma

flotante en formato basado en IEEE 754-2008, compatible con la arquitectura de juego

de instrucciones abierto (ISA) del proyecto RISC-V, para resolver problemas de procesa-

miento de sonido aplicados a la proteccion ambiental.

4 1.7 Objetivos y estructura.

1.7 Objetivos y estructura.

1.7.1 Objetivo General.

Incorporar al menos dos operaciones aritmeticas complejas y capacidades de tratamiento

de la excepcion NaN a la version actual de unidad de coma flotante (FPU) compatible

con un procesador de aplicacion especıfica (ASP) basado en el ISA RISC-V.

1.7.2 Objetivos Especıficos.

• Implementar las funciones logicas-aritmeticas seno y coseno basadas en el formato

de representacion de numeros flotantes IEEE 754-2008 y el ISA RISC-V.

• Implementar la excepcion NaN de una operacion aritmetica invalida, basada en el

formato de representacion de numeros flotantes IEEE 754-2008 y el ISA RISC-V.

1.7.3 Estructura de la tesis.

El Capıtulo 2 ofrece un resumen de los fundamentos teoricos utilizados para el desarrollo

del proyecto. En el Capıtulo 3 se detalla la solucion implementada para la resolucion de

las operaciones seno y coseno, para lo que se presenta diagramas de bloques y explicacion

del funcionamiento, ademas de los resultados en simulacion y experimentales obtenidos en

las pruebas realizadas. En el Capıtulo 4 se explica la solucion para la implementacion del

manejo de la excepcion NaN, y se presentan algunos resultados de las pruebas realizadas

para la verificacion del funcionamiento del modulo. Finalmente en el Capıtulo 5 se ofrecen

conclusiones del trabajo realizado, y recomendaciones a considerar para futuros proyectos.

Capıtulo 2

Marco teorico

En este capıtulo se presentan los conceptos en los que se basa el sistema propuesto para

la solucion de operaciones trigonometricas, en el formato de representacion estandar de

numeros en coma flotante, IEEE 754-2008, en concreto las operaciones seno y coseno. A

continuacion se brinda informacion acerca del formato de palabra para la representacion

binaria de numeros en coma flotante, ya sea en precision simple o precision doble, 32 y

64 bits respectivamente, ası como para el manejo de la excepcion de resultados Not a

Number, NaN.

Se presenta ademas las bases teoricas de la rotacion de vectores, fundamento teorico en

el que se sustenta el algoritmo CORDIC, investigado e implementado para la resolucion

de las operaciones trigonometricas antes mencionadas.

2.1 Estandar IEEE 754

El estandar IEEE 754 especifica formatos y metodos para aritmetica en coma flotante en

sistemas computacionales, permitiendo obtener el mismo resultado, dado el mismo dato

de entrada, sin importar si el proceso es llevado a cabo en hardware, software, o una

combinacion de ambos [1]. Para lograr esto, los disenadores del estandar utilizaron el

metodo de notacion cientıfica, permitiendo representar un numero factorizandolo en dos

partes, la magnitud y la potencia [6].

Los formatos de representacion de numeros en coma flotante del estandar, son usados para

representar un subconjunto finito de los numeros reales. Los formatos se caracterizan

por: su base (binaria, decimal), precision (simple, doble, extendida) y por el rango de su

exponente, y cada uno puede representar un conjunto unico de datos en coma flotante [1].

El estandar define 5 formatos basicos:

• Tres formatos binarios, con codificaciones en longitud de 32, 64 y 128 bits.

• Dos formatos decimales, con codificaciones en longitud de 64 y 128 bits.

5

6 2.1 Estandar IEEE 754

Las representacion de un dato en coma flotante en un formato consiste en:

• Un triplete (signo, exponente y significando); en una base b, el numero en coma

flotante representado por un triplete tiene la siguiente forma:

(−1)signo · bexponente · significando

• Las representaciones para +∞,−∞

• Y las representaciones para qNaN, sNaN

El conjunto finito de numeros en coma flotante representables dentro de un formato en

particular es determinado por determinados parametros enteros:

• b = la base, 2 (binaria) o 10 (decimal),

• p = el numero de dıgitos en el significando, es decir, la precision,

• emax = el maximo exponente,

• emin = el mınimo exponente,

donde emin = 1 - emax para cada uno de los formatos.

En la Tabla 2.1 se presentan los valores de cada uno de los parametros para cada uno de

los formatos basicos; cada formato esta identificado por su base y el numero de bits de su

codificacion.

Tabla 2.1: Valores de los parametros que definen los formatos basicos de numeros en

coma flotante, para los tres formatos binarios y los dos formatos decimales.

Fuente: [1].

Formato Binario (b=2) Formato Decimal (b=10)

parametro binario(32 bits) binario(64 bits) binario(128 bits) decimal64 decimal 128

p, dıgitos 24 53 113 16 34

emax +127 +1023 +16383 +384 +6144

Sin importar el formato escogido, los siguientes datos deberan poder representarse[1]:

• Cualquier numero en coma flotante igual o diferente a cero y con signo de la forma:

(−1)s · be ·m

2 Marco teorico 7

donde

– s es igual a 1 o 0, donde 1 representa a los numeros negativos y el 0 a los

numeros positivos.

– e corresponde a cualquier numero entero entre emin ≤ e ≤ emax.

– m es un numero representado por una cadena de dıgitos de la forma d0 ∗d1d2...dp−1, donde di es un dıgito entero entre 0 ≤ di ≤ b; por lo tanto m

puede ser un valor entre 0 ≤ m ≤ b.

- Dos valores infinitos, +∞,−∞.

- Dos representaciones NaN, qNaN y sNaN.

El numero positivo mas pequeno representable en cada formato es bemin, mientras que el

mas grande es bemax ∗ (b− b1−p). Los numeros diferentes a cero con magnitudes menores a

bemin son llamados subnormales, debido a que sus magnitudes caen en valores entre cero

y el numero normal mas pequeno.

En la notacion cientıfica, los numeros pueden tener exponentes tanto negativos como

positivos. En la representacion binaria, el exponente debe normalizarse para ser utilizado,

ya que en un sistema computacional un exponente negativo deberıa almacenarse utilizando

una representacion en complemento a 2, pero para fines de comparacion entre valores, la

comparacion de valores en complemento a 2 es mas compleja que comparar valores que no

posean signo, por lo que al exponente se le suma un valor de sesgo para normalizar dicho

exponente, y ası ubicarlo dentro de los valores positivos siempre. Este valor de sesgo tiene

un valor igual a emin, por lo que el valor del exponente normalizado vendrıa dado por la

ecuacion (2.1)[9].

Exponente normalizado = Exponente− emin (2.1)

2.1.1 Formatos de precision en coma flotante.

En el estandar IEEE 754 existen varios formatos de representacion de numeros en coma

flotante, ya sean binarios, decimales o formatos extendidos.

Los formatos de precision, o almacenamiento, determinan la cantidad de espacio en memo-

ria que un valor en coma flotante necesita en memoria para almacenarse, y son utilizados

para representar un subconjunto definido finito de numeros reales. Cada formato se dife-

rencia de los demas por la ubicacion de la coma decimal, la precision del dato y el rango de

su exponente, ası como el hecho de que cada uno puede representar solo un determinado

conjunto de numeros en coma flotante[9].

Los formatos que se desarrollan en este documento tienen una distribucion definida de

bits, para representar un valor en coma flotante. En la Figura 2.1 se observa el acomodo

de los diferentes campos que conforman la representacion segun el estandar IEEE 754 [1].

8 2.1 Estandar IEEE 754

Figura 2.1: Acomodo de bits para la representacion binaria de un numero en coma flotante

utilizando el estandar IEEE 754-2008, donde s corresponde al bit de signo, E el exponente

y T la mantisa o significando. Fuente: [1].

En este documento solo se tratan dos formatos de precision binarios: el formato de pre-

cision simple y el de precision doble, y al igual que los formatos decimales y extendidos,

se caracterizan por tener un ancho de palabra definido.

Segun el patron de bits presente en la representacion binaria de un numero en coma

flotante, ası sera su interpretacion. En la Tabla 2.2 se presenta la interpretacion de dichos

patrones segun los valores en los campos de la representacion, ya sea para precision simple

o doble [9].

Formato de Precision Simple.

Este formato de precision tiene un ancho de palabra definido de 32 bits, de los cuales el

campo de signo ocupa 1 bit, el mas significativo de la cadena, y puede tomar dos valores

unicamente: 0 que representa a los numeros positivos, y 1 que representa a los numeros

negativos. El campo de exponente ocupa los 8 bits despues del bit de signo, siguiendo la

direccion de MSB a LSB, por lo que el exponente puede tomar cualquier valor desde 0 a

255, donde los valores desde 0 a 127 representan los exponentes negativos, y desde 128 a

255 representan los exponentes positivos. Por ultimo, el campo de mantisa ocupa 23 bits.

En la Figura 2.2 se muestra la distribucion de bits de cada campo para el formato de

precision simple.

Figura 2.2: Ordenamiento de bits en el formato de precision simple. Notese que el ancho

de palabra del exponente es 8 bits y el de la mantisa 23, para este formato de precision.

Fuente: [9].

La normalizacion del exponente para este formato se lleva a cabo con un valor de sesgo

de 127.

Formato de Precision Doble.

En el formato de precision doble se tiene un ancho de palabra definido de 64 bits, de los

cuales el campo de signo, al igual que en el formato de precision simple, ocupa 1 bit, el

2 Marco teorico 9

Tabla 2.2: Interpretacion de patrones de bits del estandar IEEE 754 para el formato de

precision simple y doble, para cada uno de los posibles tipos de numero que

se pueden representar.

Patron de bits

Tipo de

NumeroPrecision Simple Precision Doble

Numeros

Normales

Signo = 0 o 1

00h <Exponente Normalizado < ffhFraccion = Cualquier combinacion

de bits

Signo = 0 o 1

000h <Exponente Normalizado< 7ffhFraccion = Cualquier combinacion

de bits

Numeros

Subnormales

Signo = 0 o 1

Exponente Normalizado = 00h

Fraccion 6= 00000h

Signo = 0 o 1


Fraccion 6= 0000000000000h

Caso Especial

Cero con Signo

Signo = 0 o 1


Fraccion = 000000h

Signo = 0 o 1


Fraccion = 0000000000000h

Caso Especial

Infinito Positivo

Signo = 0

Exponente Normalizado = ffhFraccion = 00h

Signo = 0

Exponente Normalizado = 7ffhFraccion = 0000000000000h

Caso Especial

Infinito Negativo

Signo = 1

Exponente Normalizado = ffhFraccion = 00h

Signo = 1

Exponente Normalizado = 7ffhFraccion = 000000000000h

Caso Especial

Numeros no

representables

(Not a Number)

Signo = 0 o 1

Exponente Normalizado = ffhFraccion 6= 00000h

Signo = 0 o 1

Exponente Normalizado = 7ffhFraccion 6= 000000000000h

mas significativo de la cadena de bits. El campo de exponente ocupa los once bits despues

del bit de signo, siguiendo la direccion de MSB a LSB. Por ultimo, el campo de mantisa

ocupa 52 bits.

En la Figura 2.3 se muestra la distribucion de bits de cada campo para el formato de

precision doble.

Figura 2.3: Ordenamiento de bits en el formato de precision doble. Notese que el ancho

de palabra del exponente es 11 bits y el de la mantisa 52, para este formato de precision.

Fuente: [9].

La normalizacion del exponente para este formato se lleva a cabo con un valor de sesgo

de 1023.

10 2.2 Algoritmo CORDIC para el calculo de operaciones trigonometricas.

2.2 Algoritmo CORDIC para el calculo de operacio-

nes trigonometricas.

El algoritmo de Computacion Digital para Rotacion de Coordenadas, CORDIC por sus

siglas en ingles (COordinate Rotation Digital Computer), fue desarrollado especialmente

para usarse en computadoras digitales en tiempo real, donde la mayorıa de la computacion

involucraba la resolucion de las relaciones trigonometricas de las ecuaciones de navegacion

y una alta tasa de exactitud para las relaciones trigonometricas de las transformaciones

de coordenadas [15].

Este algoritmo fue originalmente propuesto por Jack Volder en el ano 1959, con el

proposito de calcular funciones trigonometricas mediante la rotacion de vectores. La ro-

tacion de vectores es usada tambien para realizar la conversion de sistemas coordenados

(polar a cartesiano y viceversa), y como parte de funciones matematicas mas complejas

como lo son la Transformada Rapida de Fourier (FFT), y la transformada Coseno Discreta

(DCT).

El CORDIC es un algoritmo iterativo para rotar vectores a ciertos angulos determi-

nados, que efectua operaciones matematicas a alta velocidad en sistemas coordenados

lineales, circulares e hiperbolicos y que solo utiliza operaciones de suma y desplazamiento

para efectuar operaciones trigonometricas, exponenciales, logarıtmicas, y otras funciones

trascendentales [17].

2.2.1 Fundamento Teorico.

El algoritmo originalmente propuesto [15], describe la rotacion de un vector bidimensional

en el plano cartesiano, como el mostrado en la Figura 2.4. El funcionamiento del algoritmo

se deduce de la formula general de rotacion de vectores [2].

x′ = xcosθ − ysenθy′ = ycosθ + xsenθ

(2.2)

Figura 2.4: Vector bidimensional antes y despues de ser rotado θ grados. Fuente: [13]

2 Marco teorico 11

Sacando a factor comun el cosθ en la ecuacion (2.2), asumiendo que cosθ 6= 0, se obtiene

[2]

x′ = cosθ(x− ytanθ)y′ = cosθ(y + xtanθ)

(2.3)

Y tomando en cuenta que

cosθ =1√

1 + tan2θ(2.4)

entonces la ecuacion (2.3) se puede expresar como

x′ =x− ytanθ√1 + tan2θ

y′ =y + xtanθ√1 + tan2θ

(2.5)

En el algoritmo CORDIC, las rotaciones son sustituidas por pseudo-rotaciones vectoria-

les, tal y como se muestra en la Figura 2.5.

Figura 2.5: Pseudo-rotacion de un vector bidimensional. Notese como el vector pseudo-

rotado aumenta su magnitud por un factor de V√

1 + tan2θ, donde V es el valor original

de la magnitud. Fuente: [13]

En una rotacion real no se cambia la magnitud del vector V una vez realizada la rotacion,

pero en una pseudo-rotacion esto no aplica, ya que incrementa su magnitud en

V ′′ = V√

1 + tan2θ (2.6)

La rotacion de un angulo se puede descomponer en una sumatoria de rotaciones mas

pequenas. Asumiendo inicialmente que x = x0, y = y0 y z = z0, despues de realizadas n

iteraciones para una rotacion real, se obtiene

12 2.2 Algoritmo CORDIC para el calculo de operaciones trigonometricas.

x′n = xcosθ(n−1∑i=0

θi)− ysinθ(n−1∑i=0

θi) (2.7)

y′n = ycosθ(n−1∑i=0

θi) + xsinθ(n−1∑i=0

θi) (2.8)

z′n = z − (n−1∑i=0

θi) (2.9)

En cambio para una pseudo-rotacion se tiene que

x′′n = (xcosθ(n−1∑i=0

θi)− ysinθ(n−1∑i=0

θi))n−1∏i=0

√1 + tan2θi (2.10)

y′′n = (ycosθ(n−1∑i=0

θi) + xsinθ(n−1∑i=0

θi))n−1∏i=0

√1 + tan2θi (2.11)

z′′n = z − (n−1∑i=0

θi) (2.12)

en donden−1∑i=0

θi = θ

Las ecuaciones (2.9) y (2.12) son conocidas como el parametro acumulador angular, ya

que incluye las rotaciones realizadas hasta el momento.

Si se restringen los angulos de rotacion de tal manera que tanθ = ±2−i, i ∈ N , la operacion

multiplicacion, que es tan costosa para un sistema computacional en terminos de area y

tiempo, se ve reducida a una operacion de desplazamiento. Ademas, los diversos angulos se

pueden obtener al realizar una sucesion de rotaciones elementales cada vez mas pequenas,

y en cada iteracion, en vez de de determinar si se debe rotar o no, lo que hace es escoger

el sentido de rotacion.

Tomando como punto de partida las ecuaciones (2.3), sustituyendo tanθ = ±2−i, y ademas

teniendo en cuenta que cos(θ) = cos(−θ), las iteraciones se pueden expresar como

xi+1 = Ki(xi − yidi2−i)yi+1 = Ki(yi + xidi2

−i)(2.13)

en donde Ki =1√

1 + 2−2iy di = ±1 dependiendo del sentido de rotacion[2].

2 Marco teorico 13

Esta valor Ki, debe ser multiplicado por las ecuaciones correspondientes a las pseudo-

rotaciones, para obtener la rotacion real, ya que como se menciono anteriormente, las

pseudo-rotaciones aumentan el tamano del vector, por lo que el valor Ki contrarresta este

efecto.

Eliminando el valor Ki de las ecuaciones iterativas, se obtiene un algoritmo basado en

sumas y desplazamientos, y el factor Ki puede aplicarse al final o al principio del proceso

como una constante Kn, definida como

Kn = limn→∞

n∏i=0

Ki∼= 0.607253 (2.14)

El valor exacto de la constante Kn es determinado por la cantidad de iteraciones realiza-

das.

En cada paso de iteracion, el algoritmo, en vez de decidir si se rota o no, lo que decide

es el signo o sentido de rotacion que se efectuara. Por esto mismo, cada angulo final se

puede representar mediante un vector de signos, en donde cada componente corresponde

a un angulo de la secuencia de angulos elementales. Estos angulos se almacenan en una

Look-Up Table(LUT). Dependiendo del sistema angular, se almacenan en la tabla las

arcotangentes correspondientes a ese sistema. Con esta ultimo punto, se puede modificar

el acumulador angular, obteniendo

zi+1 = zi − diarctan(2−i) (2.15)

El algoritmo CORDIC puede operar en dos modos, rotacion(rotation) o vectoriza-

cion(vectoring). En primero rota el vector de entrada un angulo especıfico que se introduce

como parametro. El segundo modo rota el vector de entrada hacia el eje X, acumulando

el angulo necesario para efectuar dicha rotacion.

En el caso del modo de rotacion, el acumulador angular es inicializado con el angulo a

rotar, y la decision sobre el sentido de rotacion en cada iteracion, se realiza para minimizar

la magnitud del angulo acumulado, hasta llegar a cero, con lo que el signo que determina

el sentido de rotacion, se obtiene del valor del acumulador angular en cada iteracion [17].

Para el modo de rotacion, las ecuaciones iterativas son

xi+1 = xi − yidi2−iyi+1 = yi + xidi2

−i

zi+1 = zi − diarctan(2−i)

(2.16)

en donde, di =

{−1, zi < 0

+1, zi > 0

Para el modo de vectorizacion, el angulo que ingresa se rota hasta quedar alineado con el

eje X. Este resultado se logra minimizando la magnitud del componente y, en vez de la

14 2.3 Arquitecturas de implementacion del algoritmo CORDIC.

magnitud del acumulador angular. A diferencia del modo de rotacion, se utiliza el signo

de la variable y para definir la direccion de rotacion de la siguiente iteracion. Si se inicia

el acumulador angular con el valor cero, al finalizar el proceso esta variable contendra el

angulo de rotacion adecuado.

Para el modo de vectorizacion, las ecuaciones iterativas son

xi+1 = xi − yidi2−iyi+1 = yi + xidi2

−i

zi+1 = zi − diarctan(2−i)

(2.17)

en donde, di =

{−1, yi > 0

+1, yi < 0

Cabe destacar que el algoritmo CORDIC esta restringido al rango de angulos−π2

6

θ 6π

2, esto debido a que los angulos elementales convergen solo dentro de este rango, y

para tratar angulos por fuera de ese rango, estos se deben de reducir al primer o cuarto

cuadrante.

2.3 Arquitecturas de implementacion del algoritmo

CORDIC.

2.3.1 Arquitectura bit-paralela iterativa.

La arquitectura bit-paralela es una de las mas utilizadas a la hora de implementar el

algoritmo CORDIC en hardware. Se denomina paralela por la forma en que se opera con

las componentes X, Y y Z. Cada etapa de esta implementacion consiste en un registro para

almacenar los valores de salida, una unidad del desplazamiento y un sumador algebraico.

Cuando se inicia el calculo, los valores iniciales para x0, y0 y z0 ingresan de manera paralela

a los registros a traves de los multiplexores de dos entradas. El bit mas significativo de la

variable Z o Y, dependiendo del modo, en cada paso iterativo determina la operacion a

efectuar por los sumadores. Seguidamente, las senales de las variables X y Y se desplazan,

y luego se suman o restan a las mismas senales sin desplazar, correspondiente a la variable

opuesta, como se muestra en la ecuacion (2.16).

La variable Z suma o resta los valores almacenados en el registro con los valores al-

macenados en una LUT, de arcotangentes precalculadas con una cantidad de entradas

proporcional a la cantidad de iteraciones. Dicha LUT puede almacenarse en una memo-

ria ROM. Cuando se alcanza la iteracion n, el valor a calcular se puede obtener en las

salidas Xn, Yn o Zn, dependiendo de la operacion que se esta calculando.

Esta arquitectura tiene como ventaja el uso eficiente de hardware, debido a que los recursos

2 Marco teorico 15

se reutilizan en cada iteracion. En la Figura 2.6 se muestra el diagrama correspondiente

a la arquitectura antes descrita. A esta arquitectura ademas, se le debe implementar una

maquina de control que maneje el flujo de los datos, ademas de controlar las iteraciones

realizadas y el canal de los multiplexores a activar.

Figura 2.6: Arquitectura bit-paralela iterativa para la implementacion en hardware del

algoritmo CORDIC, donde se puede observar que esta arquitectura se utilizan muy

pocos componentes, debido al proceso iterativo que realiza el algoritmo, lo que permite

la reutilizacion de recursos. Fuente: [13]

2.3.2 Arquitectura bit-paralela desplegada.

Esta arquitectura, en vez de almacenar el resultado de cada iteracion en registros y volver a

utilizar los mismos recursos, tal como lo hacıa la arquitectura anterior, despliega su diseno

de manera que se separa en etapas correspondientes a cada iteracion. Cada una de las

etapas esta compuesta por los mismos componentes, las dos unidades de desplazamiento y

tres sumadores algebraicos, por lo que las salidas de una etapa corresponden a la entrada

de la siguiente, y el diseno se vuelve completamente combinacional.

El desarrollar el algoritmo CORDIC por medio de esta arquitectura provee dos ventajas:

• Las unidades de desplazamiento y las constantes correspondientes a cada iteracion

pueden cablearse.


• Al ser el diseno completamente combinacional, no se requiere de una maquina de

control, lo que simplifica bastante el diseno.

Este metodo, empero, presenta una gran desventaja, debido a la gran cantidad de recursos

de hardware que consume, ya que en este diseno se requiere replicar cada etapa n veces,

igual a la cantidad de iteraciones que tomarıa en la arquitectura bit-paralela iterativa,

para conseguir un resultado similar.

En la Figura 2.7 se observa el esquema de la arquitectura bit-paralela desplegada, donde

se observa que cada componente presente en la arquitectura bit-paralela iterativa, a ex-

cepcion de los registros y de la LUT, que se reemplaza por constantes en cada sumador

algebraico utilizado en el acumulador, se debe repetir n veces.

Figura 2.7: Arquitectura bit-paralela desplegada para la implementacion en hardware del

algoritmo CORDIC. Notese que los componentes en cada etapa se deben de replicar

en la siguiente, por lo que no se reutiliza ninguno, aumentado el consumo de recursos.

Fuente: [13]

2 Marco teorico 17

2.3.3 Arquitectura bit-serie iterativa.

En esta arquitectura, se procesa un bit a la vez, con lo que las conexiones se reducen a

un bit de ancho. En este diseno, cada etapa del algoritmo esta conformada por tres mul-

tiplexores, dos registros de desplazamiento y tres sumadores algebraicos bit-serie. Estos

sumadores se implementan como un sumador completo, en el que la resta se lleva a cabo

sumando el complemento a dos del valor a restar.

El desempeno de esta arquitectura puede calcularse como

δ =f

n ·W(2.18)

donde f es la frecuencia de reloj del sistema, n la cantidad de iteraciones a realizar y W

el ancho de palabra. En la Figura 2.8 se observa el esquema de esta arquitectura.

Figura 2.8: Arquitectura bit-serie iterativa para la implementacion en hardware del algo-

ritmo CORDIC. Notese que se tiene la ventaja de que los anchos de canal son de 1 bit,

pero el tiempo de ejecucion de una operacion es proporcional al ancho de palabra de los

operandos. Fuente: [13]

La ventaja que presenta esta arquitectura es que los buses de interconexion son del ancho

de un bit y que el registro de desplazamiento esta integrado al registro intermedio que se

utilizaba en la arquitectura bit-paralela iterativa, lo que minimiza el espacio a la hora de

la implementacion, en comparacion con dicha arquitectura.


Esta arquitectura presenta no obstante dos grandes desventajas. Primero: introduce un

retardo proporcional al ancho de palabra en cada etapa, ocasionado por los registros de

desplazamiento; segundo: la arquitectura requerirıa una maquina de control mas compleja

que la que se necesita en la arquitectura bit-paralela iterativa.

Capıtulo 3

Diseno y verificacion en hardware del

modulo de calculo trigonometrico.

En este capıtulo se presenta el diseno, implementacion y verificacion de las operaciones

trigonometricas seno y coseno en la FPU objetivo. En primera instancia se trataran

las implementaciones realizadas tanto en hoja de calculo como en el software Octave,

mostrando los resultados obtenidos. Seguidamente se explicara la solucion implementada

en hardware, mostrando por ultimo tambien, los resultados obtenidos en la solucion,

variando la cantidad de iteraciones que realiza el algoritmo para obtener un resultado, y

presentando los porcentajes de error del calculo del seno y el coseno en las arquitecturas

de 32 y 64 bits.

3.1 Generalidades.

Para el calculo del seno y coseno de un angulo por medio del algoritmo CORDIC, se

debe tener en cuenta que el valor a calcular debe cumplir las siguientes restricciones:

• El valor del angulo de entrada que se desea calcular debe ser en radianes.

• El rango de angulos que puede calcular el algoritmo CORDIC esta limitado, con

el fin de obtener porcentajes de error menores a 1%, dependiendo de la operacion a

calcular:

- Para el coseno el rango es de −89, 9 6 θ 6 89, 9.

- Para el seno el rango es de 0, 35 6 θ 6 90 ∪ −90 6 θ 6 −0, 35

• El rango de calculo se puede extender a valores que se encuentre en el segundo

y tercer cuadrante del sistema de coordenadas cartesianas; teniendo en cuenta los

rangos para cada operacion, con el fin de obtener un porcentaje menor al 1%, estas

coordenadas seran:

19

20 3.2 Implementacion del modelo de referencia de alto nivel CORDIC.

- Para el coseno el rango es de 90, 35 < θ 6 180 ∪ −180 6 θ < −90, 35.

- Para el seno el rango es de 90 < θ 6 179, 9 ∪ −179, 9 6 ∪ < −0, 35

3.2 Implementacion del modelo de referencia de alto

nivel CORDIC.

En primera instancia, para poder entender de mejor manera el funcionamiento del algo-

ritmo CORDIC, se procedio a implementar el mismo en Octave, ası como tambien en la

herramienta de hoja de calculos LibreOffice Calc.

3.2.1 Implementacion del Algoritmo CORDIC en hoja de calculo.

La implementacion en hoja de calculo permitio obtener valores confiables de los resultados

del algoritmo CORDIC, de manera rapida y que sirviera de punto de partida para su

posterior implementacion en Octave.

Acorde con la ecuacion (2.16), el algoritmo requiere el precalculo de la arcotangente de

2−i, donde i = 0, 1, 2...n, siendo n la maxima iteracion que realizara el algoritmo. Estos

valores se deberan cargar en una memoria ROM en el momento de su implementacion en

hardware.

En la Tabla A.1, presente en el Anexo A, se muestran los resultados obtenidos para un

angulo en especıfico. En la tabla se muestra el angulo a calcular, la constante Kn, que

corrige el cambio de magnitud producidas por la pseudo rotaciones, el valor teorico del

seno y el coseno del angulo a calcular, y se muestran los diferentes valores obtenidos como

resultado del algoritmo, a diferentes cantidades de iteraciones, mostrando el porcentaje

de error a nivel de software de este metodo. Cabe resaltar que en primera instancia,

el valor de Kn se multiplicaba al valor final obtenido, pero teniendo en cuenta que en

hardware eso siginificarıa realizar multiplicacion en coma flotante, se realizaron pruebas

que permitieron determinar que pre escalando la variable x0 al valor de la constante Kn,

no es necesario realizar al final una multiplicacion en coma flotante.

En la Tabla A.2, se observan los valores precalculados antes mencionados, obtenidos de

la hoja de calculo, hasta 64 iteraciones.

Los resultados obtenidos por medio de esta implementacion, y que se observan en la Tabla

A.1, permite observar que conforme se aumenta la cantidad de iteraciones, el porcentaje

de error de la operacion realizada por el algoritmo disminuye, punto importante a tomar

en cuenta al momento de disenar e implementar el algoritmo en hardware.


3.2.2 Implementacion del algoritmo CORDIC en Octave.

Para implementar el algoritmo CORDIC en un lenguaje de alto nivel, se escogio el

software para calculos matematicos Octave, el cual ofrece ventajas tales como: es facil

de usar, posee una considerable cantidad de foros sobre implementaciones del algoritmo

CORDIC, y ofrece manejo de scripts para la graficacion de los resultados obtenidos. El

codigo desarrollado se puede observar en el Apendice C.

Para realizar el calculo, la funcion cordic Hardware recibe dos valores, n y z0, donde

n son la cantidad de iteraciones que se desean realizar y z0 el angulo al que se le desea

calcular el seno y el coseno. Ello debido a que el algoritmo CORDIC procesa el resultado

de estas dos operaciones en paralelo.

Seguidamente, se comprueba el valor del angulo ingresado y se cambia para que tome

valores en el rango de [−π, π]. Despues de esta primera correccion del angulo de entrada,

se vuelve a comprobar el valor del angulo, verificando que se encuentre entre [−π2,π

2], si

no es ası se suma o se resta al valor del angulo la constanteπ

2, logrando ası finalmente

tener un valor que se encuentre en el rango de calculo del algoritmo CORDIC.

En este paso tambien se activan dos banderas: shift flag y Region flag, las cuales

indican que se ha trasladado el valor de entrada del segundo y tercer cuadrante del plano

cartesiano, al primer y cuarto cuadrante, y a cual cuadrante fue trasladado el angulo

de entrada, respectivamente. La bandera shift flag toma el valor de -1 cuando se ha

realizado un traslado de cuadrante, y la bandera Region flag, toma el valor de -1 cuando

el valor es trasladado del tercer al cuarto cuadrante, y 1 cuando se traslada del segundo

al primer cuadrante. En caso de que el angulo ya se encuentre en el rango deseado, estas

banderas toman el valor de 1 y 0, respectivamente.

A continuacion, se realiza el calculo de los valores que se introducen en la LUT, los cuales

corresponden a arctan(2−i), mediante un ciclo for, el cual calcula dicho valor desde 0

hasta n − 1, siendo n el valor maximo de iteraciones que realiza el algoritmo. Estos

valores son guardados en un archivo de texto en formato hexadecimal para su posterior

uso en la implementacion en hardware.

Una vez realizados los pasos anteriormente descritos, se procede a calcular el seno y el

coseno del angulo de entrada. Para eso se define los valores iniciales de las variables

X 0, Y 0 y Z 0, los cuales son Kn, 0 y α, respectivamente, donde Kn es la constante

de correccion de magnitud del resultado, que se calcula con la ecuacion (2.14) y como se

menciono anteriormente, X 0 toma este valor inicial con el fin de ahorrarse el paso de

multiplicar el resultado final por esta constante. Por ultimo, α es el angulo de entrada

resultante de los pasos de corrimiento de cuadrante.

Una vez que el ciclo for alcanza el valor maximo de iteraciones, n-1, se realiza un ultimo

paso, el cual consiste en evaluar el valor de las banderas shift flag y Region flag. Este

paso se hace con el fin de obtener el valor correcto en la salida del script.

22 3.2 Implementacion del modelo de referencia de alto nivel CORDIC.

Como se muestra en la Tabla 3.1, si el angulo α de entrada se encuentra fuera del rango

de calculo del algoritmo CORDIC, los valores del calculo del coseno y seno ya no se

obtienen de los valores finales de las variables X y Y, respectivamente, si no que se

intercambian, ademas de que se les aplica un cambio de signo, dependiendo de a cual

cuadrante pertenece el angulo de entrada.

Tabla 3.1: Cambios que se presentan en los valores de salida del algoritmo CORDIC,

dependiendo del cuadrante del cual haya sido desplazado el angulo de entrada.

Angulo de

entrada α

Angulo

desplazado

β

sin(α) cos(α)

π

2< α < π α− π

2cos(β) = X −sin(β) = −Y

−π < α < −π2

α +π

2−cos(β) = −X sin(β) = Y

Debido a la implementacion en Octave, es que se logra idear una forma para que el

algoritmo CORDIC ya no este limitado a angulos que pertenezcan al primer y cuarto

cuadrante, si no que su rango de calculo se pueda extender a cualquier valor del plano

cartesiano, situacion que no se habıa planteado en la implementacion en hoja de calculo.

En la Tabla 3.2 se observan los resultados de la implementacion en el software Octave,

donde se muestra el valor teorico del angulo a calcular, ası como los resultados obtenidos

del algoritmo a diferentes cantidades de iteraciones, y el porcentaje de error obtenido.

Tabla 3.2: Resultados obtenidos de la implementacion en Octave del algoritmo COR-

DIC, trabajando con diferentes cantidades de iteraciones, para un angulo de

entrada de 126.467◦, donde se puede observar que el error disminuye conforme

se aumentan las iteraciones que realiza el algoritmo.

Cantidad de

iteraciones

Valor Teorico Valor ExperimentalPorcentaje de

error (%)

coseno seno coseno seno coseno seno

8

-0,594359 0,804199

-0,594359 0,804199 7,103625e-06 3,880175e-06

16 -0,594359 0,804199 4,119123e-07 2,250344e-07

32 -0,594359 0,804199 1,988470e-08 1,086155e-08

64 -0,594359 0,804199 9,339655e-14 6,902660e-14


3.3 Hardware propuesto para el algoritmo CORDIC.

Se diseno el modulo CORDIC para que realizara las operaciones de calculo del coseno

y el seno de un angulo en coma flotante acorde con el estandar IEEE 754. En la Figura

3.1 se muestra el diagrama de entradas y salidas del modulo.

Figura 3.1: Diagrama de entradas y salidas para el modulo de calculo de seno y coseno,

basado en el algoritmo CORDIC. Esta version del modulo de calculo trigonometrico

contiene el modulo de suma/resta en coma flotante.

Las senales de entrada del modulo son:

• clk: reloj interno del sistema, con una frecuencia de 100 MHz, (segun la hoja de

datos de la placa de desarrollo Digilent Nexys 4).

• rst: senal de reinicio de la maquina de estados finitos, o maquina de control, encar-

gada de controlar el flujo de datos.

• beg fsm cordic: senal de inicio, que le indica a la maquina de control que se inicia

el proceso para un nuevo calculo de una de las operaciones.

• ack cordic: senal proveniente de un sistema externo, y que le indica a la maquina

de control que ha recibido el resultado de la operacion de manera correcta.

• operation: senal de entrada que indica cual operacion se desea realizar. Esta

codificacion viene dada por la siguiente secuencia de bits:

• 0: operacion coseno.

• 1: operacion seno.

• data in: senal de entrada, con un ancho de W bits, que contiene el valor del dato

al que se desea realizar un calculo, donde W puede tomar dos valores, 32 y 64,

dependiendo de la precision que se desea.

• shift region flag: senal de entrada utilizada en conjunto con las operaciones seno y

coseno, que indica si el valor a calcular se encuentra en el segundo o tercer cuadrante.

Esta codificacion viene dada por la siguiente secuencia de bits:

24 3.3 Hardware propuesto para el algoritmo CORDIC.

• 00: El dato de entrada es un valor que se encuentra en el primer o cuarto

cuadrante.

• 01: El dato de entrada es un valor que se encuentra en el segundo cuadrante.

• 10: El dato de entrada es un valor que se encuentra en el tercer cuadrante.


cuadrante.

3.3.1 Descripcion del funcionamiento del modulo CORDIC.

En la Figura 3.2 se muestra el diagrama de bloques completo del modulo CORDIC, en

el cual se muestran todas las etapas que conforman la solucion. Se escogio una variacion

de la arquitectura bit-paralela iterativa que se explico en el marco teorico, especialmente

por su bajo consumo de recursos y la velocidad con la que se obtiene un resultado, los

cuales son menores que las otras dos soluciones consideradas.

La arquitectura implementada puede usarse para la resolucion de las operaciones seno,

coseno, ası como para las funciones hiperbolicas, exponenciales, logaritmos, entre otras,

las cuales se pueden implementar utilizando como base esta misma solucion, y realizando

algunos cambios en cuanto a hardware y a la maquina de control.

Al ser el algoritmo CORDIC un algoritmo iterativo, se debe tener en cuenta que entre

mas iteraciones se realicen, el porcentaje de error disminuye, pero esto conlleva a un

mayor tiempo en la ejecucion de la operacion para obtener un resultado. Tomando en

cuenta esta consideraciones, a continuacion se explica detalladamente el funcionamiento

del hardware implementado para la ejecucion del algoritmo.

Al iniciar el proceso, se reciben 3 datos, los cuales corresponden a las senales operation,

shift region flag y data in, con tamanos de palabra de 1, 2 y W bits, donde W puede

tomar los valores de 32 o 64, dependiendo de la precision que se desee. Los valores de estas

senales son guardados en los registros de entrada, que muestrean el dato cuando la senal

de habilitacion enab RB1 presenta un valor en alto. Las senales x0 y y0 que se observan

en la Figura 3.2 corresponden a valores iniciales del algoritmo que son constantes, cuyos

valores son:

• x0 = 0,607252935008881 = Kn.

• y0 = 0.

Despues de que los valores iniciales son guardados en los registros, en la siguiente etapa, la

maquina de control decide cual de los dos canales de los tres multiplexores debe habilitarse.

Para esto se verifica el valor de la senal min tick iter, proveniente del contador de

iteraciones.

Si esta senal tiene un valor de 1 logico, implica que se esta realizando la primer iteracion

del proceso, por lo que el canal 0 de los multiplexores sera habilitado, permitiendo ası que


Figura 3.2: Diagrama completo de la variacion de la arquitectura CORDIC bit-paralela

iterativa, en la cual, debido al uso de un sumador/restador en coma flotante, se utiliza solo

uno para evitar un excesivo consumo de recursos. Las senales de color rojo corresponden

al bus de reloj, las de color amarillo a las senales de habilitacion de los registros y los

contadores, las de color verde a las senales de reset de los registros de la arquitectura y

las de color negro a los buses de datos.


los valores iniciales de las senales x0, y0 y z0, la cual corresponde a la senal de entrada

data in, pasen a la siguiente etapa, que consiste en un conjunto de registros pipeline,

que guardan el dato proveniente de las salidas de los multiplexores. En caso de que la

iteracion actual no sea la primera, la senal min tick iter tendra un valor de 0 logico, con

lo que se activara el canal 1 de los multiplexores, y permitira el paso de los valores de las

variables Xn, Yn y Zn, calculados en la iteracion anterior.

Una vez que los valores de salida de la primera lınea de multiplexores han sido guardados

en la segunda lınea de registros pipeline, la siguiente etapa en el calculo se encarga de 3

tareas:

i. Realizar la operacion de desplazamiento sobre los valores de las variables X y Y.

ii. Direccionar un dato en la salida de la ROM, dependiendo del valor de la iteracion

actual.

iii. Seleccionar entre el signo de la variable Y o Z, dependiendo del modo de operacion

del algoritmo.

En la Figura 3.3, se observa con mayor detalle las senales presentes en esta etapa y el

ancho de palabra de cada una.

Figura 3.3: Etapa de la Arquitectura CORDIC, que realiza la operacion de despla-

zamiento de las variables X y Y, direcciona los valores de la ROM, y decide de cual

variable se toma el signo, dependiendo del modo de operacion del algoritmo. Notese que

la operacion de desplazamiento es realizada por dos restadores de coma fija.

En las ecuaciones (2.16) del algoritmo CORDIC, se observa que las variables xi y yi, las

cuales corresponden a los valores obtenidos de las variables X y Y de la iteracion anterior,

son multiplicadas por el valor 2−i, que a nivel de hardware corresponde a la operacion de

desplazamiento a la derecha , >> i, donde i es el valor de la iteracion actual que se esta

realizando.

Pero debido a que se estan utilizando valores en coma flotante, la operacion de despla-

zamiento no consiste en insertar ceros a la derecha o izquierda del arreglo de bits. En

cambio, si se desean hacer desplazamientos a la derecha, se realiza una resta, en la que al

valor del exponente del arreglo de bits, se le resta el valor correspondiente a la cantidad de


desplazamientos a realizar, y si se desean hacer desplazamientos a la izquierda, se realiza

una suma.

Por consiguiente, ya que en el algoritmo CORDIC se necesitan realizar desplazamientos

a la derecha, se implementan dos restadores de coma fija, que tienen como entradas las

senales X[W − 2 : M ], Y [W − 2 : M ] y cont iter[3 : 0], tal como se muestra en la Figura

3.3, donde W representa el ancho de palabra, y M representa la cantidad de bits que

ocupa la mantisa. Por consiguiente, si se toma como ejemplo que el ancho de palabra

de la arquitectura es W=32 bits, esto tendrıa como consecuencia que el valor de M sea

23, por lo que el ancho de palabra de las senales X[W − 2 : M ] y Y [W − 2 : M ] es de

8 bits, y el rango que representa en el arreglo de bits es de [30:23], que son los bits que

corresponden al campo de exponente en el arreglo.

En la salida de los restadores se obtiene como resultado un nuevo valor de exponente, con

un ancho de palabra de [E − 1 : 0], donde E representa la cantidad de bits que ocupa el

campo de exponente.

La siguiente tarea que se realiza en esta etapa consiste en direccionar un valor precargado

en el modulo LUT, que contiene los valores precalculados de la operacion arctan(2−i),

donde como ya se ha explicado anteriormente, i representa la iteracion actual. Estos

valores se utilizan para el calculo de la variable zi+1, presente en las ecuaciones (2.16).

Por ultimo, en esta etapa se direcciona el bit de signo de las variables Y o Z, dependiendo

del modo de operacion del algoritmo CORDIC. Como se observa en la Figura 3.3, esto

se realiza mediante un multiplexor de 2 canales, que tiene como entradas el bit de signo

de la variable Z en el canal 0 y el bit de signo de la variable y en el canal 1.

Debido a que para el calculo de las operaciones seno y coseno el algoritmo realiza los

calculo en el modo de rotacion, y ya que estas son las dos operaciones implementadas en

este proyecto, en la entrada de seleccion del multiplexor se coloca el valor constante de 0,

que habilita el canal 0, direccionando a la salida el bit de signo de la variable Z.

Despues de completarse estas tres tareas realizadas en paralelo, los resultados son alma-

cenados en un tercer conjunto de registros pipeline. Entre estos registros, cabe destacar

los que guardan las variables X y Y, ya que a la entrada de estos registros, al bit de signo

y los bit de mantisa de estas variables se les concatena el nuevo valor de exponente, por

lo que estos registros se utilizan para formar el patron de bits correcto para las variables

desplazadas en formato de coma flotante.

En la siguiente etapa(ver Figura 3.4), se procede a resolver cada una de las variables de las

ecuaciones (2.16). Primero, la maquina de control define cual canal de los multiplexores

se debe habilitar, teniendo en cuenta a cual iteracion pertenece el calculo, si la operacion

es un seno o un coseno y a que region del plano cartesiano pertenece el angulo a resolver.


Figura 3.4: Etapa de la Arquitectura CORDIC, que realiza la suma o resta en coma

flotante, dependiendo de cual variable se este calculando y la iteracion actual. Notese

el uso de un solo sumador/restador para el calculo de las variables, a diferencia de la

arquitectura original, debido a que se usa el modulo de suma/resta en coma flotante.

Para entrar en mas detalle, en caso de que se este realizando la ultima iteracion, ya no

se necesita realizar el calculo de las tres variables, si no solo de una, ya sea de Xn o

Yn, permitiendo con esto disminuir el tiempo que toma obtener un resultado final. Si

la operacion a calcular es un coseno y el angulo se encuentra en el 1er o 4to cuadrante

del plano cartesiano, se activa el canal 0 de ambos multiplexores, con lo que permite el

calculo de la variable Xn.

En caso de que la operacion a calcular es un seno, y al igual que en el caso anterior, sea

la ultima iteracion y el angulo se encuentra en el 1er o 4to cuadrante del plano cartesiano,

se activa el canal 1 de ambos multiplexores, con lo que permite el calculo de la variable

Yn.

Ahora bien, si el angulo mas bien pertenece al 2do o 3er cuadrante, y al igual que los

casos anteriores, se esta realizando la ultima iteracion, se intercambian los canales que se

activan, esto quiere decir que en caso de que la operacion sea un coseno, se activa el canal

1 y se calcula la variable Yn, y si la operacion es un seno, se activa el canal 0 y se calcula

la variable Xn.

Esto ultimo permite al algoritmo CORDIC, el cual esta limitado a realizar el calculo de

senos y cosenos en el rango de [−90, 90], poder ampliar el rango de calculo a [−180, 180].

En caso de que no se este realizando la ultima iteracion, es necesario realizar el calculo

de las tres variables, por lo que entra en juego el contador de variables, el cual cuenta de

0 a 2, y la maquina de control se encarga de que el valor de salida del contador sea el que


determine cual canal de los multiplexores se activa.

Por ultimo, en esta etapa se encuentra el modulo operation select, el cual decide si

la operacion a realizar es una suma o una resta. A partir de la Tabla 3.3, la cual es la

tabla de verdad con la que se diseno el modulo, se observa que dicha tabla describe el

funcionamiento de una compuerta XNOR, cuyas entradas son el bit menos significativo

de la senal de seleccion de los multiplexores de esta etapa, y el bit de signo de la variable

Y o Z, dependiendo del modo de operacion en que se trabaje, en este caso de la variable

Z.

Tabla 3.3: Tabla de verdad que permite definir si se realiza una suma o resta en el modulo

de suma/resta en coma flotante, dando como resultado la implementacion de

una compuerta logica XNOR para esta operacion.

sel mux 3 [0] sign operation

0 0 1

0 1 0

1 0 0

1 1 1

Una vez que el modulo de suma/resta en coma flotante brinda una solucion, estos valores

son guardados en 3 registros, los cuales almacenan el valor de Xn, Yn o Zn dependiendo

de cual variable se estaba calculando.

La ultima etapa implementada en la arquitectura corresponde a la observada en la Figura

3.5, la cual se encarga de direccionar a la salida el valor de la variable Xn o Yn, e invierte

el valor del bit de signo del resultado final, dependiendo de la operacion y del cuadrante

al que pertenezca el angulo que se esta calculando.

La senal de seleccion del multiplexor toma el valor de 0 logico, permitiendo pasar a la

salida el valor de la variable Xn, en los siguientes casos:

• La operacion a calcular es un coseno y el angulo a calcular pertenece al 1er o 4to

cuadrante.

• La operacion a calcular es un seno y el angulo a calcular pertenece al 2do o 3er

cuadrante.

En caso contrario, la de seleccion del multiplexor toma el valor de 1 logico, permitiendo

pasar a la salida el valor de la variable Yn, en los siguientes casos:

• La operacion a calcular es un seno y el angulo a calcular pertenece al 1er o 4to

cuadrante.

• La operacion a calcular es un coseno y el angulo a calcular pertenece al 2do o 3er

cuadrante.


Figura 3.5: Etapa de la Arquitectura CORDIC, que direcciona a la salida el valor de la

variable Xn o Yn, e invierte el valor del bit de signo, dependiendo de la operacion y del

cuadrante al que pertenezca el angulo a calcular.

Por ultimo, el modulo sign inv, es el encargado de invertir el signo del resultado final

en caso de que el angulo a calcular se encuentre en el 2do o 3er cuadrante del plano

cartesiano. Presenta las senales de entrada data, shift region flag y operation, las

cuales corresponde al resultado de la operacion que se desea calcular, la senal que indica

a que cuadrante del plano cartesiano pertenece el angulo a calcular y la senal que indica

cual operacion se realizo, respectivamente.

La Tabla 3.4, es la tabla de verdad utilizada para disenar el modulo sign inv, de esta

manera se permite implementar este modulo en muy pocas lıneas en el lenguaje Verilog.

3.3.2 Maquina de estados del modulo CORDIC.

En este apartado se enumeran los pasos que realiza la maquina de control para obtener un

resultado al final del proceso. La Figura B.1, presente en el Anexo B, muestra el diagrama

de estados disenado a partir del diagrama de flujo, con el cual se implemento la maquina

de control.

Pasos:

1. Activa la senal de reset, la cual reinicia todos los modulos involucrados en la solucion

del algoritmo.


Tabla 3.4: Tabla de verdad, utilizada para el diseno del modulo sign inv, encargado

de cambiar el valor del bit de signo del resultado final, cuando el angulo de

entrada a calcular pertenece al 2do o al 3er cuadrante.

operation sign shift region flag[1] shift region flag[0] new sign

0 0 0 0 0

0 0 0 1 1

0 0 1 0 0

0 0 1 1 0

0 1 0 0 1

0 1 0 1 0

0 1 1 0 1

0 1 1 1 1

1 0 0 0 0

1 0 0 1 0

1 0 1 0 1

1 0 1 1 0

1 1 0 0 1

1 1 0 1 1

1 1 1 0 0

1 1 1 1 1

2. Espera a que la senal de inicio de operacion tome un valor de 1 logico para continuar.

3. Carga los valores de entrada en la primera lınea registros, ademas de reiniciar el

contador ascendente de iteraciones con un valor de 0.

4. Verifica si la iteracion que se esta realizando es la primera, y selecciona el canal 0

de la primera lınea de multiplexores de ser ası, en caso contrario selecciona el canal

1.

5. Verifica el valor de la senal de excepcion. De ser un valor en alto, se reinicia el

proceso hasta el paso 1, en caso contrario continua normalmente la ejecucion de

la operacion, ademas de que activa la senal de habilitacion de la segunda lınea de

registros, que permita cargar los valores presentes en las entradas de los mismos.

6. Carga los valores provenientes de los modulos de resta en punto fijo y de la ROM en

la tercera lınea de registros. Ademas reinicia el contador ascendente de variables,

que permite el control de cual de las 3 variables del algoritmo se esta calculando.

7. Verifica el valor de 3 senales: la que indica la operacion que se esta realizando, la que

indica si la iteracion actual es la ultima y la que indica la region del plano cartesiano

a la que pertenece el angulo de entrada. Dependiendo de las combinaciones de

valores de estas senales, se seleccionara una de las 3 entradas de los multiplexores

que direccionan los operandos a los cuales se les aplicara la operacion de suma o

resta en coma flotante.


8. Activa la senal que da inicio al modulo de suma y resta en coma flotante para que

realice una operacion.

9. Verifica los valores de 4 senales: la senal que indica que el modulo de suma y resta

en coma flotante ha finalizado su operacion, la senal que indica si se esta realizando

la ultima iteracion, la senal que indica la operacion que se esta calculando (seno o

coseno) y la senal que indica la region del plano cartesiano a la que pertenece el

angulo de entrada. Dependiendo de la combinacion de estas senales, se decide cual

registro guarda el valor obtenido de la operacion de suma o resta en coma flotante.

Hasta que no se presente la senal de finalizacion del modulo aritmetico, el proceso

se mantiene en este paso.

10. Se activa la senal de acknowledge que le permite al modulo de suma y resta reiniciar

sus registros y esperar a una nueva operacion. Tambien se verifica si se encuentra

en la ultima iteracion. De ser ası se continua con el siguiente paso, pero en caso

contrario se verifica si ya se calculo la ultima variable del algoritmo. Si ya se

calcularon todas las variables el proceso regresa al paso 4, con lo que se inicia

una nueva iteracion, por lo que se activa la senal que permita aumentar la cuenta

de iteraciones. En caso contrario se vuelve al paso 7, para realizar el calculo de

la proxima variable y se aumenta el contador que permite llevar el control de la

variable actual que se esta calculando.

11. En este paso se corrobora de nuevo la operacion que se esta realizando y de que

region del plano pertenece el angulo de entrada, con el fin de seleccionar si el valor

de la variable X o Y es la que se debe utilizar para brindar el resultado final.

12. Se activa la senal que habilita al registro para guardar los datos presentes en su

entrada.

13. Se activa la senal que habilita al registro para guardar los datos presentes en su

entrada, provenientes del modulo de inversion de signo del resultado. Este valor es

el resultado de la operacion seleccionada.

14. Se activa la senal que indica que el modulo CORDIC ha terminado su operacion y

que tiene un resultado final. Ademas espera la senal de acknowledge proveniente

de un modulo externo. Cuando esta senal tenga un valor en alto el proceso vuelva

a iniciar y se regresa al paso 1.

En las Figuras 3.6 y 3.7, se muestra el diagrama de flujo utilizado para el diseno de la

maquina de estados que controla los datos en el modulo CORDIC.


Figura 3.6: Primera parte del diagrama de flujo de la maquina de estados disenado para

el control de los datos en el modulo CORDIC. Esta parte permite realizar el calculo

de las variables X, Y y Z, hasta la iteracion n-1, y aumentar el valor del contador de

variables e iteraciones, para comenzar el proceso de calculo de variables para la siguiente

iteracion.


Figura 3.7: Segunda parte del diagrama de flujo de la maquina de estados disenado para el

control de los datos en el modulo CORDIC. Se puede observar como esta parte permite

obtener un resultado final, dependiendo de la operacion que se este realizando y de a que

cuadrante pertenece el angulo de entrada.


3.4 Diseno e implementacion del hardware de prue-

bas.

Al momento de realizar la verificacion funcional de los modulos disenados, para la so-

lucion de las operaciones trigonometricas seno y coseno, se implementa un ambiente de

verificacion como el que se muestra en la Figura 3.8.

Figura 3.8: Ambiente de verificacion desarrollado, para la comprobacion del correcto

funcionamiento de los modulos implementados y la recoleccion de los resultados obtenidos

en hardware, para despues ser comparados con los datos teoricos. Fuente: [4]

En la Figura 3.8, se observa como los modulos disenados se implementan en la placa de

desarrollo de pruebas, y despues son recolectados para ser comparados con los resulta-

dos teoricos, para comprobar su funcionalidad. En dado caso de que no se obtenga los

resultados deseados, se realizan cambios y se vuelve a aplicar el mismo proceso.

Para la verificacion de la funcionalidad del algoritmo CORDIC a nivel de hardware, se

diseno un conjunto de modulos, los cuales se muestran en la Figura 3.9, que realizan la

misma funcion que el testbench implementado para la verificacion en simulacion, pero

en este caso se utilizan para corroborar el correcto funcionamiento del modulo de calculo

CORDIC una vez que es implementado en la placa de desarrollo Digilent Nexys 4.

36 3.4 Diseno e implementacion del hardware de pruebas.

Figura 3.9: Modulos para la verificacion funcional del algoritmo CORDIC una vez im-

plementado en la placa de desarrollo Digilent Nexys 4. El multiplexor implementado en

la entrada del modulo de transmision UART cambia la cantidad de canales de entrada,

dependiendo de la arquitectura sintetizada.

El modulo contador de direcciones se utiliza para direccionar los valores cargados en las

ROM, y es un contador de 11 bits que realiza una cuenta desde 0 hasta 2047. Este posee

una senal llamada max tick, que presenta un valor de 1 logico cuando el contador ha

alcanzado la maxima cuenta. Esta senal es enviada a la maquina de control. Las senales

de entrada load y enab, enviadas por la maquina de control, permiten cargar un valor

de cuenta inicial en el modulo cuando ambas se encuentran en alto, en este caso se carga

con un cero en la entrada d, y habilita la cuenta cuando la senal enab se encuentra en

alto.

El contador de canal permite controlar cual canal del multiplexor es seleccionado. Fun-

ciona de la misma manera que el contador de direcciones, sin embargo este modulo cuenta

hasta 4 o hasta 8, dependiendo de la arquitectura especificada en la sıntesis.

Las ROM de vectores de prueba contiene 2048 valores generados en Octave, en el rango de

0 a 2π, mientras la ROM de cuadrante contiene 4 valores: 00, 01, 10 y 11, y representan

a cada uno de los cuadrantes del plano cartesiano. Cada 512 valores de la ROM de

vectores de prueba corresponden a valores de angulo pertenecientes a cada cuadrante,

desplazandose en la direccion opuesta a las manecillas del reloj.


El modulo CORDIC no se explicara de nuevo, solo se hara hincapie en la senal opera-

tion. Esta senal podra cambiar su valor cada vez que se realiza la sıntesis, y tomara el

valor 0 o 1 dependiendo de si se desea calcular un coseno o un seno, respectivamente.

El modulo UART permite la comunicacion con una computadora por medio del protocolo

de comunicacion serial RS-232. Ya que solo interesa la transmision de datos desde la

Nexys 4 hacia la computadora, es que no se utilizan las senales de recepcion disponibles

en el modulo.

El multiplexor implementado permite seccionar el resultado del modulo CORDIC en pa-

quetes de 8 bits, el cual es el tamano de paquete para la transmision de datos utilizando

el protocolo RS-232. La seleccion del canal se realiza mediante la cuenta realizada por el

contador de canal. Si la operacion implementada es en la arquitectura de 32 bits, el mul-

tiplexor que se sintetiza poseera 4 entradas, mientras que si se implementa la arquitectura

de 64 bits, el multiplexor que se sintetiza tendra 8 entradas. Esto se logra mediante el

comando generate de Verilog.

Por ultimo, se diseno una maquina de estados finitos que permitiera manejar el flujo de

datos y controla el inicio de un calculo en el modulo CORDIC, ası como la transmision de

datos hacia la computadora. En la Figura 3.10 se muestra el diagrama de flujos disenado

para implementar la maquina de control.

Los pasos a seguir para realizar el calculo de un valor y transmitirlo hacia una computadora

se enumeran a continuacion:

1. Se activa la senal de reset, y se inicia el proceso de calculo y transmision.

2. Se carga el valor de 0 en el contador de direcciones, con el fin de asegurarse de que

se inicie la cuenta en esta valor y direccionar el primer valor presente en las ROM.

3. Se activa la senal que inicia la operacion de calculo en el modulo CORDIC, ya con

el primer valor de las ROM direccionado.

4. Se carga el valor de 0 en el contador de canal, con el fin de asegurarse de que se

inicie la cuenta en esta valor y se seleccione el canal 0 en el multiplexor de 4 u 8

canales, dependiendo de la arquitectura sintetizada.

5. Seguidamente, la maquina de control espera la senal de finalizacion de operacion

por parte del modulo CORDIC. Hasta ese momento no se realiza ninguna otra

operacion.

6. A continuacion se inicia la transmision de los paquetes de datos hacia la compu-

tadora.

7. Una vez terminada la transmision de un paquete, se corrobora si el paquete ante-

riormente transmitido fue el ultimo. De ser ası se pasa al siguiente paso, en caso

contrario, se aumenta la cuenta en el contador de canales y se regresa al paso anterior

para transmitir el siguiente paquete.

38 3.4 Diseno e implementacion del hardware de pruebas.

8. A continuacion se corrobora la direccion en la ROM del paquete recien transmitido,

en caso de ser el ultimo dato, se termina el proceso de calculo y transmision de

datos. En caso contrario se activa la senal de reseteo de los registros del modulo

CORDIC, que permite que el modulo este listo para realizar un nuevo calculo, se

aumenta la cuenta en el contador de direcciones y se regresa al paso 3 de nuevo.

Figura 3.10: Diagrama de flujo disenado para la implementacion de la maquina de control

del proceso de verificacion a nivel de hardware, en el cual se realizan pruebas con 2048

datos, cuyos resultados son enviados a una computadora para la posterior comparacion

con los resultados teoricos.

En la Figura B.2, presente en el Anexo B, se presenta el diagrama de estados disenado

para la implementacion de la maquina de control, que permite realizar automaticamente

2048 operaciones de calculo y transmision en la placa de prototipos Digilent Nexys 4.


3.5 Resultados experimentales.

En esta seccion se presentan y discuten los resultados obtenidos en el desarrollo de los

modulos de calculo trigonometrico. Se divide en cinco partes, las cuales describen el

ambiente de verificacion a nivel de software y hardware, los resultados obtenidos de las

simulaciones y de las pruebas en hardware, el informe de recursos utilizados, el informe

de potencia y el reporte de tiempos.

3.5.1 Metodologıa de verificacion.

Para la verificacion del funcionamiento de los modulos trigonometricos, se genero un

vector pruebas de 2048 datos, los cuales se obtuvieron a partir de un script implementado

en Octave, en el cual se especifica la cantidad de valores que se desean. Dentro del

script se define el rango de los valores para el vector, el cual se determina de [0, 2π]. La

rutina genera primero una matriz con los 2048 diferentes valores tomados dentro del rango

especificado.

La generacion de los resultados teoricos se realiza en la misma rutina de Octave que crea

los vectores de prueba, realizando el calculo del seno y el coseno, y guardando en archivos

de texto, tanto los vectores de prueba, como los resultados teoricos obtenidos en cada una

de las operaciones, para los formatos de precision de 32 y 64 bits.

Los resultados experimentales se obtienen de dos formas:

• Mediante simulacion utilizando la herramienta Vivado Simulator proporcionada por

Xilinx.

• Mediante la implementacion en hardware de las operaciones trigonometricas y cap-

turando los resultados en una computadora.

Para la obtencion de los valores experimentales mediante simulacion en la herramienta

Vivado Simulator, se desarrollo una rutina que cumplıa las siguientes funciones:

• Realizar el proceso de lectura del vector de datos de prueba.

• Generar las senales de estımulo que inicializan y finalizan la ejecucion del algoritmo

CORDIC.

• Almacenar en un archivo de texto los resultados obtenidos de la ejecucion de la

operacion seno y coseno, en los formatos de precision de 32 y 64 bits.

Para asegurar el correcto funcionamiento de los modulos de calculo trigonometrico, se

realizaron las cinco diferentes simulaciones que se pueden realizar en el software Vi-

vado: 1) Behavioral, 2) Post-Synthesis Functional, 3) Post-Synthesis Timing, 4) Post-

Implementation Functional y 5) Post-Implementation Timing Simulation, cada una de

estas para las operaciones seno y coseno, en los dos formatos de precision implementados.

40 3.5 Resultados experimentales.

En el caso de los resultados experimentales obtenidos de la implementacion de las opera-

ciones en hardware, especıficamente en la placa de desarrollo Digilent Nexys 4, se utilizo

el hardware de pruebas explicado en la seccion anterior, que permitio realizar las mismas

funciones que realiza un testbench de simulacion.

Por ultimo, se desarrollo una rutina en Octave, encargada de graficar los resultados obte-

nidos de las simulaciones y de la implementacion en hardware, ademas del porcentaje de

error, el cual se calcula con la siguiente ecuacion:

%error =|Teorico− Experimental|

Teorico(3.1)

Las graficas generadas son utilizadas como punto de referencia, para realizar la verificacion

de la funcionalidad de los modulos, definir un rango valores que puede procesar el modulo,

definir un rango de precision y analizar la aceptabilidad de los resultados obtenidos.

Tal como se definieron los indicadores para los objetivos de este proyecto, se desea un

porcentaje de error acotado al 1% entre datos de la implementacion y datos teoricos

(tomandose como teoricos los del modelo de referencia en Octave).

Los scripts mas importantes implementados en Octave pueden ser consultados en el Anexo

C del documento.

3.5.2 Resultados de pruebas en simulacion y en implementacion

de hardware en la FPGA.

Como se ha mencionado anteriormente, el algoritmo CORDIC implementado en hard-

ware para la resolucion de las operaciones trigonometricas seno y coseno, es un metodo

iterativo, por lo que conforme aumenten la cantidad de veces que se realice el proceso de

calculo, el resultado obtenido es mas confiable.

Bajo esta premisa es que se procede a realizar simulaciones con el Vivado Simulator,

variando la cantidad de iteraciones que realiza el algoritmo, para comparar y escoger la

cantidad idonea de iteraciones que permita obtener un porcentaje de error menor al 1%,

pero que tambien realice el calculo de la operacion en un tiempo razonable.

Debido a que las graficas generadas con los resultados de las operaciones seno y coseno

en 64 bits son identicas a las obtenidas en la arquitectura de 32 bits, solo se presentaran

estas ultimas, y se brindaran dos tablas que resumen los resultados mas importantes de

ambas arquitecturas, para cada operacion al variar la cantidad de iteraciones realizadas.

Las Figuras 3.11 y 3.12 muestran los resultados obtenidos en la operacion coseno y seno,

respectivamente, realizadas con 8 y 16 iteraciones. En la primera grafica de cada figura

se observa la forma de onda obtenida con los valores teoricos de las operaciones, en

contraposicion con los valores experimentales que se obtuvieron en simulacion . Para

obtener estos resultados se utilizo un vector de pruebas de 2048 datos, que toma valores

desde 0 hasta 2π.


0 100 200 300-1

-0.5

0

0.5

1

Grado

coseno(r

adia

nes)

0 100 200 300-1

-0.5

0

0.5

1

Grado

coseno(r

adia

nes)

0 100 200 300-1

-0.5

0

0.5

1

Grado

coseno(r

adia

nes)

Resultados teoricos obtenidos de Octave en la operacion coseno.

Resultados obtenidos en simulacion de la operacion coseno con 8 iteraciones.

Resultados obtenidos en simulacion de la operacion coseno con 16 iteraciones.

Figura 3.11: Graficas de los resultados de aplicar la operacion coseno a un barrido de

valores desde 0 hasta 2π, obteniendo resultados teoricos y experimentales con 8 y 16

iteraciones, en las cuales se observa que con 8 iteraciones, los resultados difieren con

respecto a los valores teoricos, no ası en el caso con 16 iteraciones.

0 100 200 300-1

-0.5

0

0.5

1

Grado

seno(r

adia

nes)

0 100 200 300-1

-0.5

0

0.5

1

Grado

seno(r

adia

nes)

0 100 200 300-1

-0.5

0

0.5

1

Grado

seno(r

adia

nes)

Resultados teoricos obtenidos de Octave en la operacion seno.

Resultados obtenidos en simulacion de la operacion seno con 8 iteraciones.

Resultados obtenidos en simulacion de la operacion seno con 16 iteraciones.

Figura 3.12: Graficas de los resultados de aplicar la operacion seno a un barrido de valores

desde 0 hasta 2π, obteniendo resultados teoricos y experimentales con 8 y 16 iteraciones,

en las cuales se observa que con 8 iteraciones, los resultados difieren con respecto a los

valores teoricos, no ası en el caso con 16 iteraciones.


0 100 200 3000

100

200

300

400

Grado

Porc

enta

je d

e e

rror

0 100 200 3000

0.2

0.4

0.6

0.8

1

Grado

Porc

enta

je d

e e

rror

Porcentaje de error obtenido en simulacion de la operacion coseno con 8 iteraciones.

Porcentaje de error obtenido en simulacion de la operacion coseno con 16 iteraciones.

Figura 3.13: Grafica del porcentaje de error obtenido al aplicar a la operacion coseno

un barrido de valores desde 0 hasta 2π, utilizando 8 y 16 iteraciones para el calculo.

Notese como el aumento en la cantidad de iteraciones utilizadas en el calculo reduce los

porcentajes de error desde un 400% hasta menos de un 1%.

0 100 200 3000

100

200

300

400

Grado

Porc

enta

je d

e e

rror

0 100 200 3000

0.2

0.4

0.6

0.8

1

Grado

Porc

enta

je d

e e

rror

Porcentaje de error obtenido en simulacion de la operacion seno con 8 iteraciones.

Porcentaje de error obtenido en simulacion de la operacion seno con 16 iteraciones.

Figura 3.14: Grafica del porcentaje de error obtenido al aplicar a la operacion seno

un barrido de valores desde 0 hasta 2π, utilizando 8 y 16 iteraciones para el calculo.

Notese como el aumento en la cantidad de iteraciones utilizadas en el calculo reduce los

porcentajes de error desde un 400% hasta menos de un 1%


En las Figuras 3.11 y 3.12 se puede observar como al aumentar la cantidad de itera-

ciones utilizadas en el algoritmo CORDIC, las formas de ondas del seno y el coseno

experimentales se asemejan mas a la onda teorica.

Con los valores teoricos y experimentales obtenidos en cada operacion para distintas

cantidades de iteraciones, se calcula el porcentaje de error de cada resultado, obteniendo

ası las graficas que se observan en las Figuras 3.13 y 3.14.

Como se puede observar, el porcentaje de error presente en las operacion coseno y seno

realizada con 8 iteraciones conducen a valores erroneos que se desvıan hasta casi un 400%

del valor teorico, resultado que se podıa observar en las Figuras 3.11 y 3.12, en donde la

onda generada con los valores experimentales difiere a la teorica, en los mismos valores

de grado que en los que el porcentaje de error es notorio.

Las operaciones realizadas con 16 iteraciones, presentan porcentajes de error mucho me-

nores a los obtenidos con 8 iteraciones, resultado esperado debido a que el algoritmo

CORDIC aumenta su confiabilidad conforme se aumente el numero de iteraciones utili-

zadas para realizar una operacion.

En las Tablas 3.5 y 3.6 se despliegan los valores maximos y mınimos, ası como el valor

promedio de porcentaje de error obtenidos para las operaciones seno y coseno, en las

arquitecturas de 32 y 64 bits, para 8 y 16 iteraciones.

Tabla 3.5: Valores maximos, mınimos y promedio de porcentaje de error de las opera-



disminuye al aumentar la cantidad de iteraciones utilizadas.

Arquitectura 32 bits

Operacion Seno Coseno

Cantidad

de iteraciones8 16 8 16

Porcentaje

de error

mınimo

8.8222e-05 % 1.4394e-07 % 1.1617e-04 % 3.7291e-06 %

Porcentaje

de error

maximo

379.5268 % 0.9136 % 380.6219 % 0.8150 %

Porcentaje

de error

promedio

4.2933 % 1.7021e-02 % 3.9919 % 1.5582e-02 %

A partir de los resultados observados en las Tablas 3.5 y 3.6 se puede observar que el

algoritmo CORDIC, para las arquitecturas de 32 y 64 bits, presenta un porcentaje de

error menor al 1% con 16 iteraciones, lo que permite determinar este valor como el que

se va a utilizar a la hora de la implementacion en hardware.

Realizadas las simulaciones que verifican el correcto funcionamiento de los modulos im-

plementados, se procede a descargar el diseno en la placa de prototipos Digilent Nexys 4,





disminuye al aumentar la cantidad de iteraciones utilizadas.

Arquitectura 64 bits

Operacion Seno Coseno

Cantidad

de iteraciones8 16 8 16

Porcentaje

de error

mınimo

1.7423e-01 % 1.0987e-07 % 8.3731e-02 % 3.1001e-08 %

Porcentaje

de error

maximo

2.9662e+04 % 0.9136 % 2.9720e+04 % 0.8149 %

Porcentaje

de error

promedio

230.0492 % 1.7017e-02 % 241.4329 % 1.5189e-02 %

la cual opera a una frecuencia nominal de 100 MHz.

Para verificar el funcionamiento de las operaciones a nivel de hardware, se hace uso del

circuito disenado y explicado en secciones anteriores, para bombardear con 2048 diferentes

datos al modulo CORDIC, y se procede a graficar los valores experimentales obtenidos

para observar la onda que se genera y los porcentajes de error, esto para la arquitectura

de 32 bits, y en 2 tablas se resumen los datos mas importantes obtenidos en cuanto a

porcentaje de error se refiere para ambas arquitecturas.

En las Figuras 3.15 y 3.16 se muestra la forma de onda generada con los resultados obteni-

dos a partir de las pruebas en hardware de las operaciones coseno y seno, respectivamente,

para la arquitectura de 32 bits, y realizando 16 iteraciones. En dichas figuras se puede

observar la onda generada con los resultados teoricos y la onda generada con los resultados

experimentales.

En las Figuras 3.15 y 3.16 se puede observar que las ondas teoricas y experimentales para

ambas operaciones son practicamente iguales, lo que conlleva a suponer que el porcentaje

de error es muy pequeno. Para comprobar esta suposicion se procede a calcular el por-

centaje de error de los resultados, y en las Figuras 3.17 y 3.18 se muestran las graficas

resultantes.

De las graficas desplegadas en las Figuras 3.15 y 3.16 se observa que el porcentaje de error

de ambas operaciones no es superior al 1%, lo cual es el resultado esperado, debido a las

pruebas realizadas en simulacion. En la Tabla 3.7 se resumen los resultados obtenidos

para ambas arquitecturas, en las cuales se detallan los valores maximos y mınimos de

porcentaje de error, ademas del porcentaje de error promedio, para ambas operaciones.

Los porcentajes de error presentes en la operaciones seno y coseno, son debido a 2 factores:


0 100 200 300-1

-0.5

0

0.5

1

Grado

Valo

r de c

oseno(r

adia

nes)

0 100 200 300-1

-0.5

0

0.5

1

Grado

Valo

r de c

oseno(r

adia

nes)

Onda coseno generada con los resultados teoricos.

Onda coseno generada con los resultados experimentales, para la arquitectura de 32 bits.

Figura 3.15: Grafica de resultados obtenidos en la operacion coseno para la arquitectura

de 32 bits. Se despliegan los resultados teoricos y experimentales en hardware, respecti-

vamente.

0 100 200 300-1

-0.5

0

0.5

1

Grado

Valo

r de s

eno(r

adia

nes)

0 100 200 300-1

-0.5

0

0.5

1

Grado

Valo

r de s

eno(r

adia

nes)

Onda seno generada con los resultados teoricos.

Onda seno generada con los resultados experimentales, para la arquitectura de 32 bits.

Figura 3.16: Grafica de resultados obtenidos en la operacion seno para la arquitectura de

32 bits. Se despliegan los resultados teoricos y experimentales en hardware, respectiva-

mente.


0 100 200 3000

0.2

0.4

0.6

0.8

1

Grado

Porc

enta

je d

e e

rror

Grafica del porcentaje de error obtenido en la implementacion en hardware de la operacion coseno en la arquitectura de 32 bits.

Figura 3.17: Grafica del porcentaje de error de la operacion coseno en 32 bits, donde se

observa que los porcentajes no sobrepasan el 1%. Es importante anotar que el error au-

menta conforme el algoritmo se aproxima a los lımites de su rango o dominio de operacion,

por lo que son esperables.

0 100 200 3000

0.2

0.4

0.6

0.8

1

Grado

Porc

enta

je d

e e

rror

Grafica del porcentaje de error obtenido en la implementacion en hardware de la operacion seno en la arquitectura de 32 bits.

Figura 3.18: Grafica del porcentaje de error de la operacion seno en 32 bits, donde se ob-

serva que los porcentajes no sobrepasan el 1%. Es importante anotar que el error aumenta

conforme el algoritmo se aproxima a los lımites de su rango o dominio de operacion, por

lo que son esperables.



ciones seno y coseno para las arquitecturas de 32 y 64 bits, para la imple-

mentacion final con 16 iteraciones.

Arquitectura 32 64

Operacion Coseno Seno Coseno Seno

Porcentaje

de error

mınimo

3.72910e-06% 1.43940e-07% 3.10011e-08% 1.09875e-07%

Porcentaje

de error

maximo

0.81501% 0.91367% 0.81499% 0.91364%

Porcentaje

de error

promedio

1.55827e-02% 1.71208e-02% 1.55827e-02% 1.70217e-02%

1. La cantidad de iteraciones que realiza el algoritmo.

2. El error asociado a las operaciones de suma y resta en coma flotante.

Como se ha mencionado anteriormente, la precision de los resultados obtenidos mediante

el calculo del algoritmo CORDIC esta directamente relacionado con la cantidad de ite-

raciones que se realicen. Como se observo en las resultados obtenidos en las pruebas en

las que se vario la cantidad de iteraciones, el porcentaje de error se redujo drasticamente

a la hora de doblar la cantidad de iteraciones. Resultados con mejores porcentajes de

error se obtendran al aumentar las iteraciones, pero esto conlleva que el tiempo que le

toma al modulo para realizar un calculo aumente. Aunado a este error esta el error que

se va acumulando cada vez que se realiza una iteracion debido al modulo que realiza el

calculo de las operaciones suma y resta en coma flotante.

3.5.3 Recursos de hardware utilizados.

Los datos presentes en las Tablas 3.8 y 3.9 son un resumen del uso de recursos por parte

de las arquitecturas de 32 y 64 bits, respectivamente. Esta informacion fue extraıda de

un informe Post-Implementation generado por la herramienta Vivado.

En las Tablas 3.8 y 3.9 se puede observar que debido a la gran cantidad de recursos que

dispone la placa de desarrollo Digilent Nexys 4 y al hecho de implementar una arquitectura

iterativa para el algoritmo CORDIC que permite reutilizar el mismo hardware en cada

iteracion, la cantidad de recursos utilizados para las implementaciones en 32 y 64 bits es

mınima, dando cabida a desarrollar muchas mas operaciones matematicas haciendo uso

de este algoritmo, sin llegar a impactar de manera significativa el area a utilizar.


Tabla 3.8: Recursos consumidos por el modulo de calculo CORDIC, para 32 bits, don-

de se observa que se utilizan muy pocos recursos debido a la arquitectura

iterativa implementada para la solucion de las operaciones.

Resource Utilization Available Utilization %

LUT 584 63400 0.92

FF 731 126800 0.58

BUFG 1 32 3.13

Tabla 3.9: Recursos consumidos por el modulo de calculo CORDIC, para 64 bits, don-

de se observa que se utilizan muy pocos recursos debido a la arquitectura

iterativa implementada para la solucion de las operaciones.


LUT 1169 63400 1.84

FF 1426 126800 1.12

BUFG 1 32 3.13

3.5.4 Consumo de potencia.

La Tabla 3.10 presenta los datos de consumo de potencia dinamica y estatica de las dos ar-

quitecturas del modulo CORDIC, obtenidos a partir de un reporte Post-Implementation

generado por la herramienta Vivado. En las Figuras 3.19a y 3.19b se presentan los graficos

generados en el reporte, que detallan de mejor manera el consumo de potencia del modulo

CORDIC para ambas arquitecturas.

A partir de estas tablas y figuras, se puede observar que el consumo de potencia estatico

en ambas arquitecturas es relativamente constante. Esto es debido a que el consumo de

potencia estatica es propio de la FPGA e independiente del diseno que se desarrolle en la

placa. Caso contrario, el consumo de potencia dinamica, de la cual se puede observar un

mejor desglose en las Figuras 3.19a y 3.19b, aumenta en la implementacion de 64 bits con

(a) Arquitectura de 32 bits. (b) Arquitectura de 64 bits.

Figura 3.19: Graficos del consumo de potencia del modulo CORDIC en las arquitecturas

de 32 y 64 bits, donde se puede observar en detalle el porcentaje de consumo que tienen

los diferentes componentes del diseno. Fuente: Vivado Post-Implementation Report.


Tabla 3.10: Consumo de potencia del modulo CORDIC para el calculo de las opera-

ciones seno y coseno en las arquitecturas de 32 y 64 bits.

Arquitectura de 32 bits Arquitectura de 64 bits

Consumo de

potencia

estatica (mW)

Consumo de

potencia

dinamica (mW)

Consumo de

potencia

Total (mW)

Consumo de

potencia

estatica (mW)

Consumo de

potencia

dinamica (mW)

Consumo de

potencia

Total (mW)

104 6 110 104 11 115

respecto a la de 32 bits, donde se puede observar que se cuadriplica el consumo debido a

logica, y se duplica en el parametro de senales, para la arquitectura de 64bits respecto a

la de 32 bits.

3.5.5 Reporte de tiempos.

En las Tablas 3.11 y 3.12 se presenta el reporte de tiempos que se obtiene despues de

realizar el proceso de implementar la logica para la FPGA. En esta se muestran los

resultados para las arquitecturas de 32 y 64 bits, a una frecuencia de reloj de 100 MHz.

Tabla 3.11: Reporte de tiempos referente al Setup Slack, para las arquitecturas de 32



operacion del modulo.

Arquitectura 32 bits 64 bits

Worst Negative Slack (ns) 1.627 0.649

Data Path Delay (ns) 6.256 7.323

Required Time (ns) 12.965 12.965

Arrival time (ns) 11.338 12.257

Tabla 3.12: Reporte de tiempos referente al Hold Slack, para las arquitecturas de 32



operacion del modulo.

Arquitectura 32 bits 64 bits

Worst Hold Slack (ns) 0.104 0.106

Data Path Delay (ns) 0.238 0.240

Required Time (ns) 1.532 1.562

Arrival time (ns) 1.636 1.668


El slack es el margen por el que se cumplio o no el requisito de tiempo predefinido.

Un valor de slack positivo indica que se han cumplido con los requerimientos de tiempo

definidos, caso contrario si se obtiene un valor de slack negativo. Para el calculo de este

parametro, Vivado utiliza la siguiente ecuacion:

Setup \Hold Slack = ±(required time− arrival time) (3.2)

El tiempo que una senal necesita para llegar a el final de la ruta y asegurarse de que

se cumple el timing es llamado el required time. El tiempo en que la senal en realidad

llega al punto de llegada es llamado el arrival time. De las Tablas 3.11 y 3.12 se puede

observar que el diseno realizado cumple con los tiempos definidos para que los modulos

implementados trabajen correctamente, y da cabida al posible aumento de la frecuencia

a la que trabaja la placa de prototipos Digilent Nexys 4, y con esto mejorar el tiempo

total que le toma al modulo para realizar un calculo.

El modulo de calculo trigonometrico realiza el calculo de una operacion en un total de 834

ciclos de reloj, para la implementacion realizada con 16 iteraciones. El uso de 8 iteraciones

realiza el calculo en un total de 403 ciclos de reloj, pero los valores de porcentaje de error

no eran aceptables, por lo que se decidio sacrificar el tiempo de ejecucion de una operacion,

con tal de obtener resultados con porcentajes de error menores al 1%.

Capıtulo 4

Modulo para el manejo de la

excepcion NaN en las operaciones

implementadas en la FPU.

En este capıtulo se presenta el diseno e implementacion de los modulos que permitiran

detectar cuando los valores de entrada de la FPU puedan generar el resultado Not a

Number, para las 5 operaciones implementadas hasta la actualidad : suma, resta, multi-

plicacion, seno y coseno. En primera instancia se explicara la solucion implementada para

detectar y manejar esta excepcion, para despues mostrar los resultados en simulaciones

donde se pueda comprobar el correcto funcionamiento de los modulos implementados.

4.1 Interfaz general de la FPU.

Para lograr la deteccion y el manejo de la excepcion NaN para todas las operaciones

implementadas hasta el momento en la FPU, se procedio a implementar una interfaz que

permitiera escoger cual de las 5 operaciones se desea realizar, y con estos implementar un

modulo general, para cada arquitectura, que permita evaluar los valores de entrada que se

utilizaran para el calculo, y determinar si estos valores pueden generar que la operacion

de como resultado NaN.

En la Figura 4.1 se muestra el diagrama de entradas y salidas de la interfaz de la FPU.

Las senales de entrada del modulo son:

• clk: reloj interno del sistema, con una frecuencia de 100 MHz, (segun la hoja de

datos de la placa de desarrollo Digilent Nexys 4).

• rst: senal de reinicio de la maquina de estados finitos, o maquina de control, encar-

gada de controlar el flujo de datos.

51

52 4.1 Interfaz general de la FPU.

Figura 4.1: Interfaz General de la FPU, que integra las operaciones suma, resta, seno,

coseno y multiplicacion, ademas de permitir realizar la identificacion y el manejo de la

combinacion de operandos de entrada que generen la excepcion NaN.

• begin operation: senal de inicio, que le indica a la maquina de control que se

inicia el proceso para un nuevo calculo de una de las operaciones.

• ack operation: senal proveniente de un sistema externo, y que le indica a la

maquina de control que ha recibido el resultado de la operacion de manera correcta.

• operation: senal de entrada que indica cual operacion se desea realizar. Esta

codificacion viene dada por la siguiente secuencia de bits:

• 000: operacion suma.

• 001: operacion resta.

• 010: operacion coseno.

• 011: operacion seno.

• 100: operacion multiplicacion.

• 101 a 111 : bits sin uso que se puede utilizar en el futuro cuando se amplıe la

cantidad de operaciones en la FPU.

• region flag: senal de entrada utilizada en conjunto con las operaciones seno y

coseno, que indica si el valor a calcular se encuentra en el segundo o tercer cuadrante.

Esta codificacion viene dada por la siguiente secuencia de bits:


cuadrante.

• 01: El dato de entrada es un valor que se encuentra en el segundo cuadrante.

• 10: El dato de entrada es un valor que se encuentra en el tercer cuadrante.

4 Modulo para el manejo de la excepcion NaN en las operaciones implementadas en la FPU.53


cuadrante.

• Data 1 y Data 2: senales de entrada, con un ancho de W bits, que contienen

los operandos que se utilizaran para realizar un calculo, donde W puede tomar dos

valores, 32 y 64, dependiendo de la precision que se desea.

• r mode: senal que le indica a la FPU que tipo de redondeo se va a utilizar en los

calculos.

4.1.1 Descripcion del funcionamiento de la interfaz de la FPU.

En la Figura 4.2 se muestra el diagrama de bloques completo que compone a la interfaz

general de la FPU, en el cual se observa la integracion de los modulos de calculo de

las operaciones suma,resta, seno,coseno y multiplicacion, en conjunto con el detector

de resultado NaN y otros modulos integrados, que permiten el direccionamiento de los

valores de entrada al modulo de calculo correcto, dependiendo de la operacion escogida

para realizar un calculo.

Los modulos de demultiplexado observados se utilizan con el fin de permitir que una senal

de entrada se reparta para varios modulos, pero que solo un modulo a la vez utilice esta

senal. El demultiplexor para la senal begin operation utiliza como senal para la selec-

cion del canal de salida a los dos bits mas significativos de la senal operation, permitiendo

ası que cuando se seleccione las operaciones suma/resta, seno/coseno o multiplicacion, se

active el canal 0, 1 o 2, respectivamente, permitiendo que comience el calculo en el modulo

que corresponde a la operacion escogida. El demultiplexor para la senal ack operation

funciona de la misma manera.

El modulo deco operation toma los dos bits menos significativos de la senal operation,

y la decodifica para obtener dos senales de 1 bit cada una, las cuales se utilizan para

indicarle al modulo de suma/resta y al modulo CORDIC(coseno/seno) cual operacion

debe realizar.

Los multiplexores utilizados en varias de las senales de entrada del modulo de suma y resta

en coma flotante, se utilizan debido a que este modulo es utilizado tambien por el modulo

CORDIC, para realizar el calculo de las operaciones coseno y seno. Por esto se utiliza

como senal de seleccion de dichos multiplexores el segundo bit de la senal operation, ya

que este bit tomara un valor de 0 cuando la operacion seleccionada sea una suma o resta,

y tomara un valor de 1 cuando la senal seleccionada se un coseno o un seno, permitiendo

ası seleccionar el canal 0, el cual direcciona las senales provenientes del exterior de interfaz

de la FPU al modulo de suma y resta, o el canal 1, que direcciona las senales de control

provenientes del modulo CORDIC, respectivamente.

De igual manera, los multiplexores presentes antes de las salidas de la interfaz de la FPU,

se utilizan para direccionar valores a partir de los diferentes modulos, dependiendo de cual


Figura 4.2: Interfaz general de la FPU detallada, que integra las operaciones suma, resta,

seno, coseno y multiplicacion, ademas del modulo que permite detectar y manejar la

combinacion de operandos que generan la excepcion NaN.


operacion se le solicito a la FPU realizar, y utilizan la senal operation para determinar

cual canal se selecciona para conectarlo con la salida de la Interfaz de la FPU.

Recursos de hardware utilizados.

Los datos presentes en las Tablas 4.1 y 4.2 son un resumen del uso de recursos por parte

de las arquitecturas de 32 y 64 bits, respectivamente. Esta informacion fue extraıda de

un informe Post-Implementation generado por la herramienta Vivado.

Tabla 4.1: Recursos consumidos por el modulo de interfaz general de la FPU, para 32



mas operaciones.


LUT 952 63400 1.50

FF 1077 126800 0.85

DSP 2 240 0.83

BUFG 1 32 3.13

Tabla 4.2: Recursos consumidos por el modulo de interfaz general de la FPU, para 64



mas operaciones.


LUT 1874 63400 2.96

FF 2203 126800 1.74

DSP 9 240 3.75

BUFG 1 32 3.13

En las Tablas 4.1 y 4.2 se puede observar que debido a la gran cantidad de recursos

que dispone la placa de desarrollo Digilent Nexys 4 y al proceso de optimizacion que se

realizo a la hora de desarrollar cada operacion, la cantidad de recursos utilizados para

las implementaciones en 32 y 64 bits es mınima, dando cabida a desarrollar muchas

mas operaciones matematicas que permitan obtener una FPU mas completa, sin llegar a

impactar de manera significativa el area a utilizar.


Consumo de potencia.

La Tabla 4.3 presenta los datos de consumo de potencia dinamica y estatica de las dos

arquitecturas de la interfaz general de la FPU, obtenidos a partir de un reporte Post-

Implementation generado por la herramienta Vivado. En las Figuras 4.3a y 4.3b se pre-

sentan los graficos generados en el reporte, que detallan de mejor manera el consumo de

potencia del modulo, para ambas arquitecturas.

(a) Arquitectura de 32 bits. (b) Arquitectura de 64 bits.

Figura 4.3: Graficos del consumo de potencia del modulo de interfaz general de la FPU en

las arquitecturas de 32 y 64 bits, donde se observar en detalle el porcentaje de consumo

que tienen los diferentes componentes del diseno. Fuente: Vivado Post-Implementation

Report.

Tabla 4.3: Consumo de potencia del modulo de interfaz general de la FPU en las arqui-

tecturas de 32 y 64 bits.

Arquitectura de 32 bits Arquitectura de 64 bits

Consumo de

potencia

estatica (mW)

Consumo de

potencia

dinamica (mW)

Consumo de

potencia

Total (mW)

Consumo de

potencia

estatica (mW)

Consumo de

potencia

dinamica (mW)

Consumo de

potencia

Total (mW)

104 15 119 104 26 130

A partir de estas tablas y figuras, se puede observar que el consumo de potencia estatico

en ambas arquitecturas es relativamente constante. Esto es debido a que el consumo de

potencia estatica es propio de la FPGA e independiente del diseno que se desarrolle en la

placa. Caso contrario, el consumo de potencia dinamica, de la cual se puede observar un

mejor desglose en las Figuras 4.3a y 4.3b, aumenta en la implementacion de 64 bits con

respecto a la de 32 bits.


4.1.2 Modulo de deteccion de resultados NaN.

En la Figura 4.4 se muestra el diagrama de entradas y salidas que conforman al modulo

de deteccion de resultados NaN. Este modulo lo que realiza es la comparacion de los

operandos de entrada que se utilizaran para realizar un calculo, con valores que generan

el resultado NaN, dependiendo de la operacion que se quiere realizar.

Figura 4.4: Modulo de manejo de la excepcion NaN, que permite detectar cuando la

combinacion de valores de entrada para calculo generaran un resultado NaN, para las

operaciones suma, resta, coseno, seno y multiplicacion.

En la Tabla 4.4 se muestran los valores que generan dicho resultado para cada operacion.

En esta tabla se observa las diferentes combinaciones de valores que se puede presentar

en las entradas de datos, y que generan el resultado NaN.

Tabla 4.4: Combinacion de valores de los operandos de entrada que generan la excepcion

NaN, para las operaciones suma, resta, coseno, seno y multiplicacion, en las

arquitecturas de 32 y 64 bits.

Operacion Operando 1 Operando 2

Suma

Resta

∞ ∞−∞ −∞∞ −∞−∞ ∞

Coseno

Seno

∞-

−∞

Multiplicacion

0 ∞0 −∞−∞ 0

∞ 0


4.1.3 Resultados experimentales.

Debido a que en las pruebas realizadas en hardware, los vectores de datos generados no

tenıan la posibilidad de tomar alguno de los valores presentes en la Tabla 4.4, a excepcion

del 0, que en el caso del seno y coseno no genera una excepcion, los resultados de la

implementacion del manejo de la excepcion NaN se obtienen unicamente de la simulacion.

Las Figuras 4.5, 4.6 y 4.7 corresponden a las simulaciones para las operaciones suma,

coseno y multiplicacion, respectivamente. En estas se observan diferentes combinaciones

de operandos de entrada para cada operacion, los cuales generan un resultado NaN.

Figura 4.5: Simulacion de la operacion suma, con valores de operandos de entrada que

generan la excepcion NaN. Notese como la bandera NaN flag se activa al evaluar los

valores de entrada. Fuente: Vivado Simulator

Figura 4.6: Simulacion de la operacion coseno, con un valor de operando de entrada que

genera la excepcion NaN. Notese como la bandera NaN flag se activa al evaluar los

valores de entrada. Fuente: Vivado Simulator


Figura 4.7: Simulacion de la operacion multiplicacion, con valores de operandos de entrada

que generan la excepcion NaN. Notese como la bandera NaN flag se activa al evaluar

los valores de entrada. Fuente: Vivado Simulator

Debido a que serıa muy repetitivo y carente de sentido mostrar los resultados obtenidos

para todas las posibles combinaciones de operandos de entrada que generan la excepcion

NaN, es que solo se presentan 3 figuras, las cuales demuestran el correcto funcionamiento

del modulo. Esto se realiza para la arquitectura de 32 bits, debido a que el resultado es

exactamente el mismo para la arquitectura de 64 bits.

A partir de las Figuras 4.5, 4.6 y 4.7 se puede observar como la bandera que indica que

los operandos de entrada generan un resultado NaN, se activa y toma un valor en alto.

Esta bandera, como se observa en la Figura, va directamente a la entrada del modulo

correspondiente a la operacion que se esta realizando y le indica a la maquina de estados

que se genero una excepcion, y por ende, que detenga la operacion y no realice el calculo.

Ademas se envıa esta senal a la salida de la Interfaz de la FPU, para indicarle al modulo

externo que solicito la solucion de la operacion, que se genero la excepcion.

Capıtulo 5

Conclusiones y Recomendaciones

5.1 Conclusiones.

• Se realizo la implementacion de las operaciones trigonometricas seno y coseno, ob-

teniendo un porcentaje de error menor al 1%, para las arquitecturas de 32 y 64 bits

con 16 iteraciones, en el proceso de verificacion.

• Se comprobo que el modulo de manejo de la excepcion NaN, identifica de manera

correcta la combinacion de operandos de entrada que generan esta excepcion, para

las 5 operaciones aritmeticas implementadas en la FPU.

• Se determino que se puede mejorar el porcentaje de error de las operaciones seno y

coseno aumentando la cantidad de iteraciones que realiza el algoritmo.

• Se concluyo que el uso del algoritmo CORDIC en hardware permite implementar

diversas operaciones de calculo utilizando el mismo hardware, permitiendo ası que

el consumo de recursos y el impacto en el area disponible sea muy bajo.

• A partir de los valores de slack obtenidos en el reporte de tiempo, se determina que el

modulo de calculo trigonometrico CORDIC, puede operar a una mayor frecuencia,

lo que permitira realizar el calculo de una operacion en un menor tiempo.

61

62 5.2 Recomendaciones.

5.2 Recomendaciones.

A partir de los resultados obtenidos en cuanto al tiempo de ejecucion de las operaciones

seno y coseno y al consumo de recursos que se obtuvo de la implementacion del algoritmo

CORDIC en la placa de desarrollo Nexys 4, se recomienda valorar la opcion de utilizar

la arquitectura bit-paralela iterativa pura y no la variacion que se implemento en este

proyecto.

Con esto lo que se busca es utilizar 3 modulos de suma y resta en punto flotante, que

permitan realizar el calculo de las variables del algoritmo CORDIC en paralelo, y no

como se realiza actualmente, calculando una variable a la vez, lo que produce que el tiempo

de ejecucion sea tres veces mas largo que si se realizaran estos calculos en paralelo. Debido

a que el consumo de recursos por parte del algoritmo CORDIC es de apenas 1% en la

arquitectura de 32 bits y de un 2% en la arquitectura de 64 bits, es muy factible considerar

esta opcion, si lo que se busca es obtener resultados en un menor tiempo.

Tambien se puede aumentar la frecuencia de reloj a la que trabaja la Nexys 4, para

conseguir que el tiempo necesario para obtener un resultado se reduzca, y dependiendo de

los requerimientos de tiempo y precision del modulo externo que solicita el calculo de una

operacion, se puede aumentar con esto la cantidad de iteraciones que realiza el algoritmo.

Bibliografıa

[1] IEEE Standard for Floating-Point Arithmetic. IEEE Std 754-2008, pages 13–21,

Aug 2008.

[2] T. Adiono and R. S. Purba. Scalable pipelined CORDIC architecture design and

implementation in FPGA. In Electrical Engineering and Informatics, 2009. ICEEI

’09. International Conference on, volume 02, pages 646–649, 2009. ID: 1.

[3] Matthew Butler. Hidden Markov Model Clustering of Acoustic Data [online].

2003 [visitado el 15 de Octubre del 2015]. URL http://www.inf.ed.ac.uk/

publications/thesis/online/IM030057.pdf.

[4] Salazar Garcıa C. Implementacion de un microprocesador de aplicacion especıfica pa-

ra la ejecucion del algoritmo de Modelos Ocultos de Markov ara el reconocimiento de

patrones acusticos. Tesis de Maestrıa, Escuela de Ingenierıa en Electronica, Instituto

Tecnologico de Costa Rica, Diciembre 2015.

[5] ORACLE Help Center. Chapter 2. IEEE Arithmetic [online]. 2015 [visitado el

21 de junio de 2016]. URL http://docs.oracle.com/cd/E19957-01/806-3568/

ncg_math.html.

[6] The Oxford Math Center. IEEE 754 Format [online]. 2015 [visitado el 21 de junio

de 2016]. URL http://www.oxfordmathcenter.com/drupal7/node/43.

[7] R. Cerdas-Robles, A. Rodrıguez, A. Chacon-Rodrıguez, and P. Julian. Design of

an IDM-based determinant computing unit for a 130nm low power CMOS ASIC

acoustic localization processor. In Circuits Systems (LASCAS), 2015 IEEE 6th Latin

American Symposium on, pages 1–4, Feb 2015.

[8] Alvarado Moya J.P Chacon Rodrıguez, A. Sistema electronico integrado en chip

(SoC) para el reconocimiento de patrones de disparos y motosierras en una red

inalambrica de sensores para la proteccion ambiental (Documento I) [online]. 2014

[visitado el 11 de Octubre del 2015]. URL http://www.ie.itcr.ac.cr/achacon/

VIE/sirpa-doc1.pdf.

[9] Rodrıguez Valverde Diego A. Diseno e implementacion de una unidad aritmetico-

logica de coma flotante para un procesador de aplicacion especıfica. Tesis de Licen-

63

http://www.inf.ed.ac.uk/publications/thesis/online/IM030057.pdf

http://www.inf.ed.ac.uk/publications/thesis/online/IM030057.pdf

http://docs.oracle.com/cd/E19957-01/806-3568/ncg_math.html

http://docs.oracle.com/cd/E19957-01/806-3568/ncg_math.html

http://www.oxfordmathcenter.com/drupal7/node/43

http://www.ie.itcr.ac.cr/achacon/VIE/sirpa-doc1.pdf

http://www.ie.itcr.ac.cr/achacon/VIE/sirpa-doc1.pdf

64 Bibliografıa

ciatura, Escuela de Ingenierıa en Electronica, Instituto Tecnologico de Costa Rica,

Enero 2016.

[10] Z Ghahramani. An Introduction to Hidden Markov Models and Bayesian Networks

[online]. 2001 [visitado el 13 de Octubre del 2015]. URL http://mlg.eng.cam.ac.

uk/zoubin/papers/ijprai.pdf.

[11] C. Gomez-Viquez, L.A. Li-Huang, O. Villalta-Gutierrez, A. Chacon-Rodriguez, and

P. Alvarado-Moya. An Embedded Test System for Acoustic Pattern Recognition In-

tended for Environmental Monitoring and Protection in Tropical rain forest reserves.

In Proceedings of the ETC2012 Third Embedded Technology Conference, San Jose,

Costa Rica, January 2012.

[12] W Kahan. IEEE standard 754 for binary floating-point arithmetic [online]. 1997

[visitado el 15 de Octubre del 2015]. URL http://www.eecs.berkeley.edu/wkahan/

ieee754status/IEEE754.pdf.

[13] Bria O. Descripcion en VHDL de arquitecturas para implementar el algoritmo COR-

DIC. Tesis de licenciatura, Universidad Nacional de la Plata, 2002.

[14] C. Salazar-Garcıa, L. Alfaro-Hidalgo, M. Carvajal-Delgado, J. Montero-Aragon,

R. Castro-Gonzalez, J. A. Rodrıguez, A. Chacon-Rodrıguez, and P. Alvarado-Moya.

Digital integrated circuit implementation of an identification stage for the detection

of illegal hunting and logging. In Circuits Systems (LASCAS), 2015 IEEE 6th Latin

American Symposium on, pages 1–4, Feb 2015.

[15] J. E. Volder. The CORDIC Trigonometric Computing Technique. IRE Transactions

on Electronic Computers, EC-8(3):330–334, 1959.

[16] Lee Y. Patterson D. Asanovic K Waterman, A. The RISC-V Instruction Set Ma-

nual, Volume I: User- Level ISA, Version 2.0 [online]. 2014 [visitado el 10 de

Octubre del 2015]. URL http://www.eecs.berkeley.edu/Pubs/TechRpts/2014/

EECS-2014-54.pdf.

[17] Jie Zhou, Yong Dou, Yuanwu Lei, Jinbo Xu, and Yazhuo Dong. Double Precision

Hybrid-Mode Floating-Point Fpga CORDIC Co-processor. In High Performance

Computing and Communications, 2008. HPCC ’08. 10th IEEE International Confe-

rence on, pages 182–189, 2008. ID: 1.

http://mlg.eng.cam.ac.uk/zoubin/papers/ijprai.pdf

http://mlg.eng.cam.ac.uk/zoubin/papers/ijprai.pdf

http://www.eecs.berkeley.edu/wkahan/ieee754status/IEEE754.pdf

http://www.eecs.berkeley.edu/wkahan/ieee754status/IEEE754.pdf

http://www.eecs.berkeley.edu/Pubs/TechRpts/2014/EECS-2014-54.pdf

http://www.eecs.berkeley.edu/Pubs/TechRpts/2014/EECS-2014-54.pdf

Apendice A

Tablas obtenidas mediante la

implementacion del Algoritmo

CORDIC en hoja de calculo y el

software Octave.

Tabla A.1: Resultados obtenidos en hoja de calculo, desplegando valores teoricos, valo-

res obtenidos del algoritmo CORDIC, y el porcentaje de error con diferente

cantidad de iteraciones.

Angulo de entrada (grados) = 84,52357

kn = 0,60725293651701

cos(alpha) teorico= 0,0954362556888532

sin(alpha) teorico= 0,995435543418102

cos(10 iteraciones)= 0,095604138995655

sin(10 iteraciones)= 0,995603608010703

cos %error= 0,175911455861283%

sin %error= 0,0168835233694574%

cos(20 iteraciones)= 0,0954335077736298

sin(20 iteraciones)= 0,9954356273350420

cos %error= 0,002879320027385610%

sin %error= 0,000008430173132282%

cos(30 iteraciones)= 0,0954362556144339

sin(30 iteraciones)= 0,9954355457423870

cos %error= 0,000000077978050659%

sin %error= 0,000000233494295448%

cos(40 iteraciones)= 0,0954362559222506

sin(40 iteraciones)= 0,9954355458904660

cos %error= 0,00000024455844867454%

sin %error= 0,00000024837005012663%

cos(50 iteraciones)= 0,0954362559258685

sin(50 iteraciones)= 0,9954355458902920

cos %error= 0,000000248349295361547%

sin %error= 0,000000248352628924666%

cos(64 iteraciones)= 0,0954362559258717

sin(64 iteraciones)= 0,9954355458902920

cos %error= 0,000000248352727136923%

sin %error= 0,000000248352617771528%

65

66

Tabla A.2: Valores precalculados de arcotan(2−i) necesarios para el calculo de las ope-

raciones seno y coseno con el algoritmo CORDIC.

n arctan(2−i) n arctan(2−i)

0 0,78539816339744800000 32 0,00000000023283064365

1 0,46364760900080600000 33 0,00000000011641532183

2 0,24497866312686400000 34 0,00000000005820766091

3 0,12435499454676100000 35 0,00000000002910383046

4 0,06241880999595740000 36 0,00000000001455191523

5 0,03123983343026830000 37 0,00000000000727595761

6 0,01562372862047680000 38 0,00000000000363797881

7 0,00781234106010111000 39 0,00000000000181898940

8 0,00390623013196697000 40 0,00000000000090949470

9 0,00195312251647882000 41 0,00000000000045474735

10 0,00097656218955931900 42 0,00000000000022737368

11 0,00048828121119489800 43 0,00000000000011368684

12 0,00024414062014936200 44 0,00000000000005684342

13 0,00012207031189367000 45 0,00000000000002842171

14 0,00006103515617420880 46 0,00000000000001421085

15 0,00003051757811552610 47 0,00000000000000710543

16 0,00001525878906131580 48 0,00000000000000355271

17 0,00000762939453110197 49 0,00000000000000177636

18 0,00000381469726560650 50 0,00000000000000088818

19 0,00000190734863281019 51 0,00000000000000044409

20 0,00000095367431640596 52 0,00000000000000022204

21 0,00000047683715820309 53 0,00000000000000011102

22 0,00000023841857910156 54 0,00000000000000005551

23 0,00000011920928955078 55 0,00000000000000002776

24 0,00000005960464477539 56 0,00000000000000001388

25 0,00000002980232238770 57 0,00000000000000000694

26 0,00000001490116119385 58 0,00000000000000000347

27 0,00000000745058059692 59 0,00000000000000000173

28 0,00000000372529029846 60 0,00000000000000000087

29 0,00000000186264514923 61 0,00000000000000000043

30 0,00000000093132257462 62 0,00000000000000000022

31 0,00000000046566128731 63 0,00000000000000000011

Apendice B

Diagramas de estado de las

maquinas de control.

Figura B.1: Diagrama de estados de la maquina de control que maneja los modulos

implementados para las pruebas en la FPGA y la transmision de datos por via serial.

67

68

Figura B.2: Diagrama de estados de la maquina de control del Algoritmo CORDIC.

Apendice C

Scripts mas importantes

implementados en Octave

Listing C.1: Script del Algoritmo CORDIC implementado en el software matematico

Octave.

1 f unc t i on [ seno , coseno ] = cordic Hardware (n , z0 )

2 format long

3 %

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

4 %Entradas :

5 %n= cant idad de i t e r a c i o n e s que se desean r e a l i z a r .

6 %z0 = angulo de entrada que se desea c a l c u l a r e l s i n y cos .

7 %S a l i d a s :

8 %seno = seno de l angulo beta de entrada .

9 %coseno = coseno de l angulo beta de entrada .

10 %

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

11 %Primero se asegura que e l angulo de entrada e s t e en l a primera rotac ion , y

12 %cambia l o s v a l o r e s o l o s desp laza para que obtengan v a l o r e s ent r e −pi<z0<=

pi

13 %en vez de 0<z0<=2pi . S i e l angulo e s ta ent re 0 y p i se meantiene su valor ,

14 %s i se encuentra ent re p i y 2 p i se rota su va l o r para que se ubique ent re 0

y −pi .

15 z0 = z0 ∗( p i /180) ;

16 s h i f t f l a g = 1 ;

17 Reg i on f l ag = 0 ;

18 alpha = 0 ;

19 i f ( z0 < −pi )

20 alpha = −pi − mod ( −pi − z0 , 2 . 0 ∗ pi ) + 2 .0 ∗ pi ;

21 e l s e

22 alpha = −pi + mod ( z0 + pi , 2 . 0 ∗ pi ) ;

23 end

24 %

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

69

70

25 %Seguido se asegura de que e l angulo a c a l c u l a r e s t e ent re e l rango de −pi

/2 y

26 %pi /2 , ya que es e l rango de en que e l a lgor i tmo CORDIC c a l c u l a e l va l o r

de l

27 %seno y coseno de l angulo de entrada .

28 i f ( alpha < −pi /2)

29 alpha = alpha + pi /2 ;

30 s h i f t f l a g = −1;

31 Reg i on f l ag = −1;

32 e l s e i f ( alpha > pi /2)

33 alpha = alpha − pi /2 ;

34 s h i f t f l a g = −1;


36 e l s e

37 s h i f t f l a g = 1 ;


39 end

40 %

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

41 %Despues de de sp la za r e l angulo a l rango deseado , se procede a l c a l c u l o de

l a s

42 %cosntante s atan (2ˆ(− i ) ) , donde i = 0 , 1 , 2 , . . . , n−1; donde n es l a cant idad

de i t e r a−43 %c i o n e s a r e a l i z a r por e l programa .

44 f i d=fopen ( ’LUT. txt ’ , ’w ’ ) ;

45 f o r ( j=1 : 1 : n )

46 Angles (1 , j ) = atan (2ˆ(1− j ) ) ;

47 f p r i n t f ( f i d , ’%s \n ’ , num2hex( s i n g l e ( Angles (1 , j ) ) ) ) ;

48 end

49 f c l o s e ( f i d ) ;

50 %

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

51 %Se procede a c a l c u l a r l a constante de c o r r e c i o n de l a magnitud de l a s

v a r i a b l e s

52 %de s a l i d a . Por l o gene ra l e s t e va l o r es cercano a 0 . 6 0 7 2 .

53 K=1;

54 f o r ( j=0 : 1 : n−1)

55 K = K∗(1/ s q r t (1 + 2ˆ(−2∗ j ) ) ) ;

56 end

57 %

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

58 %Se procede a c a l c u l a r e l seno y e l coseno mediante e l a lgor i tmo CORDIC.

59 Xi = K;

60 Yi = 0 ;

61 Zi = alpha ;

62 f o r ( i=0 : 1 : n−1)

63 i f ( Zi < 0)

64 sigma = −1;

C Scripts mas importantes implementados en Octave 71

65 e l s e

66 sigma = 1 ;

67 end

68 X i1 = Xi − sigma∗Yi∗2ˆ(− i ) ;

69 Y i1 = Yi + sigma∗Xi∗2ˆ(− i ) ;

70 Z i1 = Zi − sigma∗Angles (1 , i +1) ;

71 Xi = X i1 ;

72 Yi = Y i1 ;

73 Zi = Z i1 ;

74 end

75 %

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

76 %A cont inuac ion se procede a r e v i s a r e l va l o r de l a s banderas de

desplazamiento y de

77 %region , para i d e n t i f i c a r s i hay que r e a l i z a r un intercambio en l a s s a l i d a s

.

78 i f ( s h i f t f l a g == −1)

79 i f ( Reg i on f l ag == 1)

80 Temp = Xi ;

81 Xi = −Yi ;

82 Yi = Temp;

83 e l s e i f ( Reg i on f l ag == −1)

84 Temp = Xi ;

85 Xi = Yi ;

86 Yi = −Temp;

87 e l s e

88 Xi = Xi ;

89 Yi = Yi ;

90 end

91 e l s e

92 Xi = Xi ;

93 Yi = Yi ;

94 end

95 %

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

96 %Se procede a a j u s t a r e l va l o r de l a s v a r i a b l e s Xi y Yi m u l t i p l i c a n d o l a s

por l a

97 %constante K, para obtener e l va l o r c o r r e c t o .

98 coseno = Xi ;

99 seno = Yi ;

Listing C.2: Script implementado en el software matematico Octave para la recoleccion

de datos provenientes de la FPGA mediante el puerto serial.

1 f unc t i on [ ] = se r i a l com ( port ,BR, n , prec )

2 pkg load instrument−c o n t r o l ;

3

4 s1 = s e r i a l ( port , BR) ;

5 s r l f l u s h ( s1 )

6 data = s r l r e a d ( s1 , n ) ;

72

7 datahex = dec2hex ( data ) ;

8 datos =0;

9

10 f 1=fopen ( ’ /home/ j e f f r y q f /Desktop/ Result SIN64 200MHz fpga 2048 . txt ’ , ’w ’ ) ;

11 i f ( prec==32)

12 datos = n /4 ;

13 f o r ( j=1 : 4 : n )

14 f p r i n t f ( f1 , ’%s ’ , datahex ( j , 1 ) ) ;


16 f p r i n t f ( f1 , ’%s ’ , datahex ( j +1 ,1) ) ;





21 f p r i n t f ( f1 , ’%s \n ’ , datahex ( j +3 ,2) ) ;

22 end

23 e l s e

24 datos = n /8 ;

25 f o r ( j=1 : 8 : n )
















41 f p r i n t f ( f1 , ’%s \n ’ , datahex ( j +7 ,2) ) ;

42 end

43

44 e n d i f

45 f c l o s e ( f 1 ) ;

46 h e x 2 f l o a t ( ’ /home/ j e f f r y q f /Desktop/ Result SIN64 200MHz fpga 2048 . txt ’ , ’ /home

/ j e f f r y q f /Desktop/ Resu l t SIN64 200MHz fpga 2048 f loat . txt ’ , datos , prec ) ;

Apendice D

Scripts implementados en Verilog

Listing D.1: Script Verilog que instancia los modulos de la arquitectura CORDIC.

1 ‘ t i m e s c a l e 1ns / 1ps

2

3 module CORDIC Arch2 #(parameter W = 32 , parameter EW = 8 , parameter SW =

23 , parameter SWR=26, parameter EWR = 5) //∗/4 /∗#(parameter W = 64 , parameter EW = 11 , parameter SW = 52 , parameter SWR =

55 , parameter EWR = 6) //−− Double P r e c i s i o n ∗/5 (

6 // Input S i g n a l s

7 input wire c lk , // Re lo j de l s i s tema .

8 input wire r s t , // S e a l de r e s e t de l s i s tema

.

9 input wire beg f sm cord i c , // S e a l de i n i c i o de l a

maquina de es tados de l m d u l o CORDIC.

10 input wire ack cord i c , // S e a l de acknowledge

proven iente de otro m d u l o que i n d i c a que ha r e c i b i d o e l r e s u l t a d o de l

modulo CORDIC.

11 input wire operat ion , // S e a l que

i n d i c a s i se r e a l i z a l a operac ion seno (1 ’ b1 ) o coseno (1 ’ b0 ) .

12

13 input wire [W−1:0 ] data in , // Dato de entrada , cont i ene

e l angulo que se desea c a l c u l a r en rad iane s .

14 input wire [ 1 : 0 ] s h i f t r e g i o n f l a g , // S e a l que i n d i c a s i e l

ngulo a c a l c u l a r e s ta fue ra de l rango de c a l c u l o de l a lgor i tmo CORDIC.

15

16 //Output S i g n a l s

17 output wire r eady cord i c , // S e a l de s a l i d a que i n d i c a

que se ha completado e l c a l c u l o de l seno / coseno .

18 output wire o v e r f l o w f l a g , // Bandera de over f l ow de l a

operac ion .

19 output wire unde r f l ow f l ag , //

Bandera de underf low de l a operac ion .

20 output wire [W−1:0 ] data output // Bus de datos con e l va l o r

f i n a l de l angulo ca l cu l ado .

21 ) ;

73

74

22

23 loca lparam d var = 0 ; // Valor por

d e f e c t o que se l e carga a l contador de v a r i a b l e s .

24 loca lparam d i t e r = 0 ; // Valor por d e f e c t o que se l e

carga a l contador de i t e r a c i o n e s .

25 loca lparam mode = 1 ’ b0 ;

26 loca lparam r mode = 2 ’ b00 ;

27 loca lparam i t e r b i t s = 4 ; // Modi f i car va l o r para obtener

d i f e r e n t e cant idad de i t e r a c i o n e s ; ejem= 3=8 i t e r , 4=16 i t e r . e t c

28

29 wire [W−1:0 ] x0 , y0 ;

30 //

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

31

32 generate

33 case (W)

34

35 32 :

36 begin

37 a s s i g n x0 = 32 ’ h3f1b74ee ; // x0

= 0.607252935008881 , va l o r i n i c i a l de l a v a r i a b l e X.

38 a s s i g n y0 = 32 ’ h00000000 ; // y0

= 0 , va l o r i n i c i a l de l a v a r i a b l e Y.

39 end

40

41 64 :

42 begin

43 a s s i g n x0 = 64 ’ h3fe36e9db5086bc9 ; // x0 =

0.607252935008881 , va l o r i n i c i a l de l a v a r i a b l e X.

44 a s s i g n y0 = 64 ’ h0000000000000000 ; // y0 = 0 , va l o r

i n i c i a l de l a v a r i a b l e Y.

45 end

46

47 d e f a u l t :

48 begin

49 a s s i g n x0 = 32 ’ h3f1b74ee ; // x0 =

0.607252935008881 , va l o r i n i c i a l de l a v a r i a b l e X.

50 a s s i g n y0 = 32 ’ h00000000 ; // y0 = 0 , va l o r

i n i c i a l de l a v a r i a b l e Y.

51 end

52 endcase

53 endgenerate

54

55 //

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

56

57 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

58


59 // S igna l d e c l a r a t i o n

60

61 wire r e s e t r e g c o r d i c ;

62

63 //ENABLE

64 wire enab d f f RB1 ; // Enable de

l a primera l i n e a de r e g i s t r o s .

65 wire enab d f f2 RB2 ; //

Enable de l a segunda l i n e a de r e g i s t r o s .

66 wire enab RB3 ;

// Enable de l r e g i s t r o que guarda

e l va l o r de l s igno , dependiendo de l modo de l a lgor i tmo .

67 wire enab d f f4 Xn , enab d f f4 Yn , enab d f f 4 Zn ; //

Enable de l o s r e g i s t r o s que guardan l o s datos proven i en t e s de l modulo de

suma/ r e s t a .

68 wire e n a b d f f 5 d a t a o u t ;

// Enable de l r e g i s t o que guarda e l va l o r

de s a l i d a f i n a l , l i s t o para e n v i a r s e a l procesador .

69 wire e n a b c o n t i t e r , enab cont var ; //

Enable de l o s contadores de v a r i a b l e e i t e r a c i o n

70 wire l o a d c o n t i t e r , l o ad co n t va r ; //

S e a l de carga de un va lo r en l o s contadores de v a r i a b l e e i t e r a c i o n e s .

71 wire e n a b d f f 5 ;

72

73

74

75 //SELECTION

76 wire sel mux 1 , se l mux 3 ; // S e a l e s de

s e l e c c i o n proven i en te s de l a maquina de es tados .

77 wire [ 1 : 0 ] se l mux 2 ;

// S e a l de s e l e c c i o n que se a c t i va dependiendo de l a

v a r i a b l e que se e s t e ca l cu lando .

78

79 wire se l mux 1 reg , s e l mux 3 reg ; // S e a l e s de

s e l e c c i o n proven i en te s de l a maquina de es tados .

80 wire [ 1 : 0 ] s e l mux 2 reg ; //

S e a l de s e l e c c i o n que se ac t i va dependiendo de l a v a r i a b l e que

se e s t e ca l cu lando .

81

82 //DATA WIRES

83 wire d f f 1 o p e r a t i o n o u t ;

// Sa l ida de l r e g i s t r o que guarda e l dato

de entrada de l a operac ion a r e a l i z a r , coseno (1 ’ b0 ) o seno (1 ’ b1 )

84 wire [ 1 : 0 ] d f f 1 s h i f t r e g i o n f l a g o u t ; //

Sa l ida de l r e g i s t r o que guarda e l dato de entrada que i n d i c a s i e l

ngulo a c a l c u l a r e s ta fue ra de l rango de c a l c u l o de l a lgor i tmo CORDIC.

85 wire [W−1:0 ] d f f 1 Z ; //

S a l i d a s de l o s r e g i s t r o s que guardan l o s v a l o r e s i n i c i a l e s de l a s

v a r i a b l e s X, Y y Z .

86 wire [W−1:0 ] d f f Xn , d f f Yn , d f f Z n ;

// S a l i d a s de l o s r e g i s t r o s que guardan l o s v a l o r e s de l a s

v a r i a b l e s X, Y y Z despues de cada i t e r a c i o n .

76

87 wire [W−1:0 ] f i r st mux X , f i rst mux Y , f i r s t mux Z ; //

S a l i d a s de l o s mux que escogen ent re un va lo r i n i c i a l y e l va l o r

obtenido en una i t e r a c i o n .

88 wire [W−1:0 ] d f f2 X , d f f2 Y , d f f 2 Z ; //

S a l i d a s de l o s r e g i s t r o s que guardan l o s v a l o r e s p roven i en t e s de l a

primera l i n e a de mux .

89 wire s i gn ; //

Sa l ida de l mux que escoge ent re e l s i gno de Y o Z , dependiendo de l modo ,

ya sea ro ta c i on o v e c t o r i z a c i o n .

90 wire [W−1:0 ] data out LUT ;

// Sa l ida de l modulo generate que genera l a

LUT n e c e s a r i a dependiendo de l ancho de palabra .

91 wire [ i t e r b i t s −1:0 ] c o n t i t e r o u t ; // Sa l ida de l

contador que cuenta l a s i t e r a c i o n e s r e a l i z a d a s .

92 wire [EW−1:0 ] sh exp x , sh exp y ; //

S a l i d a s de l o s sumadores de punto f i j o que r e a l i z a n l o s desp lazamientos .

93 wire [W−1:0 ] d f f 3 s h x o u t , d f f 3 s h y o u t ; //

Sa l ida de l r e g i s t r o que guarda e l va l o r de X y Y luego de r e a l i z a r l o s

desp lazamientos .

94 wire [W−1:0 ] d f f3 LUT out ; //

Sa l ida de l r e g i s t r o que guarda e l va l o r de l a LUT.

95 wire d f f 3 s i g n o u t ; //

Sa l ida de l r e g i s t r o que guarda e l va l o r de l s i gno .

96 wire [ 1 : 0 ] cont va r out ; //

Sa l ida de l contador que cuenta l a s v a r i a b l e s c a l c u l a d a s .

97 wire [W−1:0 ] mux sal ; //

Sa l ida de l mux f i n a l para c o l o c a r en l a s a l i d a e l va l o r deseado .

98 wire [W−1:0 ] data output2 ;

// Sa l ida de l r e g i s t r o antes de l cambio de

s igno .

99 wire [W−1:0 ] s i g n i n v o u t ;

// Sa l ida de l modulo de i n v e r s i o n de s igno ,

dependiendo de s i se e l angulo de entrada estaba fue ra de l rango de

c a l c u l o de l a lgor i tmo CORDIC.

100 wire m i n t i c k i t e r , m a x t i c k i t e r ; //

S e a l e s que ind i can cuando se ha alcanzado e l va l o r mas bajo y masalto

de cuenta , correspondientemente en e l contador de i t e r a c i o n e s .

101 wire min t i ck var , max t ick var ; //

S e a l e s que ind i can cuando se ha alcanzado e l va l o r mas bajo y masalto

de cuenta , correspondientemente en e l contador de v a r i a b l e s .

102 wire enab reg se l mux1 , enab reg se l mux2 , enab reg se l mux3 ;

103 wire ready add subt ;

// S e a l que i n d i c a que se ha r e a l i z a d o l a

operac ion de suma/ r e s t a en punto f l o t a n t e .

104 wire [W−1:0 ] r e s u l t a d d s u b t ;

// Dato de entrada , cont i ene e l r e s u l t a d o de l

m d u l o de suma/ r e s t a .

105 wire beg add subt ;

// S e a l de s a l i d a que i n d i c a que se debe de

i n i c i a r e l modulo de suma/ r e s t a .

106 wire ack add subt ;

// S e a l que l e i n d i c a a l modulo de suma/ r e s t a que


se r e c i b i o e l r e s u l t a d o de e s t e modulo correctamente .

107 wire op add subt ;

// S e a l hac ia e l m d u l o de suma/ r e s t a que i n d i c a

s i se va a r e a l i z a r una suma (1 ’ b0 ) o una r e s t a (1 ’ b1 ) .

108 wire [W−1:0 ] add subt dataA ;

// Bus de datos hac ia e l modulo de suma/ r e s t a con

e l va l o r a l que se l e desea a p l i c a r dicha operac ion .

109 wire [W−1:0 ] add subt dataB ;

// Bus de datos hac ia e l modulo de suma/ r e s t a con

e l va l o r a l que se l e desea a p l i c a r dicha operac ion .

110

111 // I n s t a n c i a c i n

112 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

113 //FSM

114

115 CORDIC FSM v2 cordic FSM

116 (

117 . c l k ( c l k ) ,

// Re lo j de l s i tema .

118 . r e s e t ( r s t ) ,

// Reset de l s i tema .

119 . beg FSM CORDIC( beg f sm cord i c ) ,

// S e a l de i n i c i o de l a maquina de

es tados .

120 .ACK FSM CORDIC( a c k c o r d i c ) ,

// S e a l proven i ente de l modulo que r e c i b e e l

r e su l tado , ind i cado que e l dato ha s ido r e c i b i d o .

121 . ope ra t i on ( d f f 1 o p e r a t i o n o u t ) ,

// S e a l que determina s i l o que

se r e q u i e r e es r e a l i z a r un coseno (1 b0 ) o seno (1 ’ b1 ) .

122 . s h i f t r e g i o n f l a g ( d f f 1 s h i f t r e g i o n f l a g o u t ) ,

// S e a l que i n d i c a s i e l angulo a

c a l c u l a r se encuentra fue ra de l rango de c a l c u l o de l a lgor i tmo CORDIC.

123 . cont var ( cont va r out ) ,

// S e a l que i n d i c a cua l v a r i b l e se va a c a l c u l a r .

Proveniente de l contador de v a r i a b l e s .

124 . r eady add subt ( ready add subt ) ,

// S e a l proven i ente de l m d u l o de suma/

res ta , i n d i c a que se ha terminado l a operac ion y que se puede d i sponer

de l r e s u l t a d o de dicho modulo .

125 . m a x t i c k i t e r ( m a x t i c k i t e r ) ,

126 . m i n t i c k i t e r ( m i n t i c k i t e r ) , // S e a l e s

que ind i can l a maxima y minima cuenta , respect ivamente , en e l contador

de i t e r a c i o n e s .

127 . max t ick var ( max t ick var ) ,

128 . m in t i ck va r ( min t i ck va r ) , //

S e a l e s que ind i can l a maxima y minima cuenta , respect ivamente , en e l

contador de v a r i a b l e s .

129


78

131 . r e s e t r e g c o r d i c ( r e s e t r e g c o r d i c ) ,

132 . ready CORDIC( r e a d y c o r d i c ) ,

// S e a l que i n d i c a que e l c a l c u l o CORDIC se ha

terminado .

133 . beg add subt ( beg add subt ) ,

// S e a l que i n d i c a a l modulo de suma/ r e s t a que

i n i c i e su operac ion .

134 . ack add subt ( ack add subt ) ,


se ha r e c i b i d o exitosamente e l r e s u l t a d o que e s t e entrega .

135 . se l mux 1 ( se l mux 1 ) ,

136 . se l mux 3 ( se l mux 3 ) , //

S e a l e s de s e l e c c i o n de mux, l a primera escoge e l cana l 0 s i e s l a

primera i t e r a c i o n , en otro caso escoge e l cana l 1 , y l a segunda escoge

cua l v a r i a b l e (X o Y) debe aparece r a l a s a l i d a .

137 . se l mux 2 ( se l mux 2 ) ,

// S e a l de s e l e c c i o n de mux, que escoge ent re X, Y o Z

dependiendo de cua l v a r i a b l e se deba c a l c u l a r en ese momento .

138 . e n a b c o n t i t e r ( e n a b c o n t i t e r ) ,

139 . l o a d c o n t i t e r ( l o a d c o n t i t e r ) , //

S e a l e s de h a b i l i t a c i o n y carga , respect ivamente , en e l contador de

i t e r a c i o n e s .

140 . enab cont var ( enab cont var ) ,

141 . l o a d c on t va r ( l o ad c on t va r ) , // S e a l e s de

h a b i l i t a c i o n y carga , respect ivamente , en e l contador de v a r i a b l e s .

142 . enab RB1 ( enab d f f RB1 ) ,

143 . enab RB2 ( enab d f f2 RB2 ) ,

// S e a l e s de h a b i l i t a c i o n para l o s r e g i s t r o s de v a r i a b l e s

de entrada y para l o s v a l o r e s de l a s v a r i a b l e s despues de l o s pr imeros

mux, re spect ivamente .

144 . enab d f f Xn ( enab d f f4 Xn ) ,

145 . enab d f f Yn ( enab d f f4 Yn ) ,

146 . enab d f f Zn ( enab d f f 4 Zn ) , // S e a l e s de h a b i l i t a c i o n para l o s

r e g i s t r o s que guardan l o s r e s u l t a d o s de cada v a r i a b l e en cada i t e r a c i o n

proven i en t e s de l modulo de suma/ r e s t a .

147 . e n a b d f f o u t ( e n a b d f f 5 d a t a o u t ) ,

148 . e n a b d f f 5 ( e n a b d f f 5 ) , //

S e a l e s de h a b i l i t a c i o n para l o s r e g i s t r o s en l a sa l i da , e l primero

antes de l cambio de s i gno y e l segundo es e l que se encuentra en l a

s a l i d a .

149 . enab RB3 ( enab RB3 ) , // S e a l e s de

h a b i l i t a c i o n para l o s r e g i s t r o s que guardan l o s v a l o r e s

p roven i en t e s de l a look−up t a b l e y de l s igno , re spect ivamente .

150 . enab reg se l mux1 ( enab reg se l mux1 ) ,

151 . enab reg se l mux2 ( enab reg se l mux2 ) ,

152 . enab reg se l mux3 ( enab reg se l mux3 )

153 ) ;

154

155 counter d #(.W( i t e r b i t s ) ) c o n t i t e r

156 (

157 . c l k ( c l k ) ,

158 . r s t ( r e s e t r e g c o r d i c ) ,


159 . load ( l o a d c o n t i t e r ) ,

160 . enable ( e n a b c o n t i t e r ) ,

161 . d ( d i t e r ) ,

162 . max tick ( m a x t i c k i t e r ) ,

163 . m in t i ck ( m i n t i c k i t e r ) ,

164 . q ( c o n t i t e r o u t )

165 ) ;

166

167 counter up #(.W(2) ) cont var

168 (

169 . c l k ( c l k ) ,


171 . load ( l oa d c on t va r ) ,

172 . enable ( enab cont var ) ,

173 . d ( d var ) ,

174 . max tick ( max t ick var ) ,

175 . m in t i ck ( min t i ck va r ) ,

176 . q ( cont va r out )

177 ) ;

178

179 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

180 // Primera Etapa : Reg i s t r o s que guardan l o s v a l o r e s i n i c i a l e s .

181

182 d f f e n # ( .W(1) ) r e g o p e r a t i o n

183 (

184 . c l k ( c l k ) , // system c lo ck

185 . r s t ( r e s e t r e g c o r d i c ) , // system r e s e t

186 . enable ( enab d f f RB1 ) , // load s i g n a l

187 .D( opera t i on ) , // input s i g n a l

188 .Q( d f f 1 o p e r a t i o n o u t ) // output s i g n a l

189 ) ;

190

191 d f f e n # ( .W(2) ) r e g r e g i o n f l a g

192 (




196 .D( s h i f t r e g i o n f l a g ) , // input s i g n a l

197 .Q( d f f 1 s h i f t r e g i o n f l a g o u t ) // output s i g n a l

198 ) ;

199

200 d f f e n # ( .W(W) ) reg Z0

201 (




205 .D( data in ) , // input s i g n a l

206 .Q( d f f 1 Z ) // output s i g n a l

207 ) ;

208

80

209 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

210 //Segunda Etapa : Reg i s t r o s que guardan e l cana l e l e g i d o para e l mux, a s i

como l o s mux .

211

212 d f f e n # ( .W(1) ) reg ch mux 1

213 (



216 . enable ( enab reg se l mux1 ) , // load s i g n a l

217 .D( se l mux 1 ) , // input s i g n a l

218 .Q( s e l mux 1 reg ) // output s i g n a l

219 ) ;

220

221 Mux 2x1 #(.W(W) ) mux1 x0

222 (

223 . s e l e c t ( s e l mux 1 reg ) ,

224 . ch 0 ( x0 ) ,

225 . ch 1 ( d f f Xn ) ,

226 . data out ( f i r s t mux X )

227 ) ;

228

229 Mux 2x1 #(.W(W) ) mux1 y0

230 (


232 . ch 0 ( y0 ) ,

233 . ch 1 ( d f f Yn ) ,

234 . data out ( f i r s t mux Y )

235 ) ;

236

237 Mux 2x1 #(.W(W) ) mux1 z0

238 (


240 . ch 0 ( d f f 1 Z ) ,

241 . ch 1 ( d f f Z n ) ,

242 . data out ( f i r s t mux Z )

243 ) ;

244

245 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

246 // Tercera Etapa : Reg i s t r o s que guardan l o s datos proven i en te s de l o s mux .

247

248 d f f e n # ( .W(W) ) reg val muxX 2stage

249 (



252 . enable ( enab d f f2 RB2 ) , // load s i g n a l

253 .D( f i r s t mux X ) , // input s i g n a l

254 .Q( d f f 2 X ) // output s i g n a l

255 ) ;


256

257 d f f e n # ( .W(W) ) reg val muxY 2stage

258 (




262 .D( f i r s t mux Y ) , // input s i g n a l

263 .Q( d f f 2 Y ) // output s i g n a l

264 ) ;

265

266 d f f e n # ( .W(W) ) reg va l muxZ 2stage

267 (




271 .D( f i r s t mux Z ) , // input s i g n a l

272 .Q( d f f 2 Z ) // output s i g n a l

273 ) ;

274

275 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

276 // Cuarta Etapa : Restadores para e l co r r im i en to de l exponente de X y Y,

Lookup−Table y mux de s igno dependiendo de l modo .

277

278 Simple Subt #(.W(EW) , .N( i t e r b i t s ) ) s h i f t x

279 (

280 .A( d f f 2 X [W−2:SW] ) ,

281 .B( c o n t i t e r o u t ) ,

282 .Y( sh exp x )

283 ) ;

284

285 Simple Subt #(.W(EW) , .N( i t e r b i t s ) ) s h i f t y

286 (

287 .A( d f f 2 Y [W−2:SW] ) ,

288 .B( c o n t i t e r o u t ) ,

289 .Y( sh exp y )

290 ) ;

291

292 //

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

293

294 generate

295 case (W)

296 32 :

297 begin

298 LUT ROM 32bits #(.W(W) , .N( i t e r b i t s ) ) LUT32

299 (

300 . address ( c o n t i t e r o u t ) ,

301 . data out ( data out LUT )

302 ) ;

82

303 end

304 64 :

305 begin


307 (



310 ) ;

311 end

312 d e f a u l t :

313 begin


315 (



318 ) ;

319 end

320 endcase

321 endgenerate

322

323 //

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

324

325 Mux 2x1 #(.W(1) ) mux sign

326 (

327 . s e l e c t (mode) ,

328 . ch 0 ( d f f 2 Z [W−1]) ,

329 . ch 1 ( d f f 2 Y [W−1]) ,

330 . data out ( s i gn )

331 ) ;

332

333 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

334 // Quinta Etapa : Reg i s t r o s que guardan l o s datos p roven i en te s de l a etapa

a n t e r i o r .

335

336 d f f e n # ( .W(W) ) r e g s h i f t x

337 (



340 . enable ( enab RB3 ) , // load s i g n a l

341 .D({ d f f 2 X [W−1] , sh exp x , d f f 2 X [SW−1 :0 ]} ) , // input s i g n a l

342 .Q( d f f 3 s h x o u t ) // output s i g n a l

343 ) ;

344

345 d f f e n # ( .W(W) ) r e g s h i f t y

346 (





350 .D({ d f f 2 Y [W−1] , sh exp y , d f f 2 Y [SW−1 :0 ]} ) , // input s i g n a l

351 .Q( d f f 3 s h y o u t ) // output s i g n a l

352 ) ;

353

354 d f f e n # ( .W(W) ) reg LUT

355 (




359 .D( data out LUT ) , // input s i g n a l

360 .Q( d f f3 LUT out ) // output s i g n a l

361 ) ;

362

363 d f f e n # ( .W(1) ) r e g s i g n

364 (




368 .D( s i gn ) , // input s i g n a l

369 .Q( d f f 3 s i g n o u t ) // output s i g n a l

370 ) ;

371

372 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

373 // Sexta Etapa : Mux de 3 cana l e s que se act ivan dependiendo de l a v a r i a b l e

a c a l c u l a r .

374

375 d f f e n # ( .W(2) ) reg ch mux 2

376 (



379 . enable ( enab reg se l mux2 ) , // load s i g n a l

380 .D( se l mux 2 ) , // input s i g n a l

381 .Q( s e l mux 2 reg ) // output s i g n a l

382 ) ;

383

384 Mux 3x1 b #(.W(W) ) mux 3x1 var1

385 (


387 . ch 0 ( d f f 2 X ) ,

388 . ch 1 ( d f f 2 Y ) ,

389 . ch 2 ( d f f 2 Z ) ,

390 . data out ( add subt dataA )

391 ) ;

392

393 Mux 3x1 b #(.W(W) ) mux 3x1 var2

394 (


396 . ch 0 ( d f f 3 s h y o u t ) ,

397 . ch 1 ( d f f 3 s h x o u t ) ,

398 . ch 2 ( d f f3 LUT out ) ,

84

399 . data out ( add subt dataB )

400 ) ;

401

402 Op Select op se l ec t mod

403 (

404 . v a r i a b l e ( cont va r out [ 0 ] ) ,

405 . s i gn ( d f f 3 s i g n o u t ) ,

406 . ope ra t i on ( op add subt )

407 ) ;

408

409 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

410 // Septima Etapa : Ins tanc iamiento de l m d u l o de suma y r e s t a .

411

412 FPU Add Subtract Function #(.W(W) , .EW(EW) , .SW(SW) , .SWR(SWR) , .EWR(EWR)

) add subt module

413 (

414 . c l k ( c l k ) ,

415 . r s t ( r s t ) ,

416 . beg FSM( beg add subt ) ,

417 . rst FSM ( ack add subt ) ,

418 . Data X ( add subt dataA ) ,

419 . Data Y ( add subt dataB ) ,

420 . add subt ( op add subt ) ,

421 . r mode ( r mode ) ,

422 . o v e r f l o w f l a g ( o v e r f l o w f l a g ) ,

423 . u n d e r f l o w f l a g ( u n d e r f l o w f l a g ) ,

424 . ready ( ready add subt ) ,

425 . f i n a l r e s u l t i e e e ( r e s u l t a d d s u b t )

426 ) ;

427

428 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

429 //Octava Etapa : Reg i s t r o s que guardan l o s v a l o r e s de c a l c u l o de l modulo de

suma y r e s t a .

430

431 d f f e n #(.W(W) ) d f f4 Xn

432 (

433 . c l k ( c l k ) ,


435 . enable ( enab d f f4 Xn ) ,

436 .D( r e s u l t a d d s u b t ) ,

437 .Q( d f f Xn )

438 ) ;

439

440 d f f e n #(.W(W) ) d f f4 Yn

441 (

442 . c l k ( c l k ) ,


444 . enable ( enab d f f4 Yn ) ,


445 .D( r e s u l t a d d s u b t ) ,

446 .Q( d f f Yn )

447 ) ;

448

449 d f f e n #(.W(W) ) d f f 4 Z n

450 (

451 . c l k ( c l k ) ,


453 . enable ( enab d f f 4 Zn ) ,

454 .D( r e s u l t a d d s u b t ) ,

455 .Q( d f f Z n )

456 ) ;

457

458 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

459 //Novena Etapa : Mux de s e l e c c i n de l va l o r de sa l i da , a s como e l modulo

de c o r r e c c i o n de s i gno y l o s r e g i s t r o s in te rmed io s que

460 // guardan l o s datos de s a l i d a .

461

462 d f f e n #(.W(1) ) reg ch mux 3

463 (

464 . c l k ( c l k ) ,


466 . enable ( enab reg se l mux3 ) ,

467 .D( se l mux 3 ) ,

468 .Q( s e l mux 3 reg )

469 ) ;

470

471 Mux 2x1 #(.W(W) ) mux 2x1 sal

472 (


474 . ch 0 ( d f f Xn ) ,

475 . ch 1 ( d f f Yn ) ,

476 . data out ( mux sal )

477 ) ;

478

479 d f f e n #(.W(W) ) d f f 5

480 (

481 . c l k ( c l k ) ,


483 . enable ( e n a b d f f 5 ) ,

484 .D( mux sal ) ,

485 .Q( data output2 )

486 ) ;

487

488 s i g n i n v e r t e r #(.W(W) ) s i gn inve r t e r mod

489 (

490 . data ( data output2 ) ,

491 . s h i f t r e g i o n f l a g ( d f f 1 s h i f t r e g i o n f l a g o u t ) ,

492 . ope ra t i on ( d f f 1 o p e r a t i o n o u t ) ,

493 . data out ( s i g n i n v o u t )

86

494 ) ;

495

496 d f f e n #(.W(W) ) d f f 5 d a t a o u t

497 (

498 . c l k ( c l k ) ,


500 . enable ( e n a b d f f 5 d a t a o u t ) ,

501 .D( s i g n i n v o u t ) ,

502 .Q( data output )

503 ) ;

504

505 endmodule

Listing D.2: Script Verilog de la maquina de estados del modulo CORDIC.


2

3 module CORDIC FSM v2

4 (


6 input wire c lk ,

// Re lo j de l s i tema .

7 input wire r e s e t ,

// Reset de l s i tema .

8 input wire beg FSM CORDIC ,

// S e a l de i n i c i o de l a maquina de es tados .

9 input wire ACK FSM CORDIC,

// S e a l proven i ente de l modulo que r e c i b e e l

r e su l tado , ind i cado que e l dato ha s ido r e c i b i d o .

10 input wire operat ion ,

// S e a l que determina s i l o que se r e q u i e r e es

r e a l i z a r un coseno (1 b0 ) o seno (1 ’ b1 ) .

11 input wire except ion ,

12 input wire [ 1 : 0 ] s h i f t r e g i o n f l a g ,

// S e a l que i n d i c a s i e l angulo a c a l c u l a r se encuentra

fue ra de l rango de c a l c u l o de l a lgor i tmo CORDIC.

13 input wire [ 1 : 0 ] cont var ,

// S e a l que i n d i c a cua l v a r i b l e se va a c a l c u l a r .

Proveniente de l contador de v a r i a b l e s .

14 input wire ready add subt ,

// S e a l proven i ente de l m d u l o de suma/ res ta ,

i n d i c a que se ha terminado l a operac ion y que se puede d i sponer de l

r e s u l t a d o de dicho modulo .

15 input wire ma x t i ck i t e r , m i n t i c k i t e r , //

S e a l e s que ind i can l a maxima y minima cuenta , respect ivamente ,

en e l contador de i t e r a c i o n e s .

16 input wire max tick var , min t i ck var , //

S e a l e s que ind i can l a maxima y minima cuenta , respect ivamente ,

en e l contador de v a r i a b l e s .

17


19 output reg r e s e t r e g c o r d i c ,


20 output reg ready CORDIC ,

// S e a l que i n d i c a que e l c a l c u l o CORDIC se ha

terminado .

21 output reg beg add subt ,

// S e a l que i n d i c a a l modulo de suma/ r e s t a que

i n i c i e su operac ion .

22 output reg ack add subt ,


se ha r e c i b i d o exitosamente e l r e s u l t a d o que e s t e entrega .

23 output reg sel mux 1 , se l mux 3 ,

// S e a l e s de s e l e c c i o n de mux, l a primera escoge e l cana l

0 s i e s l a primera i t e r a c i o n , en otro caso escoge e l cana l 1 , y l a

segunda escoge cua l v a r i a b l e (X o Y) debe aparecer a l a s a l i d a .

24 output reg [ 1 : 0 ] se l mux 2 ,

// S e a l de s e l e c c i o n de mux, que escoge ent r e X,

Y o Z dependiendo de cua l v a r i a b l e se deba c a l c u l a r en ese momento .

25 output reg e n a b c o n t i t e r , l o a d c o n t i t e r , //

S e a l e s de h a b i l i t a c i o n y carga , respect ivamente , en e l contador

de i t e r a c i o n e s .

26 output reg enab cont var , l oad cont var , //

S e a l e s de h a b i l i t a c i o n y carga , respect ivamente , en e l contador

de v a r i a b l e s .

27 output reg enab RB1 , enab RB2 ,

// S e a l e s de h a b i l i t a c i o n para l o s r e g i s t r o s de v a r i a b l e s

de entrada y para l o s v a l o r e s de l a s v a r i a b l e s despues de l o s pr imeros

mux, re spect ivamente .

28 output reg enab d f f Xn , enab d f f Yn , enab d f f Zn , // S e a l e s de

h a b i l i t a c i o n para l o s r e g i s t r o s que guardan l o s r e s u l t a d o s de cada

v a r i a b l e en cada i t e r a c i o n proven i en te s de l modulo de suma/ r e s t a .

29 output reg enab d f f ou t , enab d f f 5 , //

S e a l e s de h a b i l i t a c i o n para l o s r e g i s t r o s en l a sa l i da , e l

primero antes de l cambio de s i gno y e l segundo es e l que se encuentra en

l a s a l i d a .

30 output reg enab RB3 ,

31 output reg enab reg se l mux1 , enab reg se l mux2 , enab reg se l mux3

32 ) ;

33

34 // symbol ic s t a t e d e c l a r a t i o n

35 localparam [ 3 : 0 ] e s t0 = 4 ’ b0000 ,

36 e s t1 = 4 ’ b0001 ,

37 e s t2 = 4 ’ b0010 ,

38 e s t3 = 4 ’ b0011 ,

39 e s t4 = 4 ’ b0100 ,

40 e s t5 = 4 ’ b0101 ,

41 e s t6 = 4 ’ b0110 ,

42 e s t7 = 4 ’ b0111 ,

43 e s t8 = 4 ’ b1000 ,

44 e s t9 = 4 ’ b1001 ,

45 e s t10 = 4 ’ b1010 ,

46 e s t11 = 4 ’ b1011 ,

47 e s t12 = 4 ’ b1100 ,

48 e s t13 = 4 ’ b1101 ;

88

49

50

51 // s i g n a l d e c l a r a t i o n

52 reg [ 3 : 0 ] s t a t e r e g , s t a t e n e x t ; // Guardan e l estado ac tua l y

e l estado futuro , re spect ivamente .

53

54 // s t a t e r e g i s t e r

55

56 always @( posedge clk , posedge r e s e t )

57 begin

58 i f ( r e s e t ) // S i hay re s e t , e l estado ac tua l es e l estado

i n i c i a l .

59 s t a t e r e g <= es t0 ;

60 e l s e // S i no hay r e s e t e l estado ac tua l es i g u a l a l

estado s i g u i e n t e .

61 s t a t e r e g <= s t a t e n e x t ;

62 end

63

64 // next−s t a t e l o g i c and output l o g i c

65

66 always @∗67 begin

68 s t a t e n e x t = s t a t e r e g ; // d e f a u l t s t a t e : the same

69

70 // d e c l a r a t i o n o f d e f a u l t outputs .

71 ready CORDIC = 1 ’ b0 ;

72 beg add subt = 1 ’ b0 ;

73 ack add subt = 1 ’ b0 ;

74 se l mux 1 = 1 ’ b0 ;

75 se l mux 2 = 2 ’ b00 ;

76 se l mux 3 = 1 ’ b0 ;

77 e n a b c o n t i t e r = 1 ’ b0 ;

78 l o a d c o n t i t e r = 1 ’ b0 ;

79 enab cont var = 1 ’ b0 ;

80 l o ad c on t va r = 1 ’ b0 ;

81 enab RB1 = 1 ’ b0 ;

82 enab RB2 = 1 ’ b0 ;

83 enab RB3 = 1 ’ b0 ;

84 enab d f f Xn = 1 ’ b0 ;

85 enab d f f Yn = 1 ’ b0 ;

86 enab d f f Zn = 1 ’ b0 ;

87 e n a b d f f o u t = 1 ’ b0 ;

88 r e s e t r e g c o r d i c = 1 ’ b0 ;

89 e n a b d f f 5 = 1 ’ b0 ;

90 enab reg se l mux1 = 1 ’ b0 ;



93

94 case ( s t a t e r e g )

95 e s t0 :

96 begin

97 r e s e t r e g c o r d i c = 1 ’ b1 ;





101 s t a t e n e x t = es t1 ;

102 end

103

104 e s t1 :

105 begin

106 i f (beg FSM CORDIC)

107 begin

108 s t a t e n e x t = es t2 ;

109 end

110 e l s e

111 s t a t e n e x t = es t1 ;

112 end

113

114 e s t2 :

115 begin

116 enab RB1 = 1 ’ b1 ;

117 e n a b c o n t i t e r = 1 ’ b1 ;

118 l o a d c o n t i t e r = 1 ’ b1 ;

119 s t a t e n e x t = es t3 ;

120 end

121

122 e s t3 :

123 begin

124 i f ( m i n t i c k i t e r )

125 se l mux 1 = 1 ’ b0 ;

126 e l s e

127 se l mux 1 = 1 ’ b1 ;


129

130 s t a t e n e x t = es t4 ;

131 end

132

133 e s t4 :

134 begin

135 i f ( except ion )

136 s t a t e n e x t = es t0 ;

137 e l s e

138 s t a t e n e x t = es t5 ;

139 enab RB2 = 1 ’ b1 ;

140 end

141

142 e s t5 :

143 begin

144 enab RB3 = 1 ’ b1 ;


146 l o ad co n t va r = 1 ’ b1 ;

147 s t a t e n e x t = es t6 ;

148 end

149

90

150 e s t6 :

151 begin

152 i f ( m a x t i c k i t e r )

153 begin

154 i f ( ope ra t i on == 1 ’ b0 )

155 begin

156 i f ( s h i f t r e g i o n f l a g == 2 ’ b00 )

157 se l mux 2 = 2 ’ b00 ;

158 e l s e i f ( s h i f t r e g i o n f l a g == 2 ’ b01 )

159 se l mux 2 = 2 ’ b01 ;


161 se l mux 2 = 2 ’ b01 ;

162 e l s e

163 se l mux 2 = 2 ’ b00 ;


165 end

166

167 e l s e

168 begin


170 se l mux 2 = 2 ’ b01 ;


172 se l mux 2 = 2 ’ b00 ;


174 se l mux 2 = 2 ’ b00 ;

175 e l s e

176 se l mux 2 = 2 ’ b01 ;


178 end

179 end

180

181 e l s e

182 se l mux 2 = cont var ;

183


185 s t a t e n e x t = es t7 ;

186 end

187

188 e s t7 :

189 begin

190 beg add subt = 1 ’ b1 ;

191 s t a t e n e x t = es t8 ;

192 end

193

194 e s t8 :

195 begin

196 i f ( ready add subt )

197 begin

198 i f ( m a x t i c k i t e r )

199 begin

200 i f ( ope ra t i on == 1 ’ b0 )

201 begin


202 i f ( s h i f t r e g i o n f l a g == 2 ’

b00 )

203 enab d f f Xn = 1 ’ b1

;

204 e l s e i f ( s h i f t r e g i o n f l a g

== 2 ’ b01 )

205 enab d f f Yn = 1 ’ b1

;


== 2 ’ b10 )

207 enab d f f Yn = 1 ’ b1

;

208 e l s e

209 enab d f f Xn = 1 ’ b1

;

210 end

211

212 e l s e

213 begin

214 i f ( s h i f t r e g i o n f l a g == 2 ’

b00 )

215 enab d f f Yn = 1 ’ b1

;


== 2 ’ b01 )

217 enab d f f Xn = 1 ’ b1

;


== 2 ’ b10 )

219 enab d f f Xn = 1 ’ b1

;

220 e l s e

221 enab d f f Yn = 1 ’ b1

;

222 end

223 end

224

225 e l s e

226 begin

227 i f ( m in t i ck va r )

228 enab d f f Xn = 1 ’ b1 ;

229 e l s e i f ( max t ick var )

230 enab d f f Zn = 1 ’ b1 ;

231 e l s e

232 enab d f f Yn = 1 ’ b1 ;

233 end

234 s t a t e n e x t = es t9 ;

235 end

236

237 e l s e

238 s t a t e n e x t = es t8 ;

239 end

92

240

241 e s t9 :

242 begin

243 ack add subt = 1 ’ b1 ;

244 i f ( m a x t i c k i t e r )

245 begin

246 s t a t e n e x t = es t10 ;

247 end

248 e l s e

249 begin

250 i f ( max t ick var )

251 begin

252 e n a b c o n t i t e r = 1 ’ b1 ;

253 s t a t e n e x t = es t3 ;

254 end

255

256 e l s e

257 begin


259 s t a t e n e x t = es t6 ;

260 end

261 end

262 end

263

264 e s t10 :

265 begin

266 i f ( ope ra t i on == 1 ’ b0 )

267 begin


269 se l mux 3 = 1 ’ b0 ;


271 se l mux 3 = 1 ’ b1 ;


273 se l mux 3 = 1 ’ b1 ;

274 e l s e

275 se l mux 3 = 1 ’ b0 ;


277 end

278

279 e l s e

280 begin


282 se l mux 3 = 1 ’ b1 ;


284 se l mux 3 = 1 ’ b0 ;


286 se l mux 3 = 1 ’ b0 ;

287 e l s e

288 se l mux 3 = 1 ’ b1 ;


290 end

291



293 s t a t e n e x t = es t11 ;

294 end

295

296 e s t11 :

297 begin

298 e n a b d f f 5 = 1 ’ b1 ;

299 s t a t e n e x t = es t12 ;

300 end

301

302 e s t12 :

303 begin

304 e n a b d f f o u t = 1 ’ b1 ;

305 s t a t e n e x t = es t13 ;

306 end

307

308 e s t13 :

309 begin

310 ready CORDIC = 1 ’ b1 ;

311 i f (ACK FSM CORDIC)

312 s t a t e n e x t = es t0 ;

313 e l s e

314 s t a t e n e x t = es t13 ;

315 end

316

317 d e f a u l t : s t a t e n e x t = es t0 ;

318 endcase

319 end

320 endmodule

Listing D.3: Script Verilog del contador de iteraciones.


2

3 module counter d #(parameter W=4)

4 (

5 input wire c lk ,

6 input wire r s t ,

7 input wire load ,

8 input wire enable ,

9 input wire [W−1:0 ] d ,

10 output wire max tick ,

11 output wire min t ick ,

12 output wire [W−1:0 ] q

13 ) ;

14 reg [W−1:0 ] count ;

15 always @( posedge clk , posedge r s t )

16 begin

17 i f ( r s t )

18 count <= 0 ;

19 e l s e i f ( enable )

20 begin

94

21 i f ( load )

22 begin

23 count <= d ;

24 end

25 e l s e

26 count <= count + 1 ’ b1 ;

27 end

28 end

29 a s s i g n q = count ;

30 a s s i g n max tick = ( count == 2∗∗W−1) ? 1 ’ b1 : 1 ’ b0 ;

31 a s s i g n min t i ck = ( count == 0) ? 1 ’ b1 : 1 ’ b0 ;

32 endmodule

Listing D.4: Script Verilog del contador de variables.


2

3 module counter up #(parameter W=4)

4 (

5 input wire c lk ,


7 input wire load ,

8 input wire enable ,

9 input wire [W−1:0 ] d ,

10 output wire max tick ,

11 output wire min t ick ,

12 output wire [W−1:0 ] q

13 ) ;

14 reg [W−1:0 ] count ;


16 begin

17 i f ( r s t )

18 count <= 0 ;


20 begin

21 i f ( load )

22 begin

23 count <= d ;

24 end

25 e l s e

26 count <= count + 1 ’ b1 ;

27 end

28 end

29 a s s i g n q = count ;

30 a s s i g n max tick = ( count == 2 ’ b10 ) ? 1 ’ b1 : 1 ’ b0 ;

31 a s s i g n min t i ck = ( count == 0) ? 1 ’ b1 : 1 ’ b0 ;

32 endmodule


Listing D.5: Script Verilog de un flip flop D.


2

3 module d f f e n # ( parameter W = 32)

4 (

5 input wire c lk , // system c lo ck

6 input wire r s t , // system r e s e t

7 input wire enable , // load s i g n a l

8 input wire [W−1:0 ] D, // input s i g n a l

9 output reg [W−1:0 ] Q // output s i g n a l

10 ) ;


12 begin

13 i f ( r s t )

14 Q <= 0 ;


16 Q <= D;

17 e l s e

18 Q <= Q;

19 end

20 endmodule

Listing D.6: Script Verilog de la implementacion de la LUT para la arquitectura de 32

bits.


2

3 module LUT ROM 32bits #(parameter W=32,N=3)

4 (


6 input wire [N−1:0 ] address ,


8 output reg [W−1:0 ] data out

9 ) ;

10 localparam ROM FILE=”/home/ j e f f r y q f /Dropbox/ Proyecto De Graduacion /

Proyecto De Graduacion 2 / Proyecto De Graduacion /Results Sim sincosCORDIC

/ Archivos pruebas / LUT sincos 32 . txt ” ;

11 reg [W−1:0 ] rom test [2∗∗N−1 : 0 ] ;

12 i n i t i a l

13 begin

14 $readmemh (ROM FILE, rom test , 0 , 2∗∗N−1) ;

15 end


18 data out = rom test [ address ] ;

19 end

20 endmodule

96

Listing D.7: Script Verilog de la implementacion de la LUT para la arquitectura de 64

bits.


2

3 module LUT ROM 64bits #(parameter W=64,N=3)

4 (


6 input wire [N−1:0 ] address ,



9 ) ;

10 loca lparam ROM FILE=”/home/ j e f f r y q f /Dropbox/ Proyecto De Graduacion /

Proyecto De Graduacion 2 / Proyecto De Graduacion /Results Sim sincosCORDIC

/ Archivos pruebas / LUT sincos 64 . txt ” ;

11 reg [W−1:0 ] rom test [2∗∗N−1 : 0 ] ;

12 i n i t i a l

13 begin

14 $readmemh (ROM FILE, rom test , 0 , 2∗∗N−1) ;

15 end


18 data out = rom test [ address ] ;

19 end

20 endmodule

Listing D.8: Script Verilog de un multiplexor de dos entradas.


2

3 module Mux 2x1 #(parameter W=32)

4 (


6 input wire s e l e c t ,

7 input wire [W−1:0 ] ch 0 ,




11 ) ;


14 case ( s e l e c t )

15 1 ’ b0 : data out = ch 0 ;

16 1 ’ b1 : data out = ch 1 ;

17 d e f a u l t : data out = ch 0 ;

18 endcase

19 end

20 endmodule


Listing D.9: Script Verilog de un multiplexor de tres entradas.


2

3 module Mux 3x1 b #(parameter W=32)

4 (


6 input wire [ 1 : 0 ] s e l e c t ,






12 ) ;



16 2 ’ b00 : data out <= ch 0 ;

17 2 ’ b01 : data out <= ch 1 ;

18 2 ’ b10 : data out <= ch 2 ;

19 d e f a u l t : data out <= ch 0 ;

20 endcase

21 end

22 endmodule

Listing D.10: Script Verilog del modulo que selecciona si se realiza una suma y resta.


2

3 module Op Select

4 (

5 input wire va r i ab l e ,

6 input wire s ign ,

7 output reg operat i on

8 ) ;


11 opera t ion = ˜( v a r i a b l e ˆ s i gn ) ;

12 end

13 endmodule

Listing D.11: Script Verilog del modulo inversor de signo del resultado.


2

3 module s i g n i n v e r t e r #(parameter W = 32)

4 (

5 input wire [W−1:0 ] data ,

6 input wire [ 1 : 0 ] s h i f t r e g i o n f l a g ,

7 input wire operat ion ,


9 ) ;

10 always@∗

98

11 begin

12 i f ( ope ra t i on == 1 ’ b0 ) // coseno

13 begin

14 i f ( s h i f t r e g i o n f l a g == 2 ’ b00 | | s h i f t r e g i o n f l a g == 2 ’ b11 ) //no

hay desplazamiento

15 begin

16 data out = data ;

17 end

18 e l s e

19 begin

20 i f ( ( s h i f t r e g i o n f l a g == 2 ’ b01 ) && ( data [W−1] == 1 ’ b0 ) )

21 begin

22 data out = {1 ’ b1 , data [W−2 : 0 ]} ;

23 end

24 e l s e i f ( ( s h i f t r e g i o n f l a g == 2 ’ b01 ) && ( data [W−1] == 1 ’ b1 ) )

25 begin

26 data out = {1 ’ b0 , data [W−2 : 0 ]} ;

27 end

28 e l s e

29 begin


31 end

32 end

33 end

34 e l s e // seno

35 begin

36 i f ( s h i f t r e g i o n f l a g == 2 ’ b00 | | s h i f t r e g i o n f l a g == 2 ’ b11 ) //no

hay desplazamiento

37 begin


39 end

40 e l s e

41 begin

42 i f ( ( s h i f t r e g i o n f l a g == 2 ’ b10 ) && ( data [W−1] == 1 ’ b0 ) )

43 begin

44 data out = {1 ’ b1 , data [W−2 : 0 ]} ;

45 end

46 e l s e i f ( ( s h i f t r e g i o n f l a g == 2 ’ b10 ) && ( data [W−1] == 1 ’ b1 ) )

47 begin

48 data out = {1 ’ b0 , data [W−2 : 0 ]} ;

49 end

50 e l s e

51 begin


53 end

54 end

55 end

56 end

57 endmodule


Listing D.12: Script Verilog de un restador de coma fija.


2

3 module Simple Subt #(parameter W=8,N=3) /∗#(W=11)∗/ // t a m o de l

exponente en 32 y 64 b i t s re spect ivamente

4 (

5 input wire [W−1:0 ] A,

6 input wire [N−1:0 ] B,

7 output wire [W−1:0 ] Y

8 ) ;

9 a s s i g n Y = A−B;

10 endmodule

Listing D.13: Script Verilog de la interface general de la FPU, que integra las operaciones

hasta el momento implementadas.


2

3 module FPU Interface #(parameter W = 64 , EW = 11 , SW = 52 , SWR = 55 , EWR =

6 , S Exp=12)

4 (


6 input wire c lk ,


8 input wire beg in opera t i on ,

9 input wire ack operat ion ,

10 input wire [ 2 : 0 ] operat ion ,

11 input wire [ 1 : 0 ] r e g i o n f l a g ,

12 input wire [W−1:0 ] Data 1 ,

13 // input wire [W−1:0 ] Data 2 ,

14 input wire [ 1 : 0 ] r mode ,


16 output wire o v e r f l o w f l a g ,

17 output wire unde r f l ow f l ag ,

18 output wire NaN flag ,

19 output wire operat ion ready ,

20 output wire [W−1:0 ] o p r e s u l t

21 ) ;

22 // S igna l d e c l a r a t i o n

23 wire beg fsm mult ;

24 wire beg fsm addsubt ;

25 wire beg f sm cord i c ;

26 wire beg add subt co rd i c ;

27 wire beg add subt ;

28 wire ack fsm mult ;

29 wire ack fsm addsubt ;

30 wire ack f sm co rd i c ;

31 wire ack add subt co rd i c ;

32 wire ack add subt ;

33 wire op mod add subt ;

34 wire op mod cordic ;

35 wire op addsubt cord i c ;

100

36 wire op addsubt ;

37 wire [W−1:0 ] add subt dataA ;

38 wire [W−1:0 ] add subt dataB ;

39 wire [W−1:0 ] add subt data1 ;

40 wire [W−1:0 ] add subt data2 ;

41 wire [W−1:0 ] r e s u l t a d d s u b t ;

42 wire ready add subt ;

43 wire r e a d y c o r d i c ;

44 wire ready mult ;

45 wire o v e r f l o w f l a g a d d s u b t ;

46 wire unde r f l ow f l ag addsubt ;

47 wire o v e r f l o w f l a g m u l t ;

48 wire unde r f l ow f l ag mu l t ;

49 wire [W−1:0 ] c o r d i c r e s u l t ;

50 wire [W−1:0 ] m u l t r e s u l t ;

51 wire [ 1 : 0 ] o p e r a t i o n r e g ;

52 wire [W−1:0 ] dataA , dataB ;

53 wire NaN reg ;

54 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

55 d f f e n # ( .W(2) ) o p e r a t i o n d f f

56 (


58 . r s t ( r s t ) , // system r e s e t

59 . enable (1 ’ b1 ) , // load s i g n a l

60 .D( opera t i on [ 2 : 1 ] ) , // input s i g n a l

61 .Q( o p e r a t i o n r e g ) // output s i g n a l

62 ) ;

63 d f f e n # ( .W(W) ) reg dataA

64 (




68 .D( Data 1 ) , // input s i g n a l

69 .Q( dataA ) // output s i g n a l

70 ) ;

71 d f f e n # ( .W(W) ) reg dataB

72 (




76 .D( Data 1 ) , // input s i g n a l

77 .Q( dataB ) // output s i g n a l

78 ) ;

79 generate

80 case (W)

81 32 :

82 begin

83 NaN mod 32 NaN flag 32

84 (

85 . ope ra t i on ( o p e r a t i o n r e g ) ,


86 . data1 ( dataA ) ,

87 . data2 ( dataB ) ,

88 . NaN flag ( NaN reg )

89 ) ;

90 end

91 64 :

92 begin


94 (


96 . data1 ( dataA ) ,

97 . data2 ( dataB ) ,


99 ) ;

100 end

101 d e f a u l t :

102 begin


104 (


106 . data1 ( dataA ) ,

107 . data2 ( dataB ) ,


109 ) ;

110 end

111 endcase

112 endgenerate

113 d f f e n # ( .W(1) ) NaN dff

114 (




118 .D( NaN reg ) , // input s i g n a l

119 .Q( NaN flag ) // output s i g n a l

120 ) ;

121 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

122 demux 1x3 demux beg op

123 (

124 . data ( beg in ope ra t i on ) ,

125 . s e l e c t ( opera t i on [ 2 : 1 ] ) ,

126 . ch1 ( beg fsm addsubt ) ,

127 . ch2 ( beg f sm cord i c ) ,

128 . ch3 ( beg fsm mult )

129 ) ;

130 demux 1x3 demux ack op

131 (

132 . data ( ack ope ra t i on ) ,


134 . ch1 ( ack fsm addsubt ) ,

135 . ch2 ( a ck f sm co rd i c ) ,

102

136 . ch3 ( ack fsm mult )

137 ) ;

138 deco op deco ope ra t i on

139 (

140 . ope ra t i on ( opera t i on [ 1 : 0 ] ) ,

141 . op mod add subt ( op mod add subt ) ,

142 . op mod cordic ( op mod cordic )

143 ) ;

144 Mux 2x1 #(.W(1) ) mux beg addsubt

145 (

146 . s e l e c t ( opera t i on [ 1 ] ) ,

147 . ch 0 ( beg fsm addsubt ) ,

148 . ch 1 ( beg add subt co rd i c ) ,

149 . data out ( beg add subt )

150 ) ;

151 Mux 2x1 #(.W(1) ) mux ack addsubt

152 (


154 . ch 0 ( ack fsm addsubt ) ,

155 . ch 1 ( ack add subt co rd i c ) ,

156 . data out ( ack add subt )

157 ) ;

158 Mux 2x1 #(.W(1) ) mux operat ion add cord ic

159 (


161 . ch 0 ( op mod add subt ) ,

162 . ch 1 ( op addsubt cord i c ) ,

163 . data out ( op addsubt )

164 ) ;

165 Mux 2x1 #(.W(W) ) mux data in1

166 (


168 . ch 0 ( Data 1 ) ,

169 . ch 1 ( add subt dataA ) ,

170 . data out ( add subt data1 )

171 ) ;

172 Mux 2x1 #(.W(W) ) mux data in2

173 (


175 . ch 0 ( Data 1 ) ,

176 . ch 1 ( add subt dataB ) ,

177 . data out ( add subt data2 )

178 ) ;

179 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

180 FPU Add Subtract Function #(.W(W) , .EW(EW) , .SW(SW) , .SWR(SWR) , .EWR(EWR)

) add subt module

181 (

182 . c l k ( c l k ) ,

183 . r s t ( r s t ) ,

184 . beg FSM( beg add subt ) ,


185 . rst FSM ( ack add subt ) ,

186 . Data X ( add subt data1 ) ,

187 . Data Y ( add subt data2 ) ,

188 . add subt ( op addsubt ) ,

189 . r mode ( r mode ) ,

190 . o v e r f l o w f l a g ( o v e r f l o w f l a g a d d s u b t ) ,

191 . u n d e r f l o w f l a g ( unde r f l ow f l ag addsubt ) ,

192 . ready ( ready add subt ) ,

193 . f i n a l r e s u l t i e e e ( r e s u l t a d d s u b t )

194 ) ;

195 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

196 CORDIC Arch #(.W(W) , .EW(EW) , .SW(SW) ) CORDIC SineCOsine

197 /∗#(parameter W = 64 , EW = 11 , SW = 52) //−− Double P r e c i s i o n ∗/198 (

199 . c l k ( c l k ) , // Re lo j de l s i s tema .

200 . r s t ( r s t ) , // S e a l de r e s e t de l s i s tema .

201 . b eg f sm cord i c ( beg f sm cord i c ) , // S e a l de i n i c i o de l a maquina de

es tados de l m d u l o CORDIC.

202 . a c k c o r d i c ( a ck f sm co rd i c ) , // S e a l de acknowledge proven iente

de otro m d u l o que i n d i c a que ha r e c i b i d o e l r e s u l t a d o de l modulo

CORDIC.

203 . ope ra t i on ( op mod cordic ) , // S e a l que i n d i c a s i se

r e a l i z a l a operac ion seno (1 ’ b1 ) o coseno (1 ’ b0 ) .

204 // . v i o l a t i o n f l a g ( ) ,

205 // . o v e r f l o w f l a g ( ) , // Bandera de over f l ow de l a operac ion

.

206 // . u n d e r f l o w f l a g ( ) , // Bandera de

underf low de l a operac ion .

207 // . NaN Flag ( ) ,

208 . da ta in ( Data 1 ) , // Dato de entrada , cont i ene e l angulo

que se desea c a l c u l a r en rad iane s .

209 . s h i f t r e g i o n f l a g ( r e g i o n f l a g ) , // S e a l que i n d i c a s i e l ngulo a

c a l c u l a r e s ta fue ra de l rango de c a l c u l o de l a lgor i tmo CORDIC.

210 . r eady add subt ( ready add subt ) , // S e a l que i n d i c a

que se ha r e a l i z a d o l a operac ion de suma/ r e s t a en punto f l o t a n t e .

211 . r e s u l t a d d s u b t ( r e s u l t a d d s u b t ) , // Dato de entrada , cont i ene

e l r e s u l t a d o de l m d u l o de suma/ r e s t a .

212 . r e a d y c o r d i c ( r e a d y c o r d i c ) , // S e a l de s a l i d a que i n d i c a

que se ha completado e l c a l c u l o de l seno / coseno .

213 . beg add subt ( beg add subt co rd i c ) , // S e a l de s a l i d a

que i n d i c a que se debe de i n i c i a r e l modulo de suma/ r e s t a .

214 . ack add subt ( ack add subt co rd i c ) , // S e a l que l e

i n d i c a a l modulo de suma/ r e s t a que se r e c i b i o e l r e s u l t a d o de e s t e

modulo correctamente .

215 . op add subt ( op addsubt cord i c ) , // S e a l hac ia e l

m d u l o de suma/ r e s t a que i n d i c a s i se va a r e a l i z a r una suma (1 ’ b0 ) o

una r e s t a (1 ’ b1 ) .

216 . add subt dataA ( add subt dataA ) , // Bus de datos hac ia e l

modulo de suma/ r e s t a con e l va l o r a l que se l e desea a p l i c a r dicha

operac ion .

104

217 . add subt dataB ( add subt dataB ) , // Bus de datos hac ia e l

modulo de suma/ r e s t a con e l va l o r a l que se l e desea a p l i c a r dicha

operac ion .

218 . data output ( c o r d i c r e s u l t ) // Bus de datos con e l va l o r f i n a l de l

angulo ca l cu l ado .

219 ) ;

220 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

221 FPU Mult ip l i cat ion Funct ion #(.W(W) , .W Exp(EW) , . W Sgf (SW) , . S Exp ( S Exp ) )

mu l t i p l f pu

222 (

223 . c l k ( c l k ) ,

224 . r s t ( r s t ) ,

225 . beg FSM( beg fsm mult ) ,

226 . rst FSM ( ack fsm mult ) ,

227 . Data MX( Data 1 ) ,

228 . Data MY( Data 1 ) ,

229 . round mode ( r mode ) ,

230 . o v e r f l o w f l a g ( o v e r f l o w f l a g m u l t ) ,

231 . u n d e r f l o w f l a g ( unde r f l ow f l ag mu l t ) ,

232 . r e a d y f l a g ( ready mult ) ,

233 . F i e e e r e s u l t ( m u l t r e s u l t )

234 ) ;

235 //

−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−

236 Mux 2x1 #(.W(1) ) over f l ow f l ag mux

237 (


239 . ch 0 ( o v e r f l o w f l a g a d d s u b t ) ,

240 . ch 1 ( o v e r f l o w f l a g m u l t ) ,

241 . data out ( o v e r f l o w f l a g )

242 ) ;

243 Mux 2x1 #(.W(1) ) under f low f lag mux

244 (


246 . ch 0 ( unde r f l ow f l ag addsubt ) ,

247 . ch 1 ( unde r f l ow f l ag mu l t ) ,

248 . data out ( u n d e r f l o w f l a g )

249 ) ;

250 Mux 3x1 b #(.W(1) ) mux ready op

251 (


253 . ch 0 ( ready add subt ) ,

254 . ch 1 ( r e a d y c o r d i c ) ,

255 . ch 2 ( ready mult ) ,

256 . data out ( ope ra t i on ready )

257 ) ;

258 Mux 3x1 b #(.W(W) ) mux resu l t op

259 (



261 . ch 0 ( r e s u l t a d d s u b t ) ,

262 . ch 1 ( c o r d i c r e s u l t ) ,

263 . ch 2 ( m u l t r e s u l t ) ,

264 . data out ( o p r e s u l t )

265 ) ;

266 endmodule

Listing D.14: Script Verilog del decodificador de operacion.


2

3 module deco op

4 (


6 output reg op mod add subt ,

7 output reg op mod cordic

8 ) ;


11 case ( operat i on )

12 2 ’ b00 :

13 begin

14 op mod add subt = 1 ’ b0 ;

15 op mod cordic = 1 ’ b0 ;

16 end

17 2 ’ b01 :

18 begin



21 end

22 2 ’ b10 :

23 begin



26 end

27 2 ’ b11 :

28 begin



31 end

32 d e f a u l t :

33 begin



36 end

37 endcase

38 end

39 endmodule

106

Listing D.15: Script Verilog de un demultiplexor de 3 salidas.


2

3 module demux 1x3

4 (

5 input wire data ,

6 input wire [ 1 : 0 ] s e l e c t ,

7 output reg ch1 ,

8 output reg ch2 ,

9 output reg ch3

10 ) ;



14 2 ’ b00 :

15 begin

16 ch1 = data ;

17 ch2 = 1 ’ b0 ;

18 ch3 = 1 ’ b0 ;

19 end

20 2 ’ b01 :

21 begin

22 ch1 = 1 ’ b0 ;

23 ch2 = data ;

24 ch3 = 1 ’ b0 ;

25 end

26 2 ’ b10 :

27 begin

28 ch1 = 1 ’ b0 ;

29 ch2 = 1 ’ b0 ;

30 ch3 = data ;

31 end

32 d e f a u l t :

33 begin

34 ch1 = 1 ’ b0 ;

35 ch2 = data ;

36 ch3 = 1 ’ b0 ;

37 end

38 endcase

39 end

40 endmodule

Listing D.16: Script Verilog del modulo de deteccion de resultado NaN para la arquitec-

tura de 32 bits.


2

3 module NaN mod 32

4 (


6 input wire [ 3 1 : 0 ] data1 ,



8 output reg NaN flag

9 ) ;



13 2 ’ b00 :

14 begin

15 i f ( ( data1 == 32 ’ h7f800000 ) && ( data2 == 32 ’ h7f800000 ) )

16 NaN flag = 1 ’ b1 ;

17 e l s e i f ( ( data1 == 32 ’ h f f800000 ) && ( data2 == 32 ’ h f f800000 ) )

18 NaN flag = 1 ’ b1 ;

19 e l s e i f ( ( data1 == 32 ’ h7f800000 ) && ( data2 == 32 ’ h f f800000 ) )

20 NaN flag = 1 ’ b1 ;

21 e l s e i f ( ( data1 == 32 ’ h f f800000 ) && ( data2 == 32 ’ h7f800000 ) )

22 NaN flag = 1 ’ b1 ;

23 e l s e

24 NaN flag = 1 ’ b0 ;

25 end

26 2 ’ b01 :

27 begin

28 i f ( data1 == 32 ’ h7f800000 )

29 NaN flag = 1 ’ b1 ;

30 e l s e i f ( data1 == 32 ’ h f f800000 )

31 NaN flag = 1 ’ b1 ;

32 e l s e

33 NaN flag = 1 ’ b0 ;

34 end

35 2 ’ b10 :

36 begin

37 i f ( ( data1 == 32 ’ h00000000 ) && ( data2 == 32 ’

h7f800000 ) )

38 NaN flag = 1 ’ b1 ;

39 e l s e i f ( ( data1 == 32 ’ h00000000 ) && ( data2 == 32 ’ h f f800000 ) )

40 NaN flag = 1 ’ b1 ;

41 e l s e i f ( ( data1 == 32 ’ h f f800000 ) && ( data2 == 32 ’ h00000000 ) )

42 NaN flag = 1 ’ b1 ;

43 e l s e i f ( ( data1 == 32 ’ h7f800000 ) && ( data2 == 32 ’ h00000000 ) )

44 NaN flag = 1 ’ b1 ;

45 e l s e

46 NaN flag = 1 ’ b0 ;

47 end

48 d e f a u l t :

49 NaN flag = 1 ’ b0 ;

50 endcase

51 end

52 endmodule

108

Listing D.17: Script Verilog del modulo de deteccion de resultado NaN para la arquitec-

tura de 64 bits.


2

3 module NaN mod 64

4 (




8 output reg NaN flag

9 ) ;



13 2 ’ b00 :

14 begin

15 i f ( ( data1 == 64 ’ h7f f0000000000000 ) && ( data2 == 64 ’

h7f f0000000000000 ) )

16 NaN flag = 1 ’ b1 ;

17 e l s e i f ( ( data1 == 64 ’ h f f f0000000000000 ) && ( data2 == 64 ’

h f f f0000000000000 ) )

18 NaN flag = 1 ’ b1 ;

19 e l s e i f ( ( data1 == 64 ’ h7f f0000000000000 ) && ( data2 == 64 ’

h f f f0000000000000 ) )

20 NaN flag = 1 ’ b1 ;


h7f f0000000000000 ) )

22 NaN flag = 1 ’ b1 ;

23 e l s e

24 NaN flag = 1 ’ b0 ;

25 end

26 2 ’ b01 :

27 begin

28 i f ( data1 == 64 ’ h7f f0000000000000 )

29 NaN flag = 1 ’ b1 ;

30 e l s e i f ( data1 == 64 ’ h f f f0000000000000 )

31 NaN flag = 1 ’ b1 ;

32 e l s e

33 NaN flag = 1 ’ b0 ;

34 end

35 2 ’ b10 :

36 begin

37 i f ( ( data1 == 64 ’ h0000000000000000 ) && ( data2 == 64 ’

h7f f0000000000000 ) )

38 NaN flag = 1 ’ b1 ;

39 e l s e i f ( ( data1 == 64 ’ h0000000000000000 ) && ( data2 == 64 ’

h f f f0000000000000 ) )

40 NaN flag = 1 ’ b1 ;


h0000000000000000 ) )

42 NaN flag = 1 ’ b1 ;


43 e l s e i f ( ( data1 == 64 ’ h7f f0000000000000 ) && ( data2 == 64 ’

h0000000000000000 ) )

44 NaN flag = 1 ’ b1 ;

45 e l s e

46 NaN flag = 1 ’ b0 ;

47 end

48 d e f a u l t :

49 NaN flag = 1 ’ b0 ;

50 endcase

51 end

52 endmodule

Disen126 no, implementacio19 on y mejoras de una unidad de ... · Informe de Proyecto de Graduaci...

Documents

Transcript of Disen126 no, implementacio19 on y mejoras de una unidad de ... · Informe de Proyecto de Graduaci...