CORDIC算法——Verilog

最新推荐文章于 2023-11-02 10:21:29 发布
最新推荐文章于 2023-11-02 10:21:29 发布
阅读量2.2k 收藏 39
点赞数 4
分类专栏： verilog
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35608277/article/details/105461691
版权

CORIDC 技术并不是什么新鲜的东西。 事实上它可以追溯到 1957 年由 J. Volder 发表的一篇文章。 在上个世纪五十年代， 在大型实际的计算机中的实行移位相加受到了当时技术上的限制， 所以使用 CORDIC 变得非常必要。 到了七十年代， Hewlett Packard 和其他公司出产了手持计算器 , 许多计算器使用一个内部 CORDIC 单元来
计算所有的三角函数 ( 了解这件事的人们一定还记得，那时求一个角度的正切值需要延迟大约 1 秒中 )。
二十世纪八十年代，随着高速度乘法器与带有大存储量的通用处理器的出现， CORDIC 算法变得无关紧要了。
然而在二十一世纪的今天， 对于 FPGA 来说， CORDIC 一定是在 DSP 应用中 ( 诸如 多输入多输出 （ MIMO）,波束形成以及其他自适应系统 ) 计算三角函数的备选技术

ref
https://blog.csdn.net/qq_39210023/article/details/77456031

一、CORDIC的基本原理介绍

CORDIC算法是一个“化繁为简”的算法，将许多复杂的运算转化为一种“仅需要移位和加法”的迭代操作。CORDIC算法有旋转和向量两个模式，分别可以在圆坐标系、线性坐标系和双曲线坐标系使用，从而可以演算出8种运算，而结合这8种运算也可以衍生出其他许多运算。

问题情景

当已知一个点P1的坐标，并已知该点P1旋转的角度θ，则可以根据上述公式求得目标点P2的坐标。然后，麻烦来了，我们需要用FPGA去执行上述运算操作，而FPGA的Verilog语言根本不支持三角函数运算。因此，我们需要对上述式子进行简化操作，将复杂的运算操作转换为一种单一的“迭代位移”算法。那么，接下来我们介绍优化算法部分。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述


module Cordic_Test
(
	CLK_50M,RST_N,
	Phase,
	Sin,Cos,Error
);

input 						CLK_50M;
input 						RST_N;
input 		[31:0] 		Phase;
output		[31:0] 		Sin;
output		[31:0] 		Cos;
output		[31:0] 		Error;

`define rot0  32'd2949120    	//45бу*2^16
`define rot1  32'd1740992    	//26.5651бу*2^16
`define rot2  32'd919872    	//14.0362бу*2^16
`define rot3  32'd466944    	//7.1250бу*2^16
`define rot4  32'd234368    	//3.5763бу*2^16
`define rot5  32'd117312    	//1.7899бу*2^16
`define rot6  32'd58688    	//0.8952бу*2^16
`define rot7  32'd29312    	//0.4476бу*2^16
`define rot8  32'd14656    	//0.2238бу*2^16
`define rot9  32'd7360    		//0.1119бу*2^16
`define rot10 32'd3648    		//0.0560бу*2^16
`define rot11 32'd1856			//0.0280бу*2^16
`define rot12 32'd896    		//0.0140бу*2^16
`define rot13 32'd448    		//0.0070бу*2^16
`define rot14 32'd256    		//0.0035бу*2^16
`define rot15 32'd128    		//0.0018бу*2^16

parameter Pipeline = 16;
parameter K = 32'h09b74;	//K=0.607253*2^16,32'h09b74,

