10 views

Uploaded by Neha Happyalways

cordic implemantaion

- 2014-homework-002
- EC3sh_C
- German English Mat 00 Hym A
- apendices_OK.pdf
- Topic 4
- lesson1theunitcircle
- Ex 10 2 Fsc Part1 Ver3
- Trigonometric Functions (Kelompok 5)
- Projects
- Text for Impatient
- Chapter9 Trignometry 130411020844 Phpapp02
- Chapter1-25_9_12-morpheus
- Word serial architecture of CORDIC
- 04 Classes Premieres
- EngCalcPPC HeatX User Guide
- Trigo.docx
- Assignment 4
- Trigonometric Functions Assignment
- 07b_1MA0_2H_-_June_2013
- C# Console Programing Notes

You are on page 1of 7

author:

release:

cordic.v

Dale Drinkard

08/06/2008

brief:

First Quadrant CORDIC

This is a self contained, configurable CORDIC generator

The user can modify the `defines below to customize the code generation.

This code is for the first quadrant, but is easily extended to the full

circle by first doing a coarse rotation. For example, to compute the

arctan of -y/x, in the second quadrant, feed the cordic function y/x and

then add 90 degrees (or pi/2 if using radian mode) to the result. When

computing sin and cos of an angle, coarse rotate the angle into the first qu

adrant

by subtracting the appropriate number of 90 (or pi/2) increments to get the

angle in

the first quadrant, keep track of this value, feed the cordic the angle. Th

en

simply change the sign of the results based on this stored number.

To use the core comment/uncomment the `defines below. The user can change t

he number

of bits that represent the x,y, and theta values. The core can operate in e

ither radian

or degree mode.

**NOTE** Even though there are allowances for changeing many parameters of t

he code, it is

strongly advised that the user understand the CORDIC algorythm before monkey

ing with these

settings. By default, the core uses 16+sign (17 bit) numbers for x,y, and t

heta, and iterates 16

times in the algorythm. There are two arctan function tables,one for radian

and one for degree

mode. If more iterations or higher precision calculations are desired then

a new arctan table will

need to be computed.

The core will operate in one

of two modes:

ROTATE: In this mode the user supplies a X and Y cartesian vector and an an

gle. The

CORDIC rotator seeks to reduce the angle to zero by rotating the ve

ctor.

To compute the cos and sin of the angle, set the inputs as follows:

y_in = 0;

x_in = `CORDIC_1

theta_in = the input angle

on completion:

y_out = sin

x_out = cos

The input angle depends on whether you build in radian or degree mo

de

see the description of the `defines below.

VECTOR: In this mode the user supplies the tangent value in x and y and the

rotator

seeks to minimize the y value, thus computing the angle.

To compute the arctan set the inputs as follows

y_in and x_in such that y/x = the tangent value for which you wish

to find the angle

theta_in = 0;

on completion

theta_out = the angle

*/

/* data valid flag

The iterative CORDIC implementations take a predetermined number of clock cyc

les to complete

If the VALID_FLAG is defined the core instantiates a dvalid_in and dvalid_out

signal. This

signal makes no sense in the COMBINATORIAL mode.

*/

// `define VALID_FLAG

/* Angle mode

The CORDIC can work with the angle expressed in radians or degrees

Uncomment the appropriate `define below.

RADIAN_16 uses 16 bit values (+ sign bit for 17 bit accuracy). angle informat

ion

is in the format U(1,15) where bit 16 is the sign bit, bit 15 is the whole num

ber part

and bits [14:0] are the fractional parts.

DEGREE_8_8 uses U(8,8) + a sign bit where bit 16 = the sign bit, [15:8] = the

whole number part

and [7:0] = the fractional.

The user can define other formats by creating a new tanangle function

*/

// `define DEGREE_8_8

`define RADIAN_16

/* Bit accuracy for sin and cos

The X and Y values are computed using a `XY_BITS + sign bit accuracy. The for

mat is assumed to be U(1,15) + sign bit

However, the CORDIC algorythm really doesn't care.

*/

`define XY_BITS

16

The angle can be represented in either degree or radians. This define determi

nes the number of bits used to represent the

angle. Going to a higher number of bits would allow more iterations thus impr

oving accuracy. 16 bits is enough for

most applications.

*/

`define THETA_BITS 16

/* Iteration accuracy

This is the number of times the algorithm will iterate. For pipelined options

, this is the number of stages.

This number is <= the number of bits used in the angles

*/

`define ITERATIONS 16

`define ITERATION_BITS 4 // 2^ITERATION_BITS = ITERATIONS

