关于FPGA中cordic算法的设计与关键细节

最新推荐文章于 2024-11-12 16:41:55 发布
最新推荐文章于 2024-11-12 16:41:55 发布
阅读量1.3k 收藏 16
点赞数 6
文章标签： fpga 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_43489770/article/details/88856823
版权

关于FPGA中cordic算法的设计与关键细节

一 codic算法核心内涵

codic 算法是一种旋转变换算法，通过若干次迭代，使横坐标值平方趋于(（x ^2 )
+(y^2))纵坐标y轴趋于零，z轴角度趋于原直角坐标（x,y）角度值。其可进行任意两点间距离计算，直角坐标到坐标转换，应用方面包括图像边缘灰度值获取等,可在非常大程度上减少浮点运算导致的资源消耗，在硬件环境下应用广泛。
二 算法原理
初始坐标值（x,y）进行若干次迭代运算使y趋于0，先假设初始坐标值[Xi,Yi,Zi],旋转后坐标值[Xj,Yj,Zj],Z表示角度，P值为旋转过程中的增益补偿量，一般取值为0.6072，旋转公式如下
[Xj,Yj,Zj]=[P(XiXi +YiYi)^(1/2), 0 , Zi+arctan(Yi/Xi) ],及经过多次旋转迭代最终旋转到x轴，
旋转角度为arctan(Yi/Xi),迭代公式为Xn+1=Xn-AnYn
Yn+1=Yn+AnXn
Zn+1=Zn-arctan(2负n次方)
An是Sn乘以2的负n次方，Sn通过Y决定，为使Y趋于零，当Y大于零时，Sn=-1,当Y小于零
Sn=1。
由于角度值一般情况下为小数，fpga中一般需对其做整形转换，fpga中一般迭代次数达到15次即可，归一化系数设置为2的20次方，定义360为2的20次方，1rad值为166886.053，在fpga中通过建立查找表的方式进行迭代运算，其值误差随输入数据增大而减小。
三 fpga电路设计
分为四大模块，预处理模块，单次运算迭代模块，核心处理模块，后续处理模块
1 预处理模块
首先对输入值取绝对值，使其位于第一象限，后对X,Y进行变换使X大于Y，位于1/4（0~45度）象限，代码如下