reg signed 	[31:0] 		Sin;
reg signed 	[31:0] 		Cos;
reg signed 	[31:0] 		Error;
reg signed 	[31:0] 		x0=0,y0=0,z0=0;
reg signed 	[31:0] 		x1=0,y1=0,z1=0;
reg signed 	[31:0] 		x2=0,y2=0,z2=0;
reg signed 	[31:0] 		x3=0,y3=0,z3=0;
reg signed 	[31:0] 		x4=0,y4=0,z4=0;
reg signed 	[31:0] 		x5=0,y5=0,z5=0;
reg signed 	[31:0] 		x6=0,y6=0,z6=0;
reg signed 	[31:0] 		x7=0,y7=0,z7=0;
reg signed 	[31:0] 		x8=0,y8=0,z8=0;
reg signed 	[31:0] 		x9=0,y9=0,z9=0;
reg signed 	[31:0] 		x10=0,y10=0,z10=0;
reg signed 	[31:0] 		x11=0,y11=0,z11=0;
reg signed 	[31:0] 		x12=0,y12=0,z12=0;
reg signed 	[31:0] 		x13=0,y13=0,z13=0;
reg signed 	[31:0] 		x14=0,y14=0,z14=0;
reg signed 	[31:0] 		x15=0,y15=0,z15=0;
reg signed 	[31:0] 		x16=0,y16=0,z16=0;
reg 			[ 1:0] 		Quadrant [Pipeline:0];

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x0 <= 1'b0; 						
		y0 <= 1'b0;
		z0 <= 1'b0;
	end
	else
	begin
		x0 <= K;
		y0 <= 32'd0;
		z0 <= Phase[15:0] << 16;
	end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x1 <= 1'b0; 						
		y1 <= 1'b0;
		z1 <= 1'b0;
	end
	else if(z0[31])
	begin
      x1 <= x0 + y0;
      y1 <= y0 - x0;
      z1 <= z0 + `rot0;
	end
	else
	begin
      x1 <= x0 - y0;
      y1 <= y0 + x0;
      z1 <= z0 - `rot0;
	end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x2 <= 1'b0; 						
		y2 <= 1'b0;
		z2 <= 1'b0;
	end
	else if(z1[31])
   begin
        x2 <= x1 + (y1 >>> 1);
        y2 <= y1 - (x1 >>> 1);
        z2 <= z1 + `rot1;
   end
   else
   begin
       x2 <= x1 - (y1 >>> 1);
       y2 <= y1 + (x1 >>> 1);
       z2 <= z1 - `rot1;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x3 <= 1'b0; 						
		y3 <= 1'b0;
		z3 <= 1'b0;
	end
	else if(z2[31])
   begin
       x3 <= x2 + (y2 >>> 2);
       y3 <= y2 - (x2 >>> 2);
       z3 <= z2 + `rot2;
   end
   else
   begin
       x3 <= x2 - (y2 >>> 2);
       y3 <= y2 + (x2 >>> 2);
       z3 <= z2 - `rot2;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x4 <= 1'b0; 						
		y4 <= 1'b0;
		z4 <= 1'b0;
	end
	else if(z3[31])
   begin
       x4 <= x3 + (y3 >>> 3);
       y4 <= y3 - (x3 >>> 3);
       z4 <= z3 + `rot3;
   end
   else
   begin
       x4 <= x3 - (y3 >>> 3);
       y4 <= y3 + (x3 >>> 3);
       z4 <= z3 - `rot3;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x5 <= 1'b0; 						
		y5 <= 1'b0;
		z5 <= 1'b0;
	end
	else if(z4[31])
   begin
       x5 <= x4 + (y4 >>> 4);
       y5 <= y4 - (x4 >>> 4);
       z5 <= z4 + `rot4;
   end
   else
   begin
       x5 <= x4 - (y4 >>> 4);
       y5 <= y4 + (x4 >>> 4);
       z5 <= z4 - `rot4;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x6 <= 1'b0; 						
		y6 <= 1'b0;
		z6 <= 1'b0;
	end
	else if(z5[31])
   begin
       x6 <= x5 + (y5 >>> 5);
       y6 <= y5 - (x5 >>> 5);
       z6 <= z5 + `rot5;
   end
   else
   begin
       x6 <= x5 - (y5 >>> 5);
       y6 <= y5 + (x5 >>> 5);
       z6 <= z5 - `rot5;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x7 <= 1'b0; 						
		y7 <= 1'b0;
		z7 <= 1'b0;
	end
	else if(z6[31])
   begin
       x7 <= x6 + (y6 >>> 6);
       y7 <= y6 - (x6 >>> 6);
       z7 <= z6 + `rot6;
   end
   else
   begin
       x7 <= x6 - (y6 >>> 6);
       y7 <= y6 + (x6 >>> 6);
       z7 <= z6 - `rot6;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x8 <= 1'b0; 						
		y8 <= 1'b0;
		z8 <= 1'b0;
	end
	else if(z7[31])
   begin
       x8 <= x7 + (y7 >>> 7);
       y8 <= y7 - (x7 >>> 7);
       z8 <= z7 + `rot7;
   end
   else
   begin
       x8 <= x7 - (y7 >>> 7);
       y8 <= y7 + (x7 >>> 7);
       z8 <= z7 - `rot7;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x9 <= 1'b0; 						
		y9 <= 1'b0;
		z9 <= 1'b0;
	end
	else if(z8[31])
   begin
       x9 <= x8 + (y8 >>> 8);
       y9 <= y8 - (x8 >>> 8);
       z9 <= z8 + `rot8;
   end
   else
   begin
       x9 <= x8 - (y8 >>> 8);
       y9 <= y8 + (x8 >>> 8);
       z9 <= z8 - `rot8;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x10 <= 1'b0; 						
		y10 <= 1'b0;
		z10 <= 1'b0;
	end
	else if(z9[31])
   begin
       x10 <= x9 + (y9 >>> 9);
       y10 <= y9 - (x9 >>> 9);
       z10 <= z9 + `rot9;
   end
   else
   begin
       x10 <= x9 - (y9 >>> 9);
       y10 <= y9 + (x9 >>> 9);
       z10 <= z9 - `rot9;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x11 <= 1'b0; 						
		y11 <= 1'b0;
		z11 <= 1'b0;
	end
	else if(z10[31])
   begin
       x11 <= x10 + (y10 >>> 10);
       y11 <= y10 - (x10 >>> 10);
       z11 <= z10 + `rot10;
   end
   else
   begin
       x11 <= x10 - (y10 >>> 10);
       y11 <= y10 + (x10 >>> 10);
       z11 <= z10 - `rot10;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x12 <= 1'b0; 						
		y12 <= 1'b0;
		z12 <= 1'b0;
	end
	else if(z11[31])
   begin
       x12 <= x11 + (y11 >>> 11);
       y12 <= y11 - (x11 >>> 11);
       z12 <= z11 + `rot11;
   end
   else
   begin
       x12 <= x11 - (y11 >>> 11);
       y12 <= y11 + (x11 >>> 11);
       z12 <= z11 - `rot11;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x13 <= 1'b0; 						
		y13 <= 1'b0;
		z13 <= 1'b0;
	end
	else if(z12[31])
   begin
       x13 <= x12 + (y12 >>> 12);
       y13 <= y12 - (x12 >>> 12);
       z13 <= z12 + `rot12;
   end
   else
   begin
       x13 <= x12 - (y12 >>> 12);
       y13 <= y12 + (x12 >>> 12);
       z13 <= z12 - `rot12;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x14 <= 1'b0; 						
		y14 <= 1'b0;
		z14 <= 1'b0;
	end
	else if(z13[31])
   begin
       x14 <= x13 + (y13 >>> 13);
       y14 <= y13 - (x13 >>> 13);
       z14 <= z13 + `rot13;
   end
   else
   begin
       x14 <= x13 - (y13 >>> 13);
       y14 <= y13 + (x13 >>> 13);
       z14 <= z13 - `rot13;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x15 <= 1'b0; 						
		y15 <= 1'b0;
		z15 <= 1'b0;
	end
	else if(z14[31])
   begin
       x15 <= x14 + (y14 >>> 14);
       y15 <= y14 - (x14 >>> 14);
       z15 <= z14 + `rot14;
   end
   else
   begin
       x15 <= x14 - (y14 >>> 14);
       y15 <= y14 + (x14 >>> 14);
       z15 <= z14 - `rot14;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		x16 <= 1'b0; 						
		y16 <= 1'b0;
		z16 <= 1'b0;
	end
	else if(z15[31])
   begin
       x16 <= x15 + (y15 >>> 15);
       y16 <= y15 - (x15 >>> 15);
       z16 <= z15 + `rot15;
   end
   else
   begin
       x16 <= x15 - (y15 >>> 15);
       y16 <= y15 + (x15 >>> 15);
       z16 <= z15 - `rot15;
   end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		Quadrant[0] <= 1'b0;
		Quadrant[1] <= 1'b0;
		Quadrant[2] <= 1'b0;
		Quadrant[3] <= 1'b0;
		Quadrant[4] <= 1'b0;
		Quadrant[5] <= 1'b0;
		Quadrant[6] <= 1'b0;
		Quadrant[7] <= 1'b0;
		Quadrant[8] <= 1'b0;
		Quadrant[9] <= 1'b0;
		Quadrant[10] <= 1'b0;
		Quadrant[11] <= 1'b0;
		Quadrant[12] <= 1'b0;
		Quadrant[13] <= 1'b0;
		Quadrant[14] <= 1'b0;
		Quadrant[15] <= 1'b0;
		Quadrant[16] <= 1'b0;
	end
	else
	begin
		Quadrant[0] <= Phase[17:16];
		Quadrant[1] <= Quadrant[0];
		Quadrant[2] <= Quadrant[1];
		Quadrant[3] <= Quadrant[2];
		Quadrant[4] <= Quadrant[3];
		Quadrant[5] <= Quadrant[4];
		Quadrant[6] <= Quadrant[5];
		Quadrant[7] <= Quadrant[6];
		Quadrant[8] <= Quadrant[7];
		Quadrant[9] <= Quadrant[8];
		Quadrant[10] <= Quadrant[9];
		Quadrant[11] <= Quadrant[10];
		Quadrant[12] <= Quadrant[11];
		Quadrant[13] <= Quadrant[12];
		Quadrant[14] <= Quadrant[13];
		Quadrant[15] <= Quadrant[14];
		Quadrant[16] <= Quadrant[15];
	end