/* Implementation options

The CORDIC core can be realized in one of three methods:

ITERATE: This option builds a single ROTATOR. The user provides the argument

s and gives the core ITERATIONS

clock cycles to get the result. A signal named init is instantiated

to load the input values. It uses the

least amount of LUTs

PIPELINE: This option can take a new input on every clock and gives results IT

ERATIONS clock cycles later. It uses the

most amount of LUTS.

COMBINATORIAL: This option gives a result in a single clock cycle at the expe

nse of very deep logic levels. The

combinatorial implementation runs at about 10 mhz while the it

erative ones run at about 125 in a

Lattice ECP2 device.

*/

//`define ITERATE

`define PIPELINE

//`define COMBINATORIAL

/* CORDIC function

The CORDIC core works in one of two methods: VECTOR and ROTATE.

VECTOR: This mode seeks to reduce the Y values and is used to compute an ang

le given a point.

Enter the sin and cos of the desired angle and the core calculates t

he angle. This

mode computes ARCTAN.

ROTATE: This mode seeks to reduce the angle. It can be used to compute the

sin and cos of a given angle

*/

//`define VECTOR

// computes the arctan and square root

`define ROTATE

// computes sin cos

/* CORDIC GAIN

The CORDIC algorithm has an associated gain that is:

CORDIC_gain = for (i=0;i<n;i++) An = An*SQRT(1+(1/2^2i)

This quickly converges to ~ 1.647 as i goes to infinity.

*** NOTE *** If you change the number representations

you will have to recompute these values.

*/

`define CORDIC_GAIN 17'd53955

`define CORDIC_1 17'd19896

//====================

// CORDIC inverse

`ifdef PIPELINE

`define GENERATE_LOOP

`endif

`ifdef COMBINATORIAL

`define GENERATE_LOOP

`endif

/* Signed shifter

This module does an arbitrary right shift to implement'

the 1/2^i function on signed numbers

*/

module signed_shifter (

input wire [`ITERATION_BITS-1:0] i,

input wire signed [`XY_BITS:0] D,

output reg signed [`XY_BITS:0] Q );

integer j;

always @ * begin

Q = D;

for(j=0;j<i;j=j+1) Q = (Q >> 1) | (D[`XY_BITS] << `XY_BITS);

end

endmodule

/* Rotator

This module is the heart of the CORDIC computer and implements the CORDIC algo

rithm.

Input values x_i, y_i, and z_i are micro computed based on the iteration step

and the arctan of that step. See the description of the CORDIC algorithm for

details.

*/

module rotator (

input wire clk,

input wire rst,

`ifdef ITERATE

input wire init,

input wire [`ITERATION_BITS:0] iteration,

input wire signed [`THETA_BITS:0] tangle,

`endif

input wire signed [`XY_BITS:0]

x_i,

input wire signed [`XY_BITS:0]

y_i,

input wire signed [`THETA_BITS:0] z_i,

output wire signed [`XY_BITS:0]

x_o,

output wire signed [`XY_BITS:0]

y_o,

output wire signed [`THETA_BITS:0] z_o

);

`ifdef GENERATE_LOOP

parameter integer iteration = 0;

parameter signed [`THETA_BITS:0] tangle = 0;

`endif

reg signed [`XY_BITS:0] y_1;

reg signed [`THETA_BITS:0] z_1;

wire signed [`XY_BITS:0] x_i_shifted;

wire signed [`XY_BITS:0] y_i_shifted;

signed_shifter x_shifter(iteration,x_i,x_i_shifted);

signed_shifter y_shifter(iteration,y_i,y_i_shifted);

`ifdef COMBINATORIAL

always @ *

`endif

`ifdef ITERATE

always @ (posedge clk)

`endif

`ifdef PIPELINE

always @ (posedge clk)

`endif

if (rst) begin

x_1 <= 0;

y_1 <= 0;

z_1 <= 0;

end else begin

`ifdef ITERATE

if (init) begin

x_1 <= x_i;

y_1 <= y_i;

z_1 <= z_i;

end else

`endif

`ifdef ROTATE

if (z_i < 0) begin

`endif

`ifdef VECTOR

if (y_i > 0) begin

`endif

x_1 <= x_i + y_i_shifted; //shifter(y_1,i); //(y_1

y_1 <= y_i - x_i_shifted; //shifter(x_1,i); //(x_1

z_1 <= z_i + tangle;

end else begin

x_1 <= x_i - y_i_shifted; //shifter(y_1,i); //(y_1

y_1 <= y_i + x_i_shifted; //shifter(x_1,i); //(x_1

z_1 <= z_i - tangle;

end

end

assign x_o = x_1;

assign y_o = y_1;

assign z_o = z_1;

endmodule

/*

CORDIC

*/

module cordic (

input wire clk,

input wire rst,

`ifdef ITERATE

input wire init,

`endif

input wire signed [`XY_BITS:0]