// An highlighted block
`timescale 1ps/1ps
module cordic_pre(
	clk,
	rst_n,
	din_valid,
	din_x,
	din_y,
	dout_x,
	dout_y,
	din_info,
	dout_valid
	);
	parameter DW=16;
	parameter latency=2;
	input clk;
	input rst_n;
	input din_valid;
	input [DW-1:0]din_x;
	input [DW-1:0]din_y;
	output reg [DW-1:0]dout_x;
	output reg [DW-1:0]dout_y;
	output reg [2:0]din_info;
	output dout_valid;
	reg [latency-1:0]din_valid_r;
	reg [DW-1:0]abs_x;
	reg [DW-1:0]abs_y;
	wire [DW-1:0]x_swap;
	wire [DW-1:0]y_swap;
	wire swap;
	reg x_signed,y_signed;
	function [DW-1:0]abs;
		input [DW-1:0]data;
			if(data[DW-1]==1'b1)
				abs=1'b1+(~data);
			else
				abs=data;
			endfunction
	always@(posedge clk or negedge rst_n)
	begin
		if(!rst_n)
			din_valid_r<={latency{1'b0}};
		else
		begin
			din_valid_r<={din_valid_r[latency-2:0],din_valid};
		end
	end
	assign x_swap=(abs_y>abs_x)?abs_y:abs_x;
	assign y_swap=(abs_y>abs_x)?abs_x:abs_y;
	assign swap=(abs_y>abs_x)?1'b1:1'b0;
	always@(posedge clk or negedge rst_n)
	begin
		if(!rst_n)
		begin
			x_signed<=1'b0;
			abs_x<={DW{1'b0}};
			y_signed<=1'b0;
			abs_y<={DW{1'b0}};
		end
		else
		begin
			abs_x<=#1 (abs(din_x));
			x_signed<=din_x[DW-1];
			abs_y<=#1 (abs(din_y));
			y_signed<=din_y[DW-1];
		end
	end
	always@(posedge clk or negedge rst_n)
	begin
		if(!rst_n)
		begin
			dout_x<={DW{1'b0}};
			dout_y<={DW{1'b0}};
			din_info<=3'b0;
		end
		else
		begin
			if(din_valid_r[1]==1'b1)
			begin
				dout_x<=#1 x_swap;
				dout_y<=#1 y_swap;
				din_info<=#1 {y_signed,x_signed,swap};
			end
		end
	end
	assign dout_valid=din_valid_r[latency-1];
	endmodule

2 单次运算迭代模块
得到预处理模块值后进行迭代运算，核心部分在于移位加法运算每次迭代需一次取符号，1次查表，2次位移和3次乘加运算，运算延迟一个时钟。代码如下

// An highlighted block
module cordic_ir_unit(
	clk,
	rst_n,
	din_valid,
	din_x,
	din_y,
	din_z,
	dout_valid,
	dout_x,
	dout_y,
	dout_z
	);
	parameter DW=16;
	parameter PIPE_ID=1;
	localparam DW_NOR=20;
	localparam IR_NUM=15;
	localparam latency=1;
	input clk;
	input rst_n;
	input din_valid;
	input signed[DW-1:0]din_x;
	input signed[DW-1:0]din_y;
	input [DW_NOR-1:0]din_z;
	output reg [DW-1:0]dout_x;
	output reg [DW-1:0]dout_y;
	output reg [DW_NOR-1:0]dout_z;
	output dout_valid;
	reg din_valid_r;
	wire y_is_neg;
	wire y_is_pos;
	wire signed [DW-1:0]delta_x;
	wire signed [DW-1:0]delta_y;
	wire signed [DW_NOR-1:0]delta_z;
	wire signed [DW-1:0]dout_temp_x;
	wire signed [DW-1:0]dout_temp_y;
	wire [DW_NOR-1:0]dout_temp_z;
	always@(posedge clk or negedge rst_n)
	begin
		if(!rst_n)
			din_valid_r<=1'b0;
		else
			din_valid_r<=din_valid;
	end
	wire [DW_NOR-1:0]atan_lut[0:IR_NUM-1];
	assign atan_lut[0]=20'h20000;
	assign atan_lut[1]=20'h12E40;
	assign atan_lut[2]=20'h09FB4;
	assign atan_lut[3]=20'h05111;
	assign atan_lut[4]=20'h028B1;
	assign atan_lut[5]=20'h0145D;
	assign atan_lut[6]=20'h00A2F;
	assign atan_lut[7]=20'h00518;
	assign atan_lut[8]=20'h0028C;
	assign atan_lut[9]=20'h00146;
	assign atan_lut[10]=20'h000A3;
	assign atan_lut[11]=20'h00051;
	assign atan_lut[12]=20'h00029;
	assign atan_lut[13]=20'h00014;
	assign atan_lut[14]=20'h0000A;
	assign y_is_neg=din_y[DW-1];
	assign y_is_pos=(~din_y[DW-1]);
	assign delta_z=atan_lut[PIPE_ID];
	generate
		if(PIPE_ID==0)
		begin:shift0
			assign delta_x=din_y;
			assign delta_y=din_x;
		end
	endgenerate
	generate
		if(PIPE_ID!=0)
		begin:shift
			wire signed [DW-1:0]delta_x_temp;
			wire signed [DW-1:0]delta_y_temp;
			assign delta_x_temp=(din_valid==1'b1)?din_y:{DW{1'b0}};
			assign delta_y_temp=(din_valid==1'b1)?din_x:{DW{1'b0}};
			assign delta_x=(din_y[DW-1]==1'b1)?{{PIPE_ID{1'b1}},delta_x_temp[DW-1:PIPE_ID]}:{{PIPE_ID{1'b0}},delta_x_temp[DW-1:PIPE_ID]};
			assign delta_y=(din_x[DW-1]==1'b1)?{{PIPE_ID{1'b1}},delta_y_temp[DW-1:PIPE_ID]}:{{PIPE_ID{1'b0}},delta_y_temp[DW-1:PIPE_ID]};
		end
	endgenerate
			assign dout_temp_x=(y_is_pos)?(din_x+delta_x):(din_x-delta_x);
			assign dout_temp_y=(y_is_neg)?(din_y+delta_y):(din_y-delta_y);
			assign dout_temp_z=(y_is_pos)?(din_z+delta_z):(din_z-delta_z);
		always@(posedge clk or negedge rst_n)
		begin
			if(!rst_n)
			begin
				dout_x<={DW{1'b0}};
				dout_y<={DW{1'b0}};
				dout_z<={DW_NOR{1'b0}};
			end
			else
			begin
				if(din_valid==1'b1)
				begin
					dout_x<=dout_temp_x;
					dout_y<=dout_temp_y;
					dout_z<=dout_temp_z;
				end
			end
		end
		assign dout_valid=din_valid_r;
		endmodule

3，核心处理单元
对单次迭代运算模块进行例化，以菊花链形式连接，上一级输出接下一级输入，输入数据位扩展到4位小数位输出为第15次迭代运算值，代码如下

// An highlighted block
module cordic_core(
	clk,
	rst_n,
	din_valid,
	din_x,
	din_y,
	din_z,
	dout_valid,
	dout_x,
	dout_z
	);
	parameter PIPELINE=15;
	parameter DW=16;
	parameter DW_FRAC=4;
	parameter DW_NOR=20;
	input clk;
	input rst_n;
	input din_valid;
	input [DW-1:0]din_x;
	input [DW-1:0]din_y;
	input [DW-1:0]din_z;
	output [DW+DW_FRAC-1:0]dout_x;
	output [DW_NOR-1:0]dout_z;
	output dout_valid;
	wire [DW+DW_FRAC-1:0]din_x_frac[PIPELINE:0];
	wire [DW+DW_FRAC-1:0]din_y_frac[PIPELINE:0];
	wire [DW_NOR-1:0]din_z_temp[PIPELINE:0];
	wire dout_valid_temp[PIPELINE:0];
	assign din_x_frac[0][DW+DW_FRAC-1:DW_FRAC]=din_x;
	assign din_x_frac[0][DW_FRAC-1:0]={DW_FRAC{1'b0}};
	assign din_y_frac[0][DW+DW_FRAC-1:DW_FRAC]=din_y;
	assign din_y_frac[0][DW_FRAC-1:0]={DW_FRAC{1'b0}};
	assign din_z_temp[0]=din_z;
	assign dout_valid_temp[0]=din_valid;
	generate
		begin:gen_iteration
			genvar n;
			for(n=1;n<=PIPELINE;n=n+1)
				begin:gen_pipeline
				cordic_ir_unit cordic_ir_unit(
				.clk(clk),
				.rst_n(rst_n),
				.din_valid(dout_valid_temp[n-1]),
				.din_x(din_x_frac[n-1]),
				.din_y(din_y_frac[n-1]),
				.din_z(din_z_temp[n-1]),
				.dout_valid(dout_valid_temp[n]),
				.dout_x(din_x_frac[n]),
				.dout_y(din_y_frac[n]),
				.dout_z(din_z_temp[n])
				);
			defparam cordic_ir_unit.DW=DW+DW_FRAC;
			defparam cordic_ir_unit.PIPE_ID=n-1;
			end
		end
	endgenerate
	assign dout_x=din_x_frac[PIPELINE];
	assign dout_z=din_z_temp[PIPELINE];
	assign dout_valid=dout_valid_temp[PIPELINE];
	endmodule

4，后续处理模块
后续处理模块单元实现坐标还原，对象限位置实现还原，处理核需要n-1个时钟完成迭代运算，预处理的象限信息缓存n-1个时钟与处理结果对齐。
在象限还原时，根据预处理逆运算
1，还原x与y交换信息
2，还原y轴
3，还原x轴
运算模块开销3个时钟，代码如下

// An highlighted block
module cordic_post(
	clk,
	rst_n,
	din_valid,
	din_x,
	din_z,
	din_info,
	dout_valid,
	dout_x,
	dout_z
	);
	parameter DW=16;
	parameter DW_FRAC=14;
	parameter DW_NOR=20;
	parameter PIPELINE=15;
	localparam latency_pre=2;
	localparam latency_core=15;
	localparam latency=3;
	localparam const_half_pi=20'h40000;
	localparam const_pi=20'h80000;
	localparam const_double_pi=20'h00000;
	input clk;
	input rst_n;
	input din_valid;
	input [DW+DW_FRAC-1:0]din_x;
	input [DW_NOR-1:0]din_z;
	input [latency-1:0]din_info;
	output [DW+DW_FRAC-1:0]dout_x;
	output reg[DW_NOR-1:0]dout_z;
	output dout_valid;
	integer n;
	reg [DW+DW_FRAC-1:0]gain_temp[0:3];
	wire [DW_NOR-1:0]angle_temp;
	wire [DW_NOR-1:0]angle_valid;
	wire [DW_NOR-1:0]angle_swap;
	reg [2:0]din_info_r[latency_core+latency-1:0];
	reg [latency-1:0]din_valid_r;
	reg [DW_NOR-1:0]angle_swap_r[0:latency-1];
	wire [DW_NOR-1:0]angle_temp_x;
	wire [DW_NOR-1:0]angle_temp_y;
	always@(posedge clk or negedge rst_n)
	begin
		if(!rst_n)
		begin
			gain_temp[0]<={DW+DW_FRAC{1'b0}};
			gain_temp[1]<={DW+DW_FRAC{1'b0}};
			gain_temp[2]<={DW+DW_FRAC{1'b0}};
			gain_temp[3]<={DW+DW_FRAC{1'b0}};
		end
		else
		begin
			if(din_valid==1'b1)
			begin
				gain_temp[0]<={1'b0,din_x[DW+DW_FRAC-1:1]}+{3'b0,din_x[DW+DW_FRAC-1:3]};
				gain_temp[1]<={6'b0,din_x[DW+DW_FRAC-1:6]}+{9'b0,din_x[DW+DW_FRAC-1:9]};
			end
			if(din_valid_r[0]==1'b1)
			begin
				gain_temp[2]<=gain_temp[0]-gain_temp[1];
			end
			if(din_valid_r[1]==1'b1)
			begin
				gain_temp[3]<=gain_temp[2]-{12'b0,gain_temp[2][DW+DW_FRAC-1:12]};
			end
		end
	end
	assign dout_x=gain_temp[3];
	assign angle_valid=(din_valid==1'b1)?din_z:{DW_NOR{1'b0}};
	assign angle_temp=(angle_valid[DW_NOR-1]==1'b1)?({DW_NOR{1'b0}}):angle_valid;
	assign angle_swap=(din_info_r[latency_core-1][0]==1'b1)?(const_half_pi-angle_temp):angle_temp;
	always@(posedge clk)
	begin
		din_valid_r<={din_valid_r[latency-2:0],din_valid};
		angle_swap_r[0]<=angle_swap;
		angle_swap_r[1]<=angle_temp_x;
	end
	always@(posedge clk)
	begin
		din_info_r[0]<=din_info;
		for(n=1;n<latency_core+latency;n=n+1)
		din_info_r[n]<=din_info_r[n-1];
	end
	assign angle_temp_x=(din_info_r[latency_core][1]==1'b1)?(const_half_pi-angle_swap_r[0]):angle_swap_r[0];
	assign angle_temp_y=(din_info_r[latency_core][2]==1'b1)?(const_double_pi-angle_swap_r[1]):angle_swap_r[1];
	always@(posedge clk)
	begin
		dout_z<=angle_temp_y;
	end
	assign dout_valid=din_valid_r[2];
	endmodule

四 总结
cordic运算结果与输入值大小有关，与输入位数有关，最终值X除以16 ，为实际距离值，误差不大于百分之20，通过顶层模块将这四部分连接，总共消耗1288个查找表与1086个寄存器，减少资源消耗，实现预期设计目的。

FPGA 基于 Vivado 核的 CORDIC 算法设计与实现
走向CTO的路上...
02-07 1095
CORDIC（COordinate Rotation DIgital Computer）是一种高效的算法，用于计算多种数学函数，如三角函数、双曲函数、对数、指数和平方根。CORDIC 在硬件中尤其适合，因为它仅依赖于移位和加法运算，而不需要乘法器，特别适合在 FPGA 上实现。CORDIC 算法在 FPGA 上实现非常高效，这是由于其利用简单的移位和加法操作替代了复杂的乘法器。在许多实时系统中，CORDIC 成为快速、低功耗的解决方案。
codic算法的vdhl实现
04-18
cordic算法的vdhl实现
CORDIC算法（Hyperbolic）双曲线旋转模式MATLAB仿真
一个热爱通信的硬件算法工程师
04-23 769
CORDIC算法（Hyperbolic）双曲线旋转模式MATLAB仿真
Cordic算法
一个人要像一支队伍
06-08 3624
Cordic算法可以利用简单的移位和加减来计算复杂的三角函数、双曲函数、对数、指数等。Cordic算法核心思想有两点，通过已知的角度来逼近输入的角度(用移位来代替tanθ)，已知角度的cosθ经过多次积累相乘趋于常数。具体原理如下。根据坐标旋转公式x2=x1cosθ-y1sinθy2=x1sinθ+y1cosθ提取出cosθx2=cosθ(x1-y1tanθ)y2=cosθ(y1+x1tanθ)上式为一次旋转，那么通过已知的角度，来逼近输入的角度，就需要多次旋转，也就是该公式要迭代多次。经过多次迭代后，co
CORDIC算法旋转模式和向量模式的MATLAB及Verilog实现
weixin_43983766的博客
09-14 4137
CORDIC算法旋转模式和向量模式的MATLAB及Verilog实现
MATLAB实现的CORDIC算法及其应用
最新发布
weixin_42234168的博客
11-12 1319
本文还有配套的精品资源，点击获取 简介：CORDIC算法是一种用于数字信号处理领域的高效算法，尤其适合硬件实现，能解决矢量旋转、坐标变换和三角函数计算等问题。本压缩包包含两个MATLAB脚本文件 cordic.m 和 cordic_test.m ，分别用于实现和测试CORDIC算法。算法原理基于迭代逼近，实现过程中通过一系列固定角度的旋转逼近目标...
基于Matlab和FPGA的Cordic算法设计与实现
06-15
CORDIC算法的思想就是：将向量（x，y）顺时针旋转一定的度数，如果旋转之后纵坐标为0，那么累计旋转的度数就是，横坐标x的值就是ρ，也就是向量的模长。 旋转模式原理 已知直角坐标下一向量的角度，如何求该点向量的...
CORDIC.rar_CORDIC FPGA_CORDIC 算法_cordic_cordic算法_fpga 算法
09-24
在提供的"CORDIC算法.pdf"文档中，可能详细介绍了CORDIC算法的原理、实现方法、FPGA设计技巧以及具体的实例应用。通过深入阅读和理解这份资料，读者将能够更好地掌握CORDIC算法，并将其应用到自己的项目中。
基于FPGA的cordic算法实现
05-01
在提供的压缩包文件“cordic”中，可能包含了实现基于FPGA的CORDIC算法的Verilog或VHDL代码，这些代码详细描述了如何在硬件层面实现这一算法。通过阅读和理解这些代码，开发者可以学习到如何将CORDIC算法有效地映射...
基于FPGA的cordic算法输出正弦余弦,verilog编程实现,vivado2019.2平台开发,含testbench
05-18
基于FPGA的cordic算法输出正弦余弦,verilog编程实现,vivado2019.2平台开发,含testbench 含代码操作演示视频 运行注意事项：使用matlab2021a或者更高版本测试，运行里面的Runme.m文件，不要直接运行子函数文件。...
一种CORDIC算法的FPGA实现
06-25
摘要:在数字化中频接收机中, 为了实现相干解调, 接收端的数控振荡器需要产生一个本地相干载波, 其频率和相位必须与 发送端载波的频率和相位严格保持一致, 因此需要用到 arctan函数计算相位差。 研究了一种基于 CORDIC算法计算 arctan 函数的方法, 提出了基于 CORDIC算法实现 arctan函数运算的硬件流水线实现结构, 并在芯片上进行仿真实现, 仿真结果表 明, 其输出误差较小, 与理论值基本一致, 利用其可实现数字载波同步中鉴相、鉴频功能。 关键词:载波同步;坐标旋转数字计算方法;反正切函数;现场可编程芯片实现
CORDIC算法理论详解
热门推荐
yindq1220的博客
10-04 2万+
cordic算法详解。理解其旋转模式和向量模式，相关函数运算的求解方式。
FPGA之CORDIC算法实现_理论篇(上）
weixin_30723433的博客
09-27 206
关于cordic的算法原理核心思想就是规定好旋转角度，然后通过不停迭代逐步逼近的思想来实现数学求解，网上关于这部分的资料非常多，主要可以参考： 1）https://blog.youkuaiyun.com/qq_39210023/article/details/77456031 2）https://blog.youkuaiyun.com/rookiew/article/details/74967394 Xinl...
CORDIC算法详解（六）- CORDIC 算法的硬件实现
OpenFPGA的博客
06-08 2095
CORDIC算法详解（六）- CORDIC 算法的硬件实现文章目录CORDIC算法详解（六）- CORDIC 算法的硬件实现6 CORDIC 算法的硬件实现6.1 CORDIC 算法的硬件...
FPGA实现Cordic算法——向量模式
qq_42151264的博客
09-08 2061
;FPGA中运算三角函数，浮点数的能力有限，而cordic算法能够将三角函数运算转换为简单的移位和加减法进行迭代得到近似结果，能够有效降低运算代价，提升运算效率。
基于cordic算法的小数开方及其FPGA实现
m0_66360845的博客
09-02 5148
现实中很多算法本身就包含开方运算，硬件实现中很多时候也会涉及到开方运算，本次较为详细的介绍用cordic算法实现开方运算的基本原理以及如何使用xilinx公司提供的cordic IP核来完成无符号小数开方运算。
Cordic算法的FPGA实现——cordic实现sqrt和atan计算的定点化以及FPGA实现
gzy0506的博客
02-04 8288
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 Cordic算法的FPGA实现——cordic实现sqrt和atan计算的定点化以及FPGA实现前言matlab定点化仿真verilog实现 前言 要用verilog实现Cordic算法，首选需要在matlab上实现定点化仿真。 因为该定点化操作比较简单，直接通过程序就可以直接理解了，这里就不多说了，直接看程序 matlab定点化仿真 1、atan_table要进行定点化，我们将1rad表示为2^29 进行对应。这样原来的atan_tab
在fpga中用Cordic算法来产生正弦函数
qq_45119962的博客
03-29 5826
在fpga中实现正弦函数可有三种基本方法，Cordic法和查找表法和线性插值法，三种方法各有其优劣性，今天就使用Cordic算法来产生正弦函数 CORDIC ( Coordinate Rotation Digital Computer ) 是坐标旋转数字计算机算法的简称，由 Vloder• 于 1959 年在设计美国航空导航控制系统的过程中首先提出, 主要用于解决导航系统中三角函数、 反三角函...
FPGA实现Cordic算法求解arctan和sqr(x*2 + y* 2)
weixin_44678052的博客
05-13 2590
由于在项目中需要使用的MPU6050，进行姿态解算，计算中设计到**arctan 和 sqr(x2 + y2),**这两部分的计算，在了解了一番之后，发现Cordic算法可以很方便的一次性求出这两个这两部分的计算。另外也可以一次性求出sin和cos的值。另外该算法还可以计算其他的一些公式(没做过多的了解)。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值