end

always @ (posedge CLK_50M or negedge RST_N)
begin
	if(!RST_N)
	begin
		Cos <= 1'b0;
		Sin <= 1'b0;
		Error <= 1'b0;
	end
	else
	begin
		Error <= z16;
		case(Quadrant[16])
			2'b00: //if the Phase is in first Quadrant,the Sin(X)=Sin(A),Cos(X)=Cos(A)
				begin
					Cos <= x16;
					Sin <= y16;
				end
			2'b01: //if the Phase is in second Quadrant,the Sin(X)=Sin(A+90)=CosA,Cos(X)=Cos(A+90)=-SinA
				begin
					Cos <= ~(y16) + 1'b1;//-Sin
					Sin <= x16;//Cos
				end
			2'b10: //if the Phase is in third Quadrant,the Sin(X)=Sin(A+180)=-SinA,Cos(X)=Cos(A+180)=-CosA
				begin
					Cos <= ~(x16) + 1'b1;//-Cos
					Sin <= ~(y16) + 1'b1;//-Sin
				end
			2'b11: //if the Phase is in forth Quadrant,the Sin(X)=Sin(A+270)=-CosA,Cos(X)=Cos(A+270)=SinA
				begin
					Cos <= y16;//Sin
					Sin <= ~(x16) + 1'b1;//-Cos
				end
		endcase
	end