x_i,

input wire signed [`XY_BITS:0]

y_i,

input wire signed [`THETA_BITS:0] theta_i,

>> i);

>> i);

>> i);

>> i);

x_o,

output wire signed [`XY_BITS:0]

y_o,

output wire signed [`THETA_BITS:0] theta_o

`ifdef VALID_FLAG

,input wire valid_in, output wire valid_out

`endif

);

`ifdef RADIAN_16

/*

arctan table in radian format 16 bit + sign bit.

*/

function [`THETA_BITS:0] tanangle;

input [3:0] i;

begin

case (i)

4'b0000: tanangle = 17'd25735 ; // 1/1

4'b0001: tanangle = 17'd15192;

// 1/2

4'b0010: tanangle = 17'd8027;

// 1/4

4'b0011: tanangle = 17'd4075;

// 1/8

4'b0100: tanangle = 17'd2045;

// 1/16

4'b0101: tanangle = 17'd1024;

// 1/32

4'b0110: tanangle = 17'd512;

// 1/64

4'b0111: tanangle = 17'd256;

// 1/128

4'b1000: tanangle = 17'd128;

// 1/256

4'b1001: tanangle = 17'd64;

// 1/512

4'b1010: tanangle = 17'd32;

// 1/1024

4'b1011: tanangle = 17'd16;

// 1/2048

4'b1100: tanangle = 17'd8;

// 1/4096

4'b1101: tanangle = 17'd4;

// 1/8192

4'b1110: tanangle = 17'd2;

// 1/16k

4'b1111: tanangle = 17'd1;

// 1/32k

endcase

end

endfunction

`endif

`ifdef DEGREE_8_8

/*

arctan table in degree U(8,8) format 16 bits + sign bit

*/

function [`THETA_BITS:0] tanangle;

input [3:0] i;

begin

case (i)

0: tanangle = 17'd11520; // theta = 45.000000

1: tanangle = 17'd6800; // theta = 22.500000

2: tanangle = 17'd3593; // theta = 11.250000

3: tanangle = 17'd1824; // theta = 5.625000

4: tanangle = 17'd915;

// theta = 2.812500

5: tanangle = 17'd458;

// theta = 1.406250

6: tanangle = 17'd229;

// theta = 0.703125

7: tanangle = 17'd114;

// theta = 0.351562

8: tanangle = 17'd57;

// theta = 0.175781

9: tanangle = 17'd28;

// theta = 0.087891

10: tanangle = 17'd14;

// theta = 0.043945

11: tanangle = 17'd7;

// theta = 0.021973

12: tanangle = 17'd3;

// theta = 0.010986

13: tanangle = 17'd1;

// theta = 0.005493

14: tanangle = 17'd0;

// theta = 0.002747

endcase

end

endfunction

`endif

// theta = 0.001373

`ifdef GENERATE_LOOP

wire signed [`XY_BITS:0] x [`ITERATIONS-1:0];

wire signed [`XY_BITS:0] y [`ITERATIONS-1:0];

wire signed [`THETA_BITS:0] z [`ITERATIONS-1:0];

assign x[0] = x_i;

assign y[0] = y_i;

assign z[0] = theta_i;

assign x_o = x[`ITERATIONS-1];

assign y_o = y[`ITERATIONS-1];

assign theta_o = z[`ITERATIONS-1];

`endif // GENERATE_LOOP

`ifdef VALID_FLAG

wire [`ITERATIONS-1:0] v;

assign valid_out v[`ITERATIONS-1];

always @ (posedge clk or posedge rst)

if (rst) v <= 0;

else begin

v <= v << 1;

v[0] <= valid_in;

end

`endif

`ifdef GENERATE_LOOP

genvar i;

generate for(i=0;i<`ITERATIONS-1;i=i+1) begin

rotator U (clk,rst,x[i],y[i],z[i],x[i+1],y[i+1],z[i+1]);

defparam U.iteration = i;

defparam U.tangle = tanangle(i);

end

endgenerate

`endif

`ifdef ITERATE

reg [`ITERATION_BITS:0] iteration;

wire signed [`XY_BITS:0] x,y,z;

assign x = init ? x_i : x_o;

assign y = init ? y_i : y_o;

assign z = init ? theta_i : theta_o;

always @ (posedge clk or posedge init)

if (init) iteration <= 0;

else iteration <= iteration + 1;

rotator U (clk,rst,init,iteration,tanangle(iteration),x,y,z,x_o,y_o,theta_o);

`endif

endmodule

- 2014-homework-002Uploaded byeouahiau
- EC3sh_CUploaded byJosh Zngr
- German English Mat 00 Hym AUploaded byOsho Arun Love
- apendices_OK.pdfUploaded byluisorlandocass
- Topic 4Uploaded bymathankumarjkk
- lesson1theunitcircleUploaded byapi-242127878
- Ex 10 2 Fsc Part1 Ver3Uploaded byAbdul Basit Javed
- Trigonometric Functions (Kelompok 5)Uploaded byRyan
- ProjectsUploaded byAswinCvrn
- Text for ImpatientUploaded byser
- Chapter9 Trignometry 130411020844 Phpapp02Uploaded byLau Yong Hui
- Chapter1-25_9_12-morpheusUploaded byhauzhi
- Word serial architecture of CORDICUploaded byWarren Smith QC (Quantum Cryptanalyst)
- 04 Classes PremieresUploaded bypancho
- EngCalcPPC HeatX User GuideUploaded byKhurram Munir
- Trigo.docxUploaded byErikson Morales
- Assignment 4Uploaded byShawn Deol
- Trigonometric Functions AssignmentUploaded byMoataz El-tantawy
- 07b_1MA0_2H_-_June_2013Uploaded byAnonymous RnapGaSIZJ
- C# Console Programing NotesUploaded byYasir Ahmed Khan
- Teacher’s Resource Book 2Uploaded byNauman Iqbal
- Rpt Matematik Kssm t3 2019Uploaded bysyafiqahdaud
- Library FunctionUploaded byAmanat Khan
- Answers 7Uploaded byTancred Thomas
- Csec Mathematics January 2016Uploaded bynaomihg
- Synthesis of MechanismsUploaded byPrince Sethi
- Microsoft Word - Maths T Paper 2 ACS Mid ScemeUploaded bySK
- Mathematics (2013) May Paper 2.pdfUploaded byJewelle
- maths.pdfUploaded byJavier Berlanga
- 2010 Algebra II Trig Review 13.4-13.6Uploaded byAlice Dwyer

- AEMC3Uploaded byRodrigo Hernández
- 傅里叶变换及其应用（斯坦福大学）Uploaded byAnonymous mw6kqFg
- Inverse Hyperbolic FunctionsUploaded byFaizal Romadhi
- sensors-12-05134Uploaded bydeny
- Fourier IntegralsUploaded byHenry Limantono
- BIOM9621-Maths-Revision.pdfUploaded byMohd Hilmi Izaan
- Unit 4 Mathematics for Engineering TechniciansUploaded byAli Ibrahiem Atwa
- m820-sol-2011Uploaded byTom Davis
- Chapter 4 - TrigonometryUploaded byDamon Leong
- Ch02- Limits and ContinuityUploaded byArmandinho Cavero
- diUploaded bymasyuki1979
- A Brief Introduction To MathematicaUploaded byWanchai Ratchatasomboon
- Machine Brakes, Clutches, Flywheels,CouplingsUploaded byRamuVasa
- Pupil AnswersUploaded bySofiaaaar
- Complex Numbers ExercisesUploaded byVíctor de la Cruz
- Maths QP Ans CET-2013Uploaded bypacesoft321
- TrigonometryUploaded byAvi Haf
- Tutorial.math.Lamar.edu PDF Trig Cheat Sheet ReducedUploaded byAnonymous vyXcR9
- Chapter 15 I Trigonometry II ENRICHUploaded byjuriah binti ibrahim
- Angle Rotations GSLIBUploaded bysoloserj
- SOL. Fisica Halliday Resnick Krane 5ed Vol2 206 216Uploaded byCristian Martínez
- Physics of Light and Optics.pdfUploaded byPiyushBose
- Mathematical and Scientific SymbolsUploaded byq
- Active Calculus Activities Ch 1-4 (v.12.30.13)Uploaded byaspendos69
- Keep 213Uploaded byanurag sawarn
- bkc19.pdfUploaded byrohitrgt4u
- A2AS MATH PP January 2008 as Mark Scheme 3691 (2)Uploaded byCora Doran
- How to Simplify Trig ExpressionsUploaded bytutorciecle123
- TrigonometryUploaded byelsteph
- W49 Revision Exercise AM SPM MonUploaded byBid Hassan