end

endmodule

ref
https://wenku.baidu.com/view/6c623aa8910ef12d2bf9e732.html

rrr2
关注
专栏目录
基于FPGA的CORDIC算法实现——Verilog版
善良の一休君的博客
08-21 6万+
目前，学习与开发FPGA的程序员们大多使用的是Verilog HDL语言（以下简称为Verilog），关于Verilog的诸多优点一休哥就不多介绍了，在此，我们将重点放在Verilog的运算操作上。 我们都知道，在Verilog中，运算一般分为逻辑运算（与或非等）与算术运算（加减乘除等）。而在一开始学习Verilog时，老司机一定会提醒我们，“切记，千万别用‘/’除、‘%’取模（有的也叫取余）和‘
基于FPGA的cordic算法的verilog初步实现
kebu12345678的博客
06-04 763
　最近在看cordic算法，由于还不会使用matlab，真是痛苦，一系列的笔算才大概明白了这个算法是怎么回事。于是尝试用verilog来实现。用verilog实现之前先参考软件的程序，于是先看了此博文http://blog.csdn.net/liyuanbhu/article/details/8458769 也不截图了，因为怕图形被其他博客网站检测到后屏蔽图片，造成此博文无法正常阅读。阅读此博文，...
cordic算法原理及verilog实现
热门推荐
u012094957的专栏
06-07 1万+
cordic算法原理及verilog实现 算法原理 由此我们可以推出，当(x0,y0)与(x1,y1)的夹角为Θ时，满足如下关系： 由此可得，当(x1,y1)长度为1时，，当根据坐标旋转法旋转Θ角度后，坐标点变为(1,0)。因此，根据cordic算法求就是将初始线段旋转至(1,0)后，所得的(x,y)的值。 下面，我们将这些旋转步骤细化，看看每一步是如何工作的。 假设第n次旋
FPGA算法学习(1) -- Cordic（Verilog实现）
weixin_30394251的博客
07-01 942
上两篇博文Cordic算法——圆周系统之旋转模式、Cordic算法——圆周系统之向量模式做了理论分析和实现，但是所用到的变量依然是浮点型，而cordic真正的用处是基于FPGA等只能处理定点的平台。只需将满足精度的浮点数，放大2^n倍，取整，再进行处理。 1. 旋转模式 假设要通过FPGA计算极坐标（55.6767°,1）的直角坐标。首先，角度值为浮点数，需要进行放大处理，放大10000倍。则预设...
CORDIC算法原理详解及其Verilog实现
Rye_Wh1skey的博客
07-06 7583
CORDIC算法原理详解及其Verilog实现CORDIC简介算法描述CORDIC方法算法实现1.已知坐标(x,y)，求其向量对应的相角θ（反正切）和模值\color{#F00}{1.已知坐标(x,y)，求其向量对应的相角θ（反正切）和模值}1.已知坐标(x,y)，求其向量对应的相角θ（反正切）和模值2.已知角度θ，求正弦sinθ和余弦cosθ\color{#F00}{2.已知角度θ，求正弦sinθ和余弦cosθ}2.已知角度θ，求正弦sinθ和余弦cosθ CORDIC简介 CORDIC（Coordina
cordic算法（verilog）
05-12
从opencores上得来得cordic算法程序，有流水线和迭代两种方法，用宏定义写得，代码很有参考价值。
基于Verilog的Cordic算法实现
baidu_34971492的博客
08-12 4466
任何适合产品实现的算法，都是将简易实现作为第一目标。CORDIC算法是建立在适应性滤波器、FFT、解调器等众多应用基础上计算超越函数的方法。其核心思想是二分逐次逼近。CORDIC（...
CORDIC算法Verilog实现，带testbench
07-21
用Verilog实现CORDIC，功能比Xilinx提供的更完善。全并行结构，可计算sin和cos函数
verilog实现cordic算法圆坐标的向量模式
最新发布
05-07
压缩包内的两个文件——`CORDIC_V.v`和`cordic_v_test.v`——分别代表了CORDIC算法的核心模块实现和测试平台。`CORDIC_V.v`包含了CORDIC算法的Verilog代码，其中会定义必要的寄存器、计数器和逻辑门来实现坐标旋转。...
基于CORDIC算法的正余弦信号发生器（verilog代码实现）
02-24
《基于CORDIC算法的正余弦信号发生器——Verilog代码实现详解》 在数字信号处理领域，正余弦信号发生器是一种常见的模块，广泛应用于通信、测试与测量以及信号合成等多个方面。其中，CORDIC（坐标旋转数字计算机）...
verilog的cordic算法实现
04-18
1.基于FPGA的cordic算法程序，输出IQ信号的幅度及相位 2.精度较高，相位精度为2/9000，幅度精度为1/1000。其中相伴扩大了100倍，幅度扩大了1.6倍。
cordic算法verilog实现
04-16
cordic算法的verilog语言实现，包含简单版和复杂版两个doc文档，简单版亲测EP2C8Q208芯片成功
三角函数的Verilog代码实现
01-24
三角函数sin，cos等，用Verilog代码实现
cordic算法的Verilog实现程序
10-19
FPGA应用，Verilog语言实现cordic算法，包括向量式和旋转式另种模式
cordic算法反正切c语言,Cordic 算法之 反正切
weixin_42504327的博客
05-23 2891
在通信的算法中，常采用Cordic算法之一，知道角度产生正交的的正弦余弦，或者知道正弦和余弦求角度，求反正切。1. 求正弦和余弦值。方法：旋转角度，得到正弦余弦值； 再旋转角度，到达下一个正弦余弦值；直到旋转的角度趋近于 0 ，不能再进行旋转。把每次旋转的坐标的x,Y轴的值各自相加，即得到为该角度的正弦和余弦值。2 .求反正切:Angle = artan(y/x)。方法： 及给定x,y 的坐标...
Cordic算法的FPGA实现——cordic实现sqrt和atan计算的定点化以及FPGA实现
gzy0506的博客
02-04 7821
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 Cordic算法的FPGA实现——cordic实现sqrt和atan计算的定点化以及FPGA实现前言matlab定点化仿真verilog实现 前言 要用verilog实现Cordic算法，首选需要在matlab上实现定点化仿真。 因为该定点化操作比较简单，直接通过程序就可以直接理解了，这里就不多说了，直接看程序 matlab定点化仿真 1、atan_table要进行定点化，我们将1rad表示为2^29 进行对应。这样原来的atan_tab
Cordic算法——verilog实现
IT荻的博客
08-28 5060
Cordic算法——verilog实现 上两篇博文做了理论分析和实现，但是所用到的变量依然是浮点型，而cordic真正的用处是基于FPGA等只能处理定点的平台。只需将满足精度的浮点数，放大2^n倍，取整，再进行处理。 旋转模式 假设要通过FPGA计算极坐标（55.6767°,1）的直角坐标。首先，角度值为浮点数，需要进行放大处理，放大10000倍。则预设的旋转角度同样要放大10000倍。实现伪旋转
FPGA Verilog Cordic算法实现三角函数计算，可计算sin cos arctan，精度达到，10e-5，有完整资料说明
YQQyLQakGe的博客
11-02 2548
该工程包含了Cordic算法模块的Verilog代码和测试文件，同时也提供了详细的资料说明，包括算法原理、模块设计和使用方法等。在未来的工程设计和科研应用中，Cordic算法在FPGA上的实现将具有广泛的应用前景。FPGA在近年来得到越来越广泛的应用，针对三角函数计算的需求，本文提出了一种基于Cordic算法的实现方式。同时，Verilog语言作为FPGA的硬件描述语言，也为Cordic算法在FPGA上的实现提供了很好的支持。Cordic算法是一种迭代算法，主要用于计算三角函数的值。
cordic算法的verilog实现
06-28
Cordic算法的Verilog实现是一种数字信号处理技术，用于计算三角函数、指数函数、对数函数等数学函数。它可以在FPGA、ASIC等数字电路中实现高速、低功耗的计算。Cordic算法的Verilog实现需要设计一个模块，包括输入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值