朽月

基于FPGA的CORDIC算法的实现（1）

CORDIC算法向量模式原理介绍及FPGA实现

参考文献
项目简述
CORDIC算法向量模式原理

CIRDIC算法向量模式推导步骤一
CIRDIC算法向量模式推导步骤二
CIRDIC算法向量模式推导步骤三
CIRDIC算法向量模式推导步骤三

MATLAB实现
FPGA实现
MATLAB测试代码
总结

参考文献

[1].liyuanbhu
[2].碎碎思
[3].电子发烧友(这门课里面的代码写的非常棒，建议有条件的同学可以与板卡一起购买，记住一定是带着板卡，这里不再多说)

项目简述

基本上懂点FPGA信号处理操作的同学都听过CORDIC算法，该算法可以被使用计算常见函数及超越函数。那么喜欢刨根问底的同学就会问为什么CORDIC算法可以被使用来计算常见函数，该算法又可以使用计算哪些函数，精度如何等等问题。那么这篇文章及接下来的文章将用来介绍这些问题，其实关于该算法在CSDN上面已经又比较完善的CSDN博主进行了介绍，包括我也是使用上面的博客进行的学习，博主的连接以及一些参考文献会在文章的最后给出。

首先CORDIC的全称是 Coordinate Rotation Digital Computer 也就是我们常说的坐标旋转算法。既然是坐标旋转算法，那么就需要坐标进而坐标系是必须需要提前确定。常见在CORDIC算法中使用的系统有圆周系统、线性系统、双曲系统，每种系统又分为向量模式与旋转模式，每种模式可以使用计算不同的函数。包括如果掌握了CORDIC的原理计算一些其他特殊函数也是可能的。 CORDIC函数可以使用计算的函数如下：

下面是VIVADO中CORDIC IP中可以计算的函数

这里是不是可以看出上面的函数基本上是一一对应的。

CORDIC算法向量模式原理

CIRDIC算法向量模式推导步骤一

这里主要参考的是参考文献[1]中的文章，大家可以进行相应的阅读。
平面上一点在直角坐标系下的坐标（X,Y）=（100，200），如何求的在极坐标系下的坐标（ρ,θ）。用计算器计算一下可知答案是（223.61，63.435）。

为了突出重点，这里我们只讨论X和Y都为正数的情况。这里或许有同学要说如果X和Y中有为负值的情况应该咋么办，其实这部分的算法不需要X和Y都为正值，但是需要X为正值。如果X为负值，那么我们便需要进行相应的处理，方法就是将X轴的值变成正值，但是这部分不要忘记CORDIC迭代的初始值发生变化。当X变成正值之后θ=atan(y/x)。求θ的过程也就是求atan 函数的过程。Cordic算法采用的想法很直接，将 $(x, y)$ 旋转一定的度数，如果旋转完纵坐标变为了0，那么旋转的度数就是θ。坐标旋转的公式可能大家都忘了，这里把公式列出了。设 $(x, y)$ 是原始坐标点，将其以原点为中心，顺时针旋转θ之后的坐标记为 $x_1,y_1)$ ,则有如下公式：

这里要明确我们的目标是为了将 $y$ 变成零，为了减少计算量，都是先用二分法进行旋转，也就是说第一次旋转45度，至于是顺时针旋转还是逆时针旋转取决于 $y$ 的符号。

旋转之后纵坐标为70.71，还是大于0，说明旋转的度数不够，接着再旋转22.5度。

这时总共旋转了45+22.5=67.5度。结果纵坐标变为了负数，说明θ<67.5度，这时就要往回转，还是二分查找法的思想，这次转11.25度。

这时总共旋转了45+22.5-11.25=56.25度。又转过头了，接着旋转，这次顺时针转5.625度。

这时总共旋转了45+22.5-11.25+5.625=61.875度。这时纵坐标已经很接近0了。我们只是说明算法的思想，因此就不接着往下计算了。计算到这里我们给的答案是 61.875±5.625。二分查找法本质上查找的是一个区间，因此我们给出的是θ值的一个范围。同时，坐标到原点的距离ρ也求出来了，ρ=223.52。与标准答案比较一下计算的结果还是可以的。旋转的过程图示如下。

可能有读者会问，计算中用到了 sin 函数和 cos 函数，这些值又是怎么计算呢。很简单，我们只用到很少的几个特殊点的sin 函数和 cos 函数的值，提前计算好存起来，用查找表。这里需要注意，这种思想在FPGA中非常容易遇见。

将上面的思想我们使用MATLAB来实现如下：

clc;
clear all;

sine = [0.7071067811865,0.3826834323651,0.1950903220161,0.09801714032956,0.04906767432742,0.02454122852291,0.01227153828572,0.006135884649154,0.003067956762966,0.001533980186285,7.669903187427045e-4,3.834951875713956e-4,1.917475973107033e-4,9.587379909597735e-5,4.793689960306688e-5,2.396844980841822e-5];
cosine = [0.7071067811865,0.9238795325113,0.9807852804032,0.9951847266722, ...
0.9987954562052,0.9996988186962,0.9999247018391,0.9999811752826,0.9999952938096, ...
0.9999988234517,0.9999997058629,0.9999999264657,0.9999999816164,0.9999999954041, ...
0.999999998851,0.9999999997128];
angle = 45;
a = zeros(16,1);
for i = 1:16
    a(i) = angle;
    angle = angle/2;
end

 x = 100;
 y = -300;
 z = 0;
 
for i = 1:16
    if(y > 0)
        x_new = x*cosine(i) + y*sine(i);
        y_new = y*cosine(i) - x*sine(i);
        x = x_new;
        y = y_new;
        z = z + a(i);
    else
        x_new = x*cosine(i) - y*sine(i);
        y_new = y*cosine(i) + x*sine(i);
        x = x_new;
        y = y_new;
        z = z - a(i);
    end
end
z

结果如下：

CIRDIC算法向量模式推导步骤二

CORDIC一般是在FPGA中实现。FPGA中的DSP资源是非常宝贵的资源，所以我们要尽可能减少CORDIC中的乘法的个数，所以将公式变形如下：

这里因为我们要计算相位 $a r c t a n (y / x)$ ，所以我们先将缩放因子去掉

但是我们注意到 CIRDIC算法向量模式不仅可以计算 $a r c t a n (y / x)$ 而且可以计算 $\sqrt{x^2+y^2}$ ，所以这个补偿因子到最后肯定会补偿回来，在FPGA中同样利用查表得方法补偿回来。
省略cos(θ)后发生了什么呢，每次旋转后的新坐标点到原点的距离都变长了，放缩的系数是1/cos(θ)。不过没有关系，我们求的是θ，不关心ρ的改变。这样的变形非常的简单，但是每次循环的运算量一下就从4次乘法降到了2次乘法了。

将上面的思想我们使用MATLAB来实现如下：

clc;
clear all;

tangent = [1.0,0.4142135623731,0.1989123673797,0.09849140335716,0.04912684976947, ...
0.02454862210893,0.01227246237957,0.006136000157623,0.003067971201423, ... 
0.001533981991089,7.669905443430926e-4,3.83495215771441e-4,1.917476008357089e-4, ... 
9.587379953660303e-5,4.79368996581451e-5,2.3968449815303e-5];
angle = 45;
a = zeros(16,1);
for i = 1:16
    a(i) = angle;
    angle = angle/2;
end

 x = 100;
 y = -300;
 z = 0;
 
for i = 1:16
    if(y > 0)
        x_new = x+ y*tangent(i);
        y_new = y - x*tangent(i);
        x = x_new;
        y = y_new;
        z = z + a(i);
    else
        x_new = x- y*tangent(i);
        y_new = y + x*tangent(i);
        x = x_new;
        y = y_new;
        z = z - a(i);
    end
end
z

结果与公式变形前得结果一摸一样，进而说明了我们实验得正确性。

CIRDIC算法向量模式推导步骤三

在FPGA中多得是寄存器查找表等资源，DSP资源非常少，所以我们要尽可能得消除CORDIC中得乘法，消除得方法是变下面公式中得乘法为移位操作：

所以我们要求 $t a n (θ)$ 是2得负整数次幂。然后我们对上面得式子进行分析：
第一次循环时，tan(45)=1，所以第一次循环实际上是不需要乘法运算的。第二次运算呢？

Tan(22.5)=0.4142135623731,很不幸，第二次循环乘数是个很不整的小数。是否能对其改造一下呢？答案是肯定的。第二次选择22.5度是因为二分查找法的查找效率最高。如果选用个在22.5到45度之间的值，查找的效率会降低一些。如果稍微降低一点查找的效率能让我们有效的减少乘法的次数，使最终的计算速度提高了，那么这种改进就是值得的。

我们发现tan(26.565051177078)=0.5，如果我们第二次旋转采用26.565051177078度，那么乘数变为0.5，如果我们采用定点数运算的话（没有浮点协处理器时为了加速计算我们会大量的采用定点数算法）乘以0.5就相当于将乘数右移一位。右移运算是很快的，这样第二次循环中的乘法运算也被消除了。

类似的方法，第三次循环中不用11.25度，而采用 14.0362434679265 度。

Tan(14.0362434679265)= 1/4

乘数右移两位就可以了。剩下的都以此类推。

所以我们给出相应的MATLAB代码：

clc;
clear all;

angle = [45.0, 26.565051177078, 14.0362434679265, 7.1250163489018, 3.57633437499735, ...
                            1.78991060824607, 0.8951737102111, 0.4476141708606, 0.2238105003685, 0.1119056770662, ... 
                            0.0559528918938, 0.027976452617, 0.01398822714227, 0.006994113675353, 0.003497056850704,0.001748528426980];
                     
tangent = [1.0, 1 / 2.0, 1 / 4.0, 1 / 8.0, 1 / 16.0, ...
                              1 / 32.0, 1 / 64.0, 1 / 128.0, 1 / 256.0, 1 / 512.0, ...
                              1 / 1024.0, 1 / 2048.0, 1 / 4096.0, 1 / 8192.0, 1 / 16384.0,1/32768];


 x = 100;
 y = -300;
 z = 0;
 
for i = 1:16
    if(y > 0)
        x_new = x+ y*tangent(i);
        y_new = y - x*tangent(i);
        x = x_new;
        y = y_new;
        z = z + angle(i);
    else
        x_new = x- y*tangent(i);
        y_new = y + x*tangent(i);
        x = x_new;
        y = y_new;
        z = z - angle(i);
    end
end
z

上面的程序由于MATLAB本身不利于移位操作，所以我们也就乘以了相应的数，但这点在FPGA中是相当容易操作的。
运行结果如下：

到这里 CORDIC 算法的最核心的思想就介绍完了。当然，这里介绍的只是CORDIC算法最基本的内容，实际上，利用CORDIC 算法不光可以计算 atan 函数，其他的像 Sin，Cos，Sinh，Cosh 等一系列的函数都可以计算。

CIRDIC算法向量模式推导步骤三

上面为计算过程中我们将 $c o s (θ)$ 省略，所以为了计算 $\sqrt{x^2+y^2}$ ，所以这个补偿因子到最后肯定会补偿回来。因为每次推导我们都省略了 $c o s (θ)$ ，所以我们最终的真实值 $x_{n1},y_{n1})$ 需要进行的缩放处理如下：

由前面可知：

所以：

若总的旋转次数为n，则总的模长补偿因子K可表示为:

当n趋于无穷大时，K 逼近 0.607252935。
对应的MATLAB程序如下：

clc;
clear all;

angle = [45.0, 26.565051177078, 14.0362434679265, 7.1250163489018, 3.57633437499735, ...
                            1.78991060824607, 0.8951737102111, 0.4476141708606, 0.2238105003685, 0.1119056770662, ... 
                            0.0559528918938, 0.027976452617, 0.01398822714227, 0.006994113675353, 0.003497056850704,0.001748528426980];
                     
tangent = [1.0, 1 / 2.0, 1 / 4.0, 1 / 8.0, 1 / 16.0, ...
                              1 / 32.0, 1 / 64.0, 1 / 128.0, 1 / 256.0, 1 / 512.0, ...
                              1 / 1024.0, 1 / 2048.0, 1 / 4096.0, 1 / 8192.0, 1 / 16384.0,1/32768];


 x = 100;
 y = -300;
 z = 0;
 
for i = 1:16
    if(y > 0)
        x_new = x+ y*tangent(i);
        y_new = y - x*tangent(i);
        x = x_new;
        y = y_new;
        z = z + angle(i);
    else
        x_new = x- y*tangent(i);
        y_new = y + x*tangent(i);
        x = x_new;
        y = y_new;
        z = z - angle(i);
    end
end
K = 1;
for i = 1:16
    K = K*1/sqrt(1+2^-(2*(i-1)));
end
x_new = x_new*K

z

运行结果如下：

从上面可以验证我们实验的正确性，并且K值在实际FPGA中也是进行查表而不是上面程序那样计算。

MATLAB实现

上面的MATLAB代码知识为了验证我们的推导过程专门写的代码，这样写的代码没办法与FPGA内部生成的代码一一对应起来，其中最主要的原因也是因为没有对数据进行相应的量化操作，也没有在程序中进行相应的预处理操作。所以接下来给出相应的完整的代码，这部分代码参考了电子发烧友，本来想自己写，但是架不住别人写的代码太好，相应的链接已经在参考文献中给出，需要的同学可以自己学习。

clc;
clear all;
Ninter = 12;%迭代次数
N = 32;
%y: y坐标值(Q（N,N-2))
%x: x坐标值(Q（N,N-2))
%angle:Q(18,15)
%这些量化指标都是为了与FPGA中的一致才进行这样精度的量化
ang = quantizer('mode','fixed','roundmode','nearest','overflowmod','saturate','format',[18,15]);
input = quantizer('mode','fixed','roundmode','floor','overflowmod','saturate','format',[N,N-2]);
amp = quantizer('mode','fixed','roundmode','floor','overflowmod','saturate','format',[N,N-2]);
ampcoe = quantizer('mode','fixed','roundmode','nearest','overflowmod','saturate','format',[18,16]);
amp2 = quantizer('mode','fixed','roundmode','floor','overflowmod','saturate','format',[48,45]);
amp3 = quantizer('mode','fixed','roundmode','floor','overflowmod','saturate','format',[25,22]);


times = 100;

num=0;

fid1 = fopen('x_random_fpga.txt','r');
x_fix = fscanf(fid1,'%d');  
x_fix = x_fix/2^(N-2);

fid1 = fopen('y_random_fpga.txt','r');
y_fix = fscanf(fid1,'%d');  
y_fix = y_fix/2^(N-2);
  
PreciseAng_data = zeros(1,times);
PreciseAmp_data = zeros(1,times);
Ang_data=zeros(1,times);
Amp_data=zeros(1,times);

for t=1:times
    
num=num+1;
    
x = x_fix(t);
y= y_fix(t);

K = zeros(1,Ninter+1);
K(1) = 1;
for i=2:Ninter + 1
    K(i) = K(i-1)*sqrt(1+2^(-2*i+4));
   
end
K = quantize(ampcoe,1./K);
y1 =y;
z = 0;
x1 = abs(x);
x1 = x1;
y1 = y1;
d = -sign(y1);

atan_z = zeros(1,Ninter);
atan_z_dectobin =zeros(Ninter,15);
for i=0:Ninter-1
    atan_z(i+1) = quantize(ang,atan(2^(-i)));
end
   
for n=0:Ninter-1
    if(y1 == 0)
        break;
    end
  x1_q = quantize(amp2,(2^(-n)*x1));
  y1_q = quantize(amp2,(2^(-n)*y1));%(48,45)

  
  x1 =  quantize(amp2,x1 - d*y1_q);
  y1 = quantize(amp2,y1 + d*x1_q);


  
  atan_z_qu = quantize(ang,atan_z(n+1));
  z = quantize(ang,z - d*atan_z_qu);
  
  atan_zzz = atan_z_qu*2^15;
  
  z_comp =z*2^15;
  d = -sign(y1);
end
%坐标点预处理
pi_quan = quantize(ang,pi);
if(x  < 0)
  if(y < 0)
     Ang = -z - pi_quan  ;
  else
     Ang = - z + pi_quan ;
  end
else
    Ang = z;
end

Ang_q =Ang*2^15;

x1 = quantize(amp3,x1);%(25,21)这些是与FPGA中的量化代码相互对应的部分

Amp = quantize(amp,x1*K(n+1));%K(18,16)
Amp_q = Amp*2^(N-2);
 
err = Ang - angle(x + j*y);
PreciseAng = log2(abs(err));
err = Amp - abs(x+j*y);
PreciseAmp = log2(abs(err));

Ang_data(t)=Ang_q;
Amp_data(t)=Amp_q;
PreciseAng_data(t)=PreciseAng;
PreciseAmp_data(t)=PreciseAmp;

if(PreciseAng_data(t)==0)
    break;
end 

if(PreciseAmp_data(t)==0)
    break;
end

end
    
PreciseAng_s_max = max(PreciseAng_data)
PreciseAmp_s_max = max(PreciseAmp_data)
fid_ang = fopen('Ang_matlab.txt','w');
fprintf(fid_ang,'%d\n',Ang_data);
   
fid_amp = fopen('Amp_matlab.txt','w');
fprintf(fid_amp,'%d\n',Amp_data);

然后对比一下100个数据之后算法计算的最大误差：

上面的结果是将数据转换成dB的格式，所以说上面的算法处理的是正确的。
上面的难点在意量化操作再FPGA中实现的方式：

在下面FPGA实现的时候我们会进行相应的介绍。

FPGA实现

其实上面代码的FPGA实现是非常容易的，FPGA的程序是在电子发烧友的基础上改的，为了尊重原作者，大家可以购买相应的课程，课程里面的代码都非常棒，我也只是改了一小部分。接下来的代码其实如果想简单点就可以不使用DSP原语而是直接使用组合逻辑或者IP完成相应的操作。其实关于CORDIC算法的Verilog实现博主19年的时候写过，还是比较容易的，但是却没办法与MATLAB相互验证，也没办法控制DSP资源的复用，通过该课程的学习我真正掌握了MATLAB与FPGA的相互验证方法。这一部分由于我只是做了稍微一点改动，所以原作者的信息在博客中保留。

`timescale 1ns / 1ps

////////////////////////////////////////////////////////////////////////////////
// Company: MYMINIEYE
// Engineer:Mill
//
// Create Date:   2016/12/29 14:26:00
// Design Name:   CORDICang_stream
// Module Name:   CORDICang_vector_ip
// Project Name:  FS_cofdm_rx_v00
// Target Device:  zc7045
// Tool versions:  vivado 2015.1
// Description: Cordic 
//	
//
//
// Dependencies:
// 
// Revision:v02
// Revision 0.01 - File Created
// Additional Comments: contact us: [email protected]
// 
////////////////////////////////////////////////////////////////////////////////
module CORDICang_vector_ip #
(
	parameter 		Ninter 		= 		13,
	parameter 		N 			=		32
)
(
	input 				sclk			,
	input 				rst_n			,
	input 		[N-1:0] x				,
	input 		[N-1:0] y				,
	input 				valid			,
	
	output	reg	[17:0]	Ang			    ,
	output	reg	[N-1:0] Amp				,
	output	reg 		Ang_en
	
);
 
//========================================================================================\
//************** 	Main  	Code		**********************************
//========================================================================================/
/*===================================================================
====================================================================*/
reg 					valid_d			;
reg 					valid_a			;
reg 			[N-1:0]	x_a				;
reg 			[N-1:0]	y_a				;
reg 			[ 4:0]	cordic_cnt		;

always @(posedge sclk)
	valid_d 		<= 		valid;

always @(posedge sclk)
	if(!rst_n)
		valid_a 	<=   	1'b0;
	else if(valid && valid_d==1'b0)
		valid_a 	<=   	1'b1;
	else if(cordic_cnt == 5'd29)
		valid_a 	<=   	1'b0;

always @(posedge sclk)
	if(!valid_a)
		cordic_cnt 	<=   	3'd0;
	else 	
		cordic_cnt 	<=   	cordic_cnt + 1'b1;		

always @(posedge sclk)
	if(valid&&valid_d==1'b0)begin
		x_a 		<=   	x;
		y_a 		<=   	y;
	end 
/*===================================================================
====================================================================*/
reg 			[ 4:0]	Ninter_cnt		;
reg 			[ 4:0]	Ninter_cnt_copy1;
wire 			[17:0] 	K_quantize		;
wire 			[17:0]	atanz			;
reg 					valid_reg		;
reg  			[47:0]  x1				;
wire 			[47:0]  x_reg_dsp_x1	;
reg  			[47:0]  y1				;
wire 			[47:0]  y_reg_dsp_y1	;
reg 					x1_add_en		;
reg 					y1_add_en		;
reg  			[17:0] 	z				;
wire 			[17:0] 	z_dsp_lut		;
reg  			[17:0] 	z_dsp_lut_delay1;
wire 			[29:0] 	A_IN_x1			;
reg 			[17:0]	B_IN_x1			;
reg 			[47:0] 	C_x1			;
wire 			[24:0] 	D				;
wire 			[47:0] 	P_x1			;
reg 			[24:0] 	x1_mux			;
reg 			[ 6:0]	OPMODE_x1		;
reg 			[ 3:0]	ALUMODE_x1		;
reg 			[ 4:0]	INMODE_x1		;
reg 			[ 6:0]	OPMODE_y1		;
reg 			[ 3:0]	ALUMODE_y1		;
wire 			[ 4:0]	INMODE_y1		;
reg 			[29:0]	A_IN_y1			;
reg 			[17:0]	B_IN_y1			;
reg 			[47:0] 	C_y1			;
wire 			[47:0] 	P_y1			;
reg 			[47:0]	shift_y_reg		;
reg 			[47:0]	shift_x_reg		;
reg 					break_out 		;
reg 					break_happen 	;
wire 					break_cal		;
reg 					cal_control		;
reg 					first_break_happen	;
always @(posedge sclk)
	if(!rst_n)
		cal_control 		<=   	1'b0;
	else if(valid_a)
		cal_control 		<=   	~cal_control;

always @(*)//这个信号没有用处
	if(Ninter_cnt_copy1 != 0 && break_cal && cal_control == 1'b0)
		break_happen 		= 		1'b1;
	else 
		break_happen 		= 		1'b0;


always @(posedge sclk)
	if(!rst_n)
		first_break_happen 	<=   	1'b0;
	else if(break_happen)
		first_break_happen 	<=   	1'b1;
	else if(Ninter_cnt_copy1 == 4'd14)
		first_break_happen 	<=   	1'b0;
/*===================================================================
====================================================================*/  
reg 					x_sign,y_sign	;
reg 					Pos_valid		;
reg 			[3:0]	k_addr			;

always @(posedge sclk)
	valid_reg 				<=   	valid_a;


always @(posedge sclk)
	if(!rst_n)
		x_sign 				<= 		1'b0;
	else if(x_a[N-1]&&valid_a&&(~valid_reg))
		x_sign 				<= 		1'b1;
	else if(x_a[N-1]==1'b0&&valid_a&&(~valid_reg))
		x_sign 				<= 		1'b0;

always @(posedge sclk)
	if(!rst_n)
		y_sign 				<= 		1'b0;
	else if(y_a[N-1]&&valid_a&&(~valid_reg))
		y_sign 				<= 		1'b1;
	else if(y_a[N-1]==1'b0&&valid_a&&(~valid_reg))
		y_sign 				<= 		1'b0;


always @(posedge sclk)
	if(!rst_n)
		Pos_valid 			<=   	1'b0;	
	else if(valid_a && (~valid_reg))
		Pos_valid 			<=   	1'b1;
	else if(Ninter_cnt_copy1==5'h1f)
		Pos_valid 			<=   	1'b0;		


always @(posedge sclk)
	if(!rst_n||(!valid_a))
		Ninter_cnt 			<=   	4'd0;
	else if(valid_a&&cal_control)		
		Ninter_cnt 			<=   	Ninter_cnt + 1'b1;


always @(posedge sclk)
	if(!rst_n||(!valid_a))
		Ninter_cnt_copy1 	<=   	4'd0;
	else if(valid_a&&cal_control)		
		Ninter_cnt_copy1 	<=   	Ninter_cnt_copy1 + 1'b1;

always @(posedge sclk)
	if(!rst_n)
		break_out 			<=   	1'b0;
	else if(break_happen==1'b1&&first_break_happen==1'b0)
		break_out 			<=   	1'b1;
	else if(Ninter_cnt_copy1==4'd14)
		break_out 			<=   	1'b0;		


always @(posedge sclk)
	if(!rst_n)
		k_addr 				<=   	4'd0;
	else if(y1[47:48-N]==32'd0)
		k_addr 				<=   	4'd0;
	else if(break_happen&&first_break_happen==1'b0)
		k_addr	 			<=   	Ninter_cnt_copy1;
	else if(!break_out)
		k_addr 				<=   	Ninter;		

K_quantize_dis_rom #(
   .ROM_WIDTH     		(18						),
   .ROM_ADDR_BITS 		(4 						),
   .ROM_DEPTH     		(16						)
) u_K_quantize_dis_rom(
    .clock      		(sclk					),
	.enable     		(1'b1					),
	.address    		(k_addr					),
	.output_data		(K_quantize				)
  );   
atan_z_dis_rom #(
   .ROM_WIDTH     		(18						),
   .ROM_ADDR_BITS 		(4 						),
   .ROM_DEPTH     		(16						)
)u_atan_z_dis_rom(
    .clock      		(sclk					),
	.enable     		(1'b1					),
	.address    		(Ninter_cnt_copy1[3:0] 	),
	.output_data		(atanz 					)
  );  
/*===================================================================
====================================================================*/  
reg 				[N-1:0]	x_abs			;
always @(posedge sclk)
	if(x_a[N-1]==1)
		x_abs 		<=  		(~x_a)+1'b1;
	else 				
		x_abs 		<=  		x_a;

/*===================================================================
====================================================================*/ 
always @(posedge sclk)
	case(Ninter_cnt[3:0])
		4'd0:shift_y_reg <=   {{2{y_a[N-1]}},{y_a[N-2:0]},{(47-N){1'b0}}};//floor
		4'd1: if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{1{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:1]};//floor
		4'd2: if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{2{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:2]};//floor
		4'd3: if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{3{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:3]};//floor
		4'd4: if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{4{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:4]};//floor
		4'd5: if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{5{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:5]};//floor
		4'd6: if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{6{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:6]};//floor
		4'd7: if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{7{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:7]};//floor	
		4'd8: if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{8{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:8]};//floor
		4'd9: if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{9{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:9]};//floor
		4'd10:if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{10{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:10]};//floor
		4'd11:if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{11{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:11]};//floor
		4'd12:if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{12{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:12]};//floor
		4'd13:if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{13{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:13]};//floor
		4'd14:if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{14{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:14]};//floor
		4'd15:if(cal_control==1'b0)shift_y_reg <=   {y_reg_dsp_y1[47],{15{y_reg_dsp_y1[47]}},y_reg_dsp_y1[46:15]};//floor	
		default:shift_y_reg <=   shift_y_reg;
	endcase 


always @(posedge sclk)
	case(Ninter_cnt[3:0])
		4'd0:shift_x_reg  <=   {{2{x_abs[N-1]}},{x_abs[N-2:0]},{(47-N){1'b0}}};
		4'd1:if(cal_control==1'b0)shift_x_reg  <=   {x_reg_dsp_x1[47],{1{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:1]};//floor
		4'd2:if(cal_control==1'b0)shift_x_reg  <=   {x_reg_dsp_x1[47],{2{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:2]};//floor
		4'd3:if(cal_control==1'b0)shift_x_reg  <=   {x_reg_dsp_x1[47],{3{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:3]};//floor
		4'd4:if(cal_control==1'b0)shift_x_reg  <=   {x_reg_dsp_x1[47],{4{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:4]};//floor
		4'd5:if(cal_control==1'b0)shift_x_reg  <=   {x_reg_dsp_x1[47],{5{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:5]};//floor
		4'd6:if(cal_control==1'b0)shift_x_reg  <=   {x_reg_dsp_x1[47],{6{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:6]};//floor
		4'd7:if(cal_control==1'b0)shift_x_reg  <=   {x_reg_dsp_x1[47],{7{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:7]};//floor	
		4'd8:if(cal_control==1'b0)shift_x_reg  <=   {x_reg_dsp_x1[47],{8{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:8]};//floor
		4'd9:if(cal_control==1'b0)shift_x_reg  <=   {x_reg_dsp_x1[47],{9{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:9]};//floor
		4'd10:if(cal_control==1'b0)shift_x_reg <=   {x_reg_dsp_x1[47],{10{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:10]};//floor
		4'd11:if(cal_control==1'b0)shift_x_reg <=   {x_reg_dsp_x1[47],{11{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:11]};//floor
		4'd12:if(cal_control==1'b0)shift_x_reg <=   {x_reg_dsp_x1[47],{12{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:12]};//floor
		4'd13:if(cal_control==1'b0)shift_x_reg <=   {x_reg_dsp_x1[47],{13{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:13]};//floor
		4'd14:if(cal_control==1'b0)shift_x_reg <=   {x_reg_dsp_x1[47],{14{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:14]};//floor
		4'd15:if(cal_control==1'b0)shift_x_reg <=   {x_reg_dsp_x1[47],{15{x_reg_dsp_x1[47]}},x_reg_dsp_x1[46:15]};//floor	
		default:shift_x_reg <=    shift_x_reg;
	endcase
/*=============================================================================
	x1 = x_reg - d*(shift(n+1)*y_reg); and Amp = quantize(q_amp,x1*K(n+1));
	DSP X1: add/sub and mult; MUX:P=(A:B)+/-C; P=B*D
==============================================================================*/
reg 				[47:0] x1_temp			;
reg 				[47:0]	x_reg_dsp_x1_d	;

assign 		A_IN_x1 	= 	shift_y_reg[47:18];
assign 		D 	   		= 	x1_temp[47:23];
assign 		x_reg_dsp_x1= 	P_x1;

always @(*)
	if(Ninter_cnt==4'd0&&Pos_valid)
		x1 				=  		{{2{x_abs[N-1]}},{x_abs[N-2:0]},{(47-N){1'b0}}};
	else 	
		x1 				= 		x_reg_dsp_x1;

always @(posedge sclk)
	if(y1[47:48-N]==32'd0)//y1[47:48-N]==32'd0||break_out
		x1_temp 		<=   	{{2{x_abs[N-1]}},{x_abs[N-2:0]},{(47-N){1'b0}}};
	else if(break_happen == 1'b1)
		x1_temp 		<=   	x_reg_dsp_x1;
	else if(cal_control==1'b0 && break_out==1'b0 && Ninter_cnt==Ninter)//if(break_happen&&first_break_happen==1'b0)
		x1_temp 		<=   	x_reg_dsp_x1;

always @(posedge sclk)
	y1 					<=   {{2{y_a[N-1]}},{y_a[N-2:0]},{(47-N){1'b0}}};//x1 <=   {4'b0000,{x[N-2:0]},{(45-N){1'b0}}};//	 

always @(posedge sclk)
	if(y_a[N-1]==1'b0 && Ninter_cnt==0)
		x1_add_en 		<=    	1'b1;
	else if(y_a[N-1]==1'b1 && Ninter_cnt==0)
		x1_add_en 		<=    	1'b0;
	else if(y_reg_dsp_y1[47]==1'b1&&cal_control==1'b0)
		x1_add_en 		<=   	1'b0;
	else if(y_reg_dsp_y1[47]==1'b0&&cal_control==1'b0)
		x1_add_en 		<=   	1'b1;		
	else 
		x1_add_en 		<=    	x1_add_en;

always @(posedge sclk)
	if(Ninter_cnt==Ninter||break_out)
		x1_mux 			<= 		x1[47:23];
	else
		x1_mux 			<= 		25'd0;


always @(posedge sclk)
	x_reg_dsp_x1_d 		<=   	x_reg_dsp_x1;


always @(*)
	if(Ninter_cnt>=Ninter||break_out)
		B_IN_x1 		= 		K_quantize;
	else if(cal_control<Ninter&&cal_control)
		B_IN_x1			= 		shift_y_reg[17:0];
	else 
		B_IN_x1 		= 		18'd0;

always @(*)
	if(Ninter_cnt==0 && cal_control)
		C_x1 			= 		{{2{x_abs[N-1]}},{x_abs[N-2:0]},{(47-N){1'b0}}};
	else if(cal_control == 1'b1)
		C_x1 			= 		x_reg_dsp_x1_d;
	else 
		C_x1 			= 		48'd0;

always @(*)
	if(Ninter_cnt>=Ninter)
		OPMODE_x1 		= 		7'b000_01_01;//B*D
	else if(x1_add_en == 1'b1)//C+(A:B)
		OPMODE_x1 		= 		7'b000_11_11;
	else 
		OPMODE_x1 		= 		7'b011_00_11;//C-(A:B)			

always @(posedge sclk)
	if(Ninter_cnt>=Ninter-2)
		INMODE_x1 		<=   	5'b00110;
	else
		INMODE_x1 		<=   	5'b00000;	

always @(*)
	if(Ninter_cnt>=Ninter)
		ALUMODE_x1 		= 		4'b0000;
	else if(x1_add_en == 1'b1)
		ALUMODE_x1 		= 		4'b0000;				
	else
		ALUMODE_x1  	= 		4'b0011;			 

always @(posedge sclk)
	if(!rst_n)
		Amp 			<=   	0;	
	else if(x_reg_dsp_x1[42]==1'b0&& |x_reg_dsp_x1[41:39] && Ninter_cnt==(Ninter+1)&&cal_control==1'b0) 
		Amp 			<=   	32'b0111_1111_1111_1111_1111_1111_1111_1111;
	else if(x_reg_dsp_x1[42]&& &x_reg_dsp_x1[41:39]==1'b0 && Ninter_cnt==(Ninter+1)&&cal_control==1'b0) 
		Amp 			<=   	32'b1000_0000_0000_0000_0000_0000_0000_0000;
	else if(Ninter_cnt==(Ninter+1)&&cal_control==1'b0) 
		Amp 			<=   	{x_reg_dsp_x1[42],x_reg_dsp_x1[38],x_reg_dsp_x1[37:40-N]};			
	else
		Amp 			<=   	Amp;

wire 		rst 	= 	~rst_n;

wire 				rst_x		;
assign 		rst_x	=	~rst_n;
	
DSP48E1 #(
// Feature Control Attributes: Data Path Selection
.A_INPUT("DIRECT"), // Selects A input source, "DIRECT" (A port) or "CASCADE" (ACIN port)
.B_INPUT("DIRECT"), // Selects B input source, "DIRECT" (B port) or "CASCADE" (BCIN port)
.USE_DPORT("TRUE"), // Select D port usage (TRUE or FALSE)
.USE_MULT("DYNAMIC"), // Select multiplier usage ("MULTIPLY", "DYNAMIC", or "NONE")
.USE_SIMD("ONE48"), // SIMD selection ("ONE48", "TWO24", "FOUR12")
// Pattern Detector Attributes: Pattern Detection Configuration
.AUTORESET_PATDET("NO_RESET"), // "NO_RESET", "RESET_MATCH", "RESET_NOT_MATCH"
.MASK(48'h3fffffffffff), // 48-bit mask value for pattern detect (1=ignore)
.PATTERN(48'h000000000000), // 48-bit pattern match for pattern detect
.SEL_MASK("MASK"), // "C", "MASK", "ROUNDING_MODE1", "ROUNDING_MODE2"
.SEL_PATTERN("PATTERN"), // Select pattern value ("PATTERN" or "C")
.USE_PATTERN_DETECT("NO_PATDET"), // Enable pattern detect ("PATDET" or "NO_PATDET")

// Register Control Attributes: Pipeline Register Configuration
.ACASCREG(0), // Number of pipeline stages between A/ACIN and ACOUT (0, 1 or 2)
.ADREG(0), // Number of pipeline stages for pre-adder (0 or 1)
.ALUMODEREG(0), // Number of pipeline stages for ALUMODE (0 or 1)
.AREG(0), // Number of pipeline stages for A (0, 1 or 2)
.BCASCREG(0), // Number of pipeline stages between B/BCIN and BCOUT (0, 1 or 2)
.BREG(0), // Number of pipeline stages for B (0, 1 or 2)
.CARRYINREG(0), // Number of pipeline stages for CARRYIN (0 or 1)
.CARRYINSELREG(0), // Number of pipeline stages for CARRYINSEL (0 or 1)
.CREG(0), // Number of pipeline stages for C (0 or 1)
.DREG(0), // Number of pipeline stages for D (0 or 1)
.INMODEREG(1), // Number of pipeline stages for INMODE (0 or 1)
.MREG(0), // Number of multiplier pipeline stages (0 or 1)
.OPMODEREG(0), // Number of pipeline stages for OPMODE (0 or 1)
.PREG(1) // Number of pipeline stages for P (0 or 1)

)

DSP48E1_cal_x1 (
// Cascade: 30-bit (each) output: Cascade Ports
.ACOUT(), // 30-bit output: A port cascade output
.BCOUT(), // 18-bit output: B port cascade output
.CARRYCASCOUT(), // 1-bit output: Cascade carry output
.MULTSIGNOUT(), // 1-bit output: Multiplier sign cascade output
.PCOUT(), // 48-bit output: Cascade output
// Control: 1-bit (each) output: Control Inputs/Status Bits
.OVERFLOW(), // 1-bit output: Overflow in add/acc output
.PATTERNBDETECT(), // 1-bit output: Pattern bar detect output
.PATTERNDETECT(), // 1-bit output: Pattern detect output
.UNDERFLOW(), // 1-bit output: Underflow in add/acc output

// Data: 4-bit (each) output: Data Ports
.CARRYOUT(), // 4-bit output: Carry output
.P(P_x1), // 48-bit output: Primary data output
// Cascade: 30-bit (each) input: Cascade Ports
.ACIN(30'd0), // 30-bit input: A cascade data input
.BCIN(18'd0), // 18-bit input: B cascade input
.CARRYCASCIN(1'b0), // 1-bit input: Cascade carry input
.MULTSIGNIN(1'b0), // 1-bit input: Multiplier sign input
.PCIN(48'd0), // 48-bit input: P cascade input
// Control: 4-bit (each) input: Control Inputs/Status Bits
.ALUMODE(ALUMODE_x1), // 4-bit input: ALU control input
.CARRYINSEL(3'b000), // 3-bit input: Carry select input
.CLK(sclk), // 1-bit input: Clock input
.INMODE(INMODE_x1), // 5-bit input: INMODE control input
.OPMODE(OPMODE_x1), // 7-bit input: Operation mode input

// Data: 30-bit (each) input: Data Ports
.A(A_IN_x1), // 30-bit input: A data input //A_IN
.B(B_IN_x1), // 18-bit input: B data input //B_IN
.C(C_x1), // 48-bit input: C data input
.CARRYIN(1'b0), // 1-bit input: Carry input signal
.D(D), // 25-bit input: D data input
 
// Reset/Clock Enable: 1-bit (each) input: Reset/Clock Enable Inputs
.CEA1(1'b1), // 1-bit input: Clock enable input for 1st stage AREG
.CEA2(1'b0), // 1-bit input: Clock enable input for 2nd stage AREG
.CEAD(1'b0), // 1-bit input: Clock enable input for ADREG
.CEALUMODE(1'b1), // 1-bit input: Clock enable input for ALUMODE
.CEB1(1'b1), // 1-bit input: Clock enable input for 1st stage BREG
.CEB2(1'b0), // 1-bit input: Clock enable input for 2nd stage BREG
.CEC(1'b1), // 1-bit input: Clock enable input for CREG

.CECARRYIN(1'b0), // 1-bit input: Clock enable input for CARRYINREG
.CECTRL(1'b1), // 1-bit input: Clock enable input for OPMODEREG and CARRYINSELREG
.CED(1'b1), // 1-bit input: Clock enable input for DREG
.CEINMODE(1'b1), // 1-bit input: Clock enable input for INMODEREG
.CEM(1'b1), // 1-bit input: Clock enable input for MREG
.CEP(1'b1), // 1-bit input: Clock enable input for PREG

.RSTA(rst_x), // 1-bit input: Reset input for AREG
.RSTALLCARRYIN(rst_x), // 1-bit input: Reset input for CARRYINREG
.RSTALUMODE(rst_x), // 1-bit input: Reset input for ALUMODEREG
.RSTB(rst_x), // 1-bit input: Reset input for BREG
.RSTC(rst_x), // 1-bit input: Reset input for CREG
.RSTCTRL(rst_x), // 1-bit input: Reset input for OPMODEREG and CARRYINSELREG
.RSTD(rst_x), // 1-bit input: Reset input for DREG and ADREG
.RSTINMODE(rst_x), // 1-bit input: Reset input for INMODEREG
.RSTM(rst_x), // 1-bit input: Reset input for MREG
.RSTP(rst_x) // 1-bit input: Reset input for PREG
);
/*===================================================================
			  y1 = y_reg + d*(shift(n+1)*x_reg);
====================================================================*/
wire 		[47:0]		cal_x_abs		;
reg 		[47:0]		y_reg_dsp_y1_d	;

assign 	cal_x_abs 		= 	{{2{x_abs[N-1]}},{x_abs[N-2:0]},{(47-N){1'b0}}};
assign 	y_reg_dsp_y1 	= 	P_y1;
 
always @(posedge sclk)
	if(y_a[N-1]==1'b0 && Ninter_cnt_copy1==0)
		y1_add_en 			<=    	1'b0;
	else if(y_a[N-1]==1'b1 && Ninter_cnt_copy1==0)
		y1_add_en 			<=    	1'b1;
	else if(y_reg_dsp_y1[47]==1'b1&&cal_control==1'b0)
		y1_add_en 			<=    	1'b1;
	else if(y_reg_dsp_y1[47]==1'b0&&cal_control==1'b0)
		y1_add_en 			<=    	1'b0;
	else 
		y1_add_en 			<=    	1'b0;

always @(posedge sclk)
	y_reg_dsp_y1_d 			<=   	y_reg_dsp_y1;

always @(*)
	if(Ninter_cnt_copy1==0&&cal_control)
		A_IN_y1 			= 		cal_x_abs[47:18];
	else if(cal_control)
		A_IN_y1 			= 		shift_x_reg[47:18];
	else 
		A_IN_y1	 			= 		30'd0; 

always @(*)
	if(Ninter_cnt_copy1==0&&cal_control)
		B_IN_y1 			= 		cal_x_abs[17:0];
	else if(cal_control == 1'b1)
		B_IN_y1 			= 		shift_x_reg[17:0];
	else 
		B_IN_y1 			= 		30'd0;

always @(*)
	if(Ninter_cnt_copy1==0&&cal_control)
		C_y1 				= 		y1;
	else if(cal_control)
		C_y1 				= 		y_reg_dsp_y1_d;
	else 
		C_y1 				= 		30'd0;

/*=======================================================================
			DSP y1 control :add sub and pattern 
=======================================================================*/
assign INMODE_y1 			= 		5'b00000;

always @(*)
	if(y1_add_en == 1'b1)//C+(A:B)
		OPMODE_y1 			= 		7'b000_11_11;
	else 
		OPMODE_y1 			= 		7'b011_00_11;//C-(A:B)		

always @(*)
	if(y1_add_en == 1'b1)
		ALUMODE_y1 			= 		4'b0000;				
	else
		ALUMODE_y1  		= 		4'b0011;			

/*=======================================================================
			DSP y1 control
=======================================================================*/
DSP48E1 #(
// Feature Control Attributes: Data Path Selection
.A_INPUT("DIRECT"), // Selects A input source, "DIRECT" (A port) or "CASCADE" (ACIN port)
.B_INPUT("DIRECT"), // Selects B input source, "DIRECT" (B port) or "CASCADE" (BCIN port)
.USE_DPORT("FALSE"), // Select D port usage (TRUE or FALSE)
.USE_MULT("NONE"), // Select multiplier usage ("MULTIPLY", "DYNAMIC", or "NONE")
.USE_SIMD("ONE48"), // SIMD selection ("ONE48", "TWO24", "FOUR12")
// Pattern Detector Attributes: Pattern Detection Configuration
.AUTORESET_PATDET("NO_RESET"), // "NO_RESET", "RESET_MATCH", "RESET_NOT_MATCH"
.MASK(48'd0), // 48-bit mask value for pattern detect (1=ignore)
.PATTERN(48'h000000000000), // 48-bit pattern match for pattern detect
.SEL_MASK("MASK"), // "C", "MASK", "ROUNDING_MODE1", "ROUNDING_MODE2"
.SEL_PATTERN("PATTERN"), // Select pattern value ("PATTERN" or "C")
.USE_PATTERN_DETECT("PATDET"), // Enable pattern detect ("PATDET" or "NO_PATDET")

// Register Control Attributes: Pipeline Register Configuration
.ACASCREG(0), // Number of pipeline stages between A/ACIN and ACOUT (0, 1 or 2)
.ADREG(0), // Number of pipeline stages for pre-adder (0 or 1)
.ALUMODEREG(0), // Number of pipeline stages for ALUMODE (0 or 1)
.AREG(0), // Number of pipeline stages for A (0, 1 or 2)
.BCASCREG(0), // Number of pipeline stages between B/BCIN and BCOUT (0, 1 or 2)
.BREG(0), // Number of pipeline stages for B (0, 1 or 2)
.CARRYINREG(0), // Number of pipeline stages for CARRYIN (0 or 1)
.CARRYINSELREG(0), // Number of pipeline stages for CARRYINSEL (0 or 1)
.CREG(0), // Number of pipeline stages for C (0 or 1)
.DREG(0), // Number of pipeline stages for D (0 or 1)
.INMODEREG(0), // Number of pipeline stages for INMODE (0 or 1)
.MREG(0), // Number of multiplier pipeline stages (0 or 1)
.OPMODEREG(0), // Number of pipeline stages for OPMODE (0 or 1)
.PREG(1) // Number of pipeline stages for P (0 or 1)

)

DSP48E1_cal_y1 (
// Cascade: 30-bit (each) output: Cascade Ports
.ACOUT(), // 30-bit output: A port cascade output
.BCOUT(), // 18-bit output: B port cascade output
.CARRYCASCOUT(), // 1-bit output: Cascade carry output
.MULTSIGNOUT(), // 1-bit output: Multiplier sign cascade output
.PCOUT(), // 48-bit output: Cascade output
// Control: 1-bit (each) output: Control Inputs/Status Bits
.OVERFLOW(), // 1-bit output: Overflow in add/acc output
.PATTERNBDETECT(), // 1-bit output: Pattern bar detect output
.PATTERNDETECT(break_cal), // 1-bit output: Pattern detect output
.UNDERFLOW(), // 1-bit output: Underflow in add/acc output

// Data: 4-bit (each) output: Data Ports
.CARRYOUT(), // 4-bit output: Carry output
.P(P_y1), // 48-bit output: Primary data output
// Cascade: 30-bit (each) input: Cascade Ports
.ACIN(30'd0), // 30-bit input: A cascade data input
.BCIN(18'd0), // 18-bit input: B cascade input
.CARRYCASCIN(1'b0), // 1-bit input: Cascade carry input
.MULTSIGNIN(1'b0), // 1-bit input: Multiplier sign input
.PCIN(48'd0), // 48-bit input: P cascade input
// Control: 4-bit (each) input: Control Inputs/Status Bits
.ALUMODE(ALUMODE_y1), // 4-bit input: ALU control input
.CARRYINSEL(3'b000), // 3-bit input: Carry select input
.CLK(sclk), // 1-bit input: Clock input
.INMODE(INMODE_y1), // 5-bit input: INMODE control input
.OPMODE(OPMODE_y1), // 7-bit input: Operation mode input

// Data: 30-bit (each) input: Data Ports
.A(A_IN_y1), // 30-bit input: A data input //A_IN
.B(B_IN_y1), // 18-bit input: B data input //B_IN
.C(C_y1), // 48-bit input: C data input
.CARRYIN(1'b0), // 1-bit input: Carry input signal
.D(), // 25-bit input: D data input
 
// Reset/Clock Enable: 1-bit (each) input: Reset/Clock Enable Inputs
.CEA1(1'b1), // 1-bit input: Clock enable input for 1st stage AREG
.CEA2(1'b0), // 1-bit input: Clock enable input for 2nd stage AREG
.CEAD(1'b0), // 1-bit input: Clock enable input for ADREG
.CEALUMODE(1'b1), // 1-bit input: Clock enable input for ALUMODE
.CEB1(1'b1), // 1-bit input: Clock enable input for 1st stage BREG
.CEB2(1'b0), // 1-bit input: Clock enable input for 2nd stage BREG
.CEC(1'b1), // 1-bit input: Clock enable input for CREG

.CECARRYIN(1'b0), // 1-bit input: Clock enable input for CARRYINREG
.CECTRL(1'b1), // 1-bit input: Clock enable input for OPMODEREG and CARRYINSELREG
.CED(1'b0), // 1-bit input: Clock enable input for DREG
.CEINMODE(1'b1), // 1-bit input: Clock enable input for INMODEREG
.CEM(1'b1), // 1-bit input: Clock enable input for MREG
.CEP(1'b1), // 1-bit input: Clock enable input for PREG

.RSTA(rst), // 1-bit input: Reset input for AREG
.RSTALLCARRYIN(rst), // 1-bit input: Reset input for CARRYINREG
.RSTALUMODE(rst), // 1-bit input: Reset input for ALUMODEREG
.RSTB(rst), // 1-bit input: Reset input for BREG
.RSTC(rst), // 1-bit input: Reset input for CREG
.RSTCTRL(rst), // 1-bit input: Reset input for OPMODEREG and CARRYINSELREG
.RSTD(rst), // 1-bit input: Reset input for DREG and ADREG
.RSTINMODE(rst), // 1-bit input: Reset input for INMODEREG
.RSTM(rst), // 1-bit input: Reset input for MREG
.RSTP(rst) // 1-bit input: Reset input for PREG
);
/*====================================================================*/
//quantize nearest;  z = quantize(q_ang,z - d*atan_z(n+1));
// Ang = -z -/+ pi_quan  ;
/*====================================================================*/


/*=======================================================================
			DSP z control and input
=======================================================================*/
wire 			[29:0]		A_IN_z		;
reg 			[17:0]		B_IN_z		;
reg 			[47:0]		C_IN_z		;
wire 			[47:0]		P_Z			;
reg 			[17:0]		z_dsp_lut_d ;
reg 			[ 6:0]		OPMODE_z	;
reg 						z_add		;
wire 			[ 4:0]		INMODE_z	;
reg 			[ 3:0]		ALUMODE_z	;

assign A_IN_z 		=  		30'd0;//x1[47:18];
assign z_dsp_lut 	= 		P_Z[17:0];
assign INMODE_z 	= 		5'b00000;

always @(*)
	if(cal_control==1'b1)
		B_IN_z 		= 		atanz[17:0];
	else 
		B_IN_z 		= 		18'd0;

always @(*)
	if(Ninter_cnt_copy1==0)
		C_IN_z 		= 		48'd0;
	else if(cal_control==1'b1)
		C_IN_z 		= 		{30'd0,z_dsp_lut_d};
	else 
		C_IN_z		= 		48'd0;


always @(posedge sclk)
	z_dsp_lut_d 	<=   	P_Z[17:0];

always @(posedge sclk)
	if(y_a[N-1]==1'b0 && Ninter_cnt_copy1==0)
		z_add 		<=    	1'b1;
	else if(y_a[N-1]==1'b1 && Ninter_cnt_copy1==0)
		z_add 		<=    	1'b0;
	else if(y_reg_dsp_y1[47]==1'b1&&cal_control==1'b0)
		z_add 		<=   	1'b0;
	else if(y_reg_dsp_y1[47]==1'b0&&cal_control==1'b0)
		z_add 		<=   	1'b1;		
	else 
		z_add 		<=    	z_add;

always @(*)
	if(z_add == 1'b1)//C+(A:B)
		OPMODE_z 	=		7'b000_11_11;
	else 
		OPMODE_z 	= 		7'b011_00_11;//C-(A:B)			

always @(*)
	if(z_add == 1'b1)
		ALUMODE_z	= 		4'b0000;				
	else
		ALUMODE_z  	= 		4'b0011;			 

wire 			rst_z 					;
assign 			rst_z 		= 		rst_x;
DSP48E1 #(
// Feature Control Attributes: Data Path Selection
.A_INPUT("DIRECT"), // Selects A input source, "DIRECT" (A port) or "CASCADE" (ACIN port)
.B_INPUT("DIRECT"), // Selects B input source, "DIRECT" (B port) or "CASCADE" (BCIN port)
.USE_DPORT("FALSE"), // Select D port usage (TRUE or FALSE)
.USE_MULT("NONE"), // Select multiplier usage ("MULTIPLY", "DYNAMIC", or "NONE")
.USE_SIMD("ONE48"), // SIMD selection ("ONE48", "TWO24", "FOUR12")
// Pattern Detector Attributes: Pattern Detection Configuration
.AUTORESET_PATDET("NO_RESET"), // "NO_RESET", "RESET_MATCH", "RESET_NOT_MATCH"
.MASK(48'd0), // 48-bit mask value for pattern detect (1=ignore)
.PATTERN(48'h000000000000), // 48-bit pattern match for pattern detect
.SEL_MASK("MASK"), // "C", "MASK", "ROUNDING_MODE1", "ROUNDING_MODE2"
.SEL_PATTERN("PATTERN"), // Select pattern value ("PATTERN" or "C")
.USE_PATTERN_DETECT("NO_PATDET"), // Enable pattern detect ("PATDET" or "NO_PATDET")

// Register Control Attributes: Pipeline Register Configuration
.ACASCREG(0), // Number of pipeline stages between A/ACIN and ACOUT (0, 1 or 2)
.ADREG(0), // Number of pipeline stages for pre-adder (0 or 1)
.ALUMODEREG(0), // Number of pipeline stages for ALUMODE (0 or 1)
.AREG(0), // Number of pipeline stages for A (0, 1 or 2)
.BCASCREG(0), // Number of pipeline stages between B/BCIN and BCOUT (0, 1 or 2)
.BREG(0), // Number of pipeline stages for B (0, 1 or 2)
.CARRYINREG(0), // Number of pipeline stages for CARRYIN (0 or 1)
.CARRYINSELREG(0), // Number of pipeline stages for CARRYINSEL (0 or 1)
.CREG(0), // Number of pipeline stages for C (0 or 1)
.DREG(0), // Number of pipeline stages for D (0 or 1)
.INMODEREG(0), // Number of pipeline stages for INMODE (0 or 1)
.MREG(0), // Number of multiplier pipeline stages (0 or 1)
.OPMODEREG(0), // Number of pipeline stages for OPMODE (0 or 1)
.PREG(1) // Number of pipeline stages for P (0 or 1)

)

DSP48E1_cal_z (
// Cascade: 30-bit (each) output: Cascade Ports
.ACOUT(), // 30-bit output: A port cascade output
.BCOUT(), // 18-bit output: B port cascade output
.CARRYCASCOUT(), // 1-bit output: Cascade carry output
.MULTSIGNOUT(), // 1-bit output: Multiplier sign cascade output
.PCOUT(), // 48-bit output: Cascade output
// Control: 1-bit (each) output: Control Inputs/Status Bits
.OVERFLOW(), // 1-bit output: Overflow in add/acc output
.PATTERNBDETECT(), // 1-bit output: Pattern bar detect output
.PATTERNDETECT(), // 1-bit output: Pattern detect output
.UNDERFLOW(), // 1-bit output: Underflow in add/acc output

// Data: 4-bit (each) output: Data Ports
.CARRYOUT(), // 4-bit output: Carry output
.P(P_Z), // 48-bit output: Primary data output
// Cascade: 30-bit (each) input: Cascade Ports
.ACIN(30'd0), // 30-bit input: A cascade data input
.BCIN(18'd0), // 18-bit input: B cascade input
.CARRYCASCIN(1'b0), // 1-bit input: Cascade carry input
.MULTSIGNIN(1'b0), // 1-bit input: Multiplier sign input
.PCIN(48'd0), // 48-bit input: P cascade input
// Control: 4-bit (each) input: Control Inputs/Status Bits
.ALUMODE(ALUMODE_z), // 4-bit input: ALU control input
.CARRYINSEL(3'b000), // 3-bit input: Carry select input
.CLK(sclk), // 1-bit input: Clock input
.INMODE(INMODE_z), // 5-bit input: INMODE control input
.OPMODE(OPMODE_z), // 7-bit input: Operation mode input

// Data: 30-bit (each) input: Data Ports
.A(A_IN_z), // 30-bit input: A data input //A_IN
.B(B_IN_z), // 18-bit input: B data input //B_IN
.C(C_IN_z), // 48-bit input: C data input
.CARRYIN(1'b0), // 1-bit input: Carry input signal
.D(25'd0), // 25-bit input: D data input
 
// Reset/Clock Enable: 1-bit (each) input: Reset/Clock Enable Inputs
.CEA1(1'b1), // 1-bit input: Clock enable input for 1st stage AREG
.CEA2(1'b0), // 1-bit input: Clock enable input for 2nd stage AREG
.CEAD(1'b0), // 1-bit input: Clock enable input for ADREG
.CEALUMODE(1'b1), // 1-bit input: Clock enable input for ALUMODE
.CEB1(1'b1), // 1-bit input: Clock enable input for 1st stage BREG
.CEB2(1'b0), // 1-bit input: Clock enable input for 2nd stage BREG
.CEC(1'b1), // 1-bit input: Clock enable input for CREG

.CECARRYIN(1'b0), // 1-bit input: Clock enable input for CARRYINREG
.CECTRL(1'b1), // 1-bit input: Clock enable input for OPMODEREG and CARRYINSELREG
.CED(1'b0), // 1-bit input: Clock enable input for DREG
.CEINMODE(1'b1), // 1-bit input: Clock enable input for INMODEREG
.CEM(1'b1), // 1-bit input: Clock enable input for MREG
.CEP(1'b1), // 1-bit input: Clock enable input for PREG

.RSTA(rst_z), // 1-bit input: Reset input for AREG
.RSTALLCARRYIN(rst_z), // 1-bit input: Reset input for CARRYINREG
.RSTALUMODE(rst_z), // 1-bit input: Reset input for ALUMODEREG
.RSTB(rst_z), // 1-bit input: Reset input for BREG
.RSTC(rst_z), // 1-bit input: Reset input for CREG
.RSTCTRL(rst_z), // 1-bit input: Reset input for OPMODEREG and CARRYINSELREG
.RSTD(rst_z), // 1-bit input: Reset input for DREG and ADREG
.RSTINMODE(rst_z), // 1-bit input: Reset input for INMODEREG
.RSTM(rst_z), // 1-bit input: Reset input for MREG
.RSTP(rst_z) // 1-bit input: Reset input for PREG
);

always @(posedge sclk)
	if(!rst_n)	
		z_dsp_lut_delay1 			<=   		0;
	else if(break_happen==1'b1&&first_break_happen==1'b0)
		z_dsp_lut_delay1 			<=   		z_dsp_lut;
	else  if(Ninter_cnt_copy1[3:0]==Ninter&&cal_control&&break_out==1'b0)
		z_dsp_lut_delay1 			<=   		z_dsp_lut_d;

always @(posedge sclk)
	if(!rst_n)
		z 							<=   		0;
	else if(break_happen==1'b1&&first_break_happen==1'b0)
		z 							<=   		(~z_dsp_lut[17:0])+1'b1;	
	else if(Ninter_cnt_copy1[3:0]==Ninter&&cal_control&&break_out==1'b0)
		z 							<=   		(~z_dsp_lut_d[17:0])+1'b1;
	else
		z 							<=   		z;

always @(posedge sclk)
	if(!rst_n)
		Ang 						<=    		0;
	else if(y_a==0&&x_a[N-1]==1'b0)
		Ang 						<=    		0;
	else if(y_a==0&&x_a[N-1]==1'b1)
		Ang 						<=    		18'b011001001000100000;
	else if(Ninter_cnt_copy1==Ninter+1 && x_sign && y_sign)
		Ang 						<=    		z - 18'b011001001000100000;		
	else if(Ninter_cnt_copy1==Ninter+1 && x_sign && y_sign==0)
		Ang 						<=    		z + 18'b011001001000100000;	
	else if(Ninter_cnt_copy1==Ninter+1)
		Ang 						<=    		z_dsp_lut_delay1;	
	else 
		Ang 						<=    		Ang;

always @(posedge sclk)
	if(Ninter_cnt_copy1==4'he&&cal_control==1'b0)
		Ang_en 						<=   		1'b1;
	else 
		Ang_en 						<=   		1'b0;

endmodule

上面的代码为了限制使用DSP的数目，所以使用了DSP原语，这也是导致代码长度过长的原因。如果我们不考虑使用DSP原语而是让编译器自动帮我们进行编译综合，那么我代码可以精简到300行。至于DSP原语的使用这里不再赘述，个人感觉吃力不讨好，当然不排除自己人太菜没达到那种逼格。我们这里重点关注一下MATLAB与FPGA之间量化的对应。
ang在MATLAB中的量化：

对应在FPGA中的处理：

这里需要注意FPGA默认的量化截取方式与下面对应：

amp在MATLAB中的量化：

ang在MATLAB中的量化：

其实就是直接截取了低位，关于量化的操作在FPGA与MATLAB数据相互对应的方面是特别重要的。

这里简要总结一下就是FPGA自己计算的就是：

如果我们进行了截位就是：

MATLAB测试代码

这里我们给出MATLAB测试代码用来对比MATLAB与Modelsim两者仿真之间代码的一致性，代码如下：

clc;
clear all;

fid1 = fopen('Ang_matlab.txt','r');
x_fix = fscanf(fid1,'%d');  

fid2 = fopen('Amp_matlab.txt','r');
y_fix = fscanf(fid2,'%d');  

fid3 = fopen('Ang_fpga.txt','r');
x_fpga = fscanf(fid3,'%d');  

fid4 = fopen('Amp_fpga.txt','r');
y_fpga = fscanf(fid4,'%d');  

sum1 = sum(abs(x_fix - x_fpga));
sum2 = sum(abs(y_fix - y_fpga));

结果如下：

从上面实验验证了我们实验的正确性。

总结

创作不易，认为文章有帮助的同学们可以关注、点赞、转发支持。为行业贡献及其微小的一部分。或者对文章有什么看法或者需要更近一步交流的同学，可以加入下面的群：

你可能感兴趣的:(FPGA)

DSP和ARM的优劣比较（也有FPGA） bingfeng_adonis 工作
概念1.FPGA:是可编程逻辑阵列，常用于处理高速数字信号，不过随着科技的发展，现在很多FPGACPLD可以集成mcu内核，甚至具备了ARMDSP的功能2.ARM,是一类内核的称谓，就像51一样，具体到芯片的话，会有很多不同的厂家不同等级，诸如三星、易法、飞利浦、摩托罗拉等等，其中STM32是易法半导体的一款面向工控低功耗内核为CortexM3内核的ARM芯片3.DSP顾名思义就是数字信号处理，厂
【教程4＞第5章＞第28节】基于帧同步+相位同步+位同步的QPSK调制解调通信系统整体性能分析 fpga和matlab #fpga开发帧同步+相位同步+位同步 QPSK 教程4
欢迎订阅FPGA/MATLAB/Simulink系列教程《★教程1:matlab入门100例》《★教程2:fpga入门100例》《★教程3:simulink入门60例》《★教程4:FPGA/MATLAB/Simulink联合开发入门与进阶X例》目录1.软件版本2.系统资源占用3.系统性能分析3.1信噪比设置3.2时偏设置3.3相位偏差设置4.总结
【PCIe XDMA开发】Windows环境下再也不用重启电脑了 RunningCamel PCIe fpga开发 FPGA Xilinx
Windows环境下开发，使用FPGA开发PCIeXDMA驱动，重新下载bit文件后，通常会遇到主机无法识别到固件更改的问题。一般有以下方式，可以解决识别问题：1.热重启（HotReset）适用场景：FPGA固件通过bit文件临时加载（未固化到Flash）。操作步骤：在主机开机状态下，断开并重新连接FPGA开发板的电源。再次执行硬件扫描。右键点击“此电脑”→“管理”→“设备管理器”。点击顶部菜单栏
串行通信接口-Modbus通信 FPGArea FPGA通信接口 fpga开发 Modbus RS-485 UART
文章目录1.Modbus介绍1.1协议模型1.2网络拓扑1.3帧结构1.4通讯模型1.5寄存器类型1.6功能码2.搭建实验环境3.FPGA实现3.1接收端3.1.1接收状态机3.1.2数据缓存3.1.3接口设计3.2发送端3.2.1发送状态机3.2.2数据缓存3.2.3接口设计4.传送门1.Modbus介绍1.1协议模型Modbus协议是一种用于工业控制的网络通讯协议，即一种机器与机器之间进行数据
『FPGA开发必备技能』汇总导航 FPGArea FPGA开发必备技能 fpga开发 FPGA Vivado Xilinx
※Welcome大家好，欢迎来到瑾芳玉洁的博客！励志开源分享诗和代码，三餐却无汤，顿顿都被噎。有幸结识那个值得被认真、被珍惜、被捧在手掌心的女孩，不出意外被敷衍、被唾弃、被埋在了垃圾堆。喜欢舞文弄墨咬文嚼字的混沌世界，懵懂无知走上了工科直男01的不归路。八十公斤的体重勉强与大鹏一日同风起的浮力动态平衡，做不到宠辱不惊无欲无求的匀速直线运动，就按部就班的小波浪式前进，螺旋式蠕动。<我是一名专注于FP
fpga原理和结构 pdf_一文带你认识FPGA~ weixin_39849888 fpga原理和结构 pdf fpga芯片架构设计与实现 pdf
在我们嵌入式中，有这样一朵奇葩介于软件与硬件之间，这朵奇葩就是FPGA。可能很多平时玩MCU比较多的朋友不太了解。之前我也不太了解，但是最近两年的这两份工作都有与FPGA挂钩，所以我精通FPGA程序的烧写(不仅如此，我还精通电脑的开关机，哈哈)：下面我们一起来简单了解一下。什么是FPGAFPGA(FieldProgrammableGateArray)，即现场可编程逻辑门阵列，属于专用集成电路中的一
fpga原理和结构 pdf_FPGA最小系统的设计方法 weixin_39998795 fpga原理和结构 pdf
FPGA最小系统是可以使FPGA正常工作的最简单的系统。它的外围电路尽量最少，只包括FPGA必要的控制电路。一般所说的FPGA的最小系统主要包括FPGA芯片、下载电路、外部时钟、复位电路和电源。如果需要使用SOPC软嵌入式处理器还要包括SDRAM和Flash。一般以上这些组件是FPGA最小系统的组成部分。本文以EP2C8Q208C8为主芯片进行FPGA最小系统的设计。FPGA芯片管脚介绍对于需要在
简述fpga的原理和结构_几组实用FPGA原理设计图 Tengfei Jiang 简述fpga的原理和结构
FPGA(Field－ProgrammableGateArray)，即现场可编程门阵列，它是在PAL、GAL、CPLD等可编程器件的基础上进一步发展的产物。它是作为专用集成电路(ASIC)领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。FPGA的开发相对于传统PC、单片机的开发有很大不同。FPGA以并行运算为主，以硬件描述语言来实现；相比于PC或单
国产化板卡设计原理图：2288-基于FMC接口的JFM7K325T PCIeX4 3U VPX接口卡 hexiaoyan827 3U VPX FMC子卡 JFM7K325T板卡软件无线电处理平台数据采集IO卡
基于FMC接口的JFM7K325TPCIeX43UVPX接口卡一、板卡概述标准VPX3U板卡，基于JFM7K325T芯片，pin_to_pin兼容FPGAXC7K410T-2FFG900，支持PCIeX8、64bitDDR3容量2GByte，HPC的FMC连接器，板卡支持各种接口输入，软件支持windows，Linux驱动。可应用于高性能计算，频域算法，如与FFT的加速等；配合AD，DAFMC子卡
Altera PDN 设计和 FPGA 收发器性能 FPGA技术实战 Xinx FPGA硬件设计 FPGA 收发器电源
本文档介绍在电源分配网络(PDN)设计中采用现代开关稳压器的优势，利用这些优势获得最佳FPGA收发器性能。本白皮书为怎样在低噪声应用中选择稳压器提供指南，还包括一个测试案例，展示不同类型稳压器和电源线配置的收发器性能。引言：面向收发器(SERDES)FPGA的PDN设计对电源有严格的要求，需要干净的电压源。虽然低功耗应用中通常采用低泄漏(LDO)线性稳压器，但这一方法必须仔细的隔离电压源。电路板设
FPGA状态机设计 FPGA小学生 fpga 状态机 verilog
B站对应讲解本文视频链接状态机：状态机是逻辑设计里面重要的内容，许多公司的硬件和逻辑工程师面试中，状态机设计几乎是必选题目。所以本次以状态机为话题进行重点讨论，以及如何写好状态机。状态机全称是有限状态机（FiniteStateMachine、FSM），是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。本篇博客对相关概念以及使用状态机实现特定字符串的检测，并通过程序具体理解一段式、两段
《解锁AI芯片新境界：提升专用人工智能芯片通用性与灵活性的热点技术》程序猿阿伟人工智能
在人工智能飞速发展的当下，专用人工智能芯片虽在特定任务上表现出色，但提升其通用性和灵活性已成为行业关键课题。以下是一些相关的热点技术。可重构架构技术可重构架构允许芯片在运行时根据不同任务需求动态改变自身的硬件结构和功能。如现场可编程门阵列（FPGA），内部有大量可配置逻辑单元和布线资源，用户能通过编程实现不同的逻辑功能，可针对不同的人工智能算法和应用场景快速重构，像在图像识别和自然语言处理任务间灵
spi iic和串口的区别_IIC协议解释 weixin_39995943 spi iic和串口的区别两个单片机iic通讯程序模拟iic和硬件iic区别
欢迎FPGA工程师加入官方微信技术群点击蓝字关注我们FPGA之家-中国最好的纯工程师社群(1)概述I2C(Inter-IntegratedCircuitBUS)集成电路总线，该总线由NXP(原PHILIPS)公司设计，多用于主控制器和从器件间的主从通信，在小数据量场合使用，传输距离短，任意时刻只能有一个主机等特性。经常ＩＩＣ和ＳＰＩ接口被认为指定是一种硬件设备，但其实这样的说法是不尽准确的，严格的
均薪23W还缺人，FPGA工程师到底有多重要? 博览鸿蒙 FPGA fpga开发
近两年，随着FPGA行业的快速发展，FPGA工程师的需求量持续增长。FPGA技术在通信、人工智能、自动驾驶、数据中心等领域的广泛应用，使得这一岗位变得尤为重要。尤其是在高性能计算、边缘计算等场景下，FPGA凭借其高并行计算能力和灵活性，成为不可或缺的技术方案。FPGA工程师的核心职责FPGA工程师主要负责FPGA的开发、调试和优化，具体包括：逻辑设计与实现：使用Verilog/VHDL等硬件描述语
点亮你的LED灯张口口 fpga开发
一、前言对于每一个FPGA的初学者，经过一段时间的理论学习后，都会有跃跃欲试的感觉，迫不及待的想通过建立一个完整的工程来验证软件安装是否正确，验证综合编译的流程是否正确，以及成功上板的喜悦感。点亮一个LED灯似乎是大多数人的选择，我的记录生涯也从点亮第一个LED开始吧。二、程序RTL代码`timescale1ns/1nsmoduleled(outputwireled_out//点亮你的LED灯);
Verilog 实现 FPGA 复杂算法的案例百态老人 fpga开发
在数字电路设计领域，FPGA（现场可编程门阵列）因其灵活性和高性能而备受青睐。有许多利用Verilog实现FPGA复杂算法的案例。例如，有一个项目是在FPGA中用Verilog实现开方运算。该项目充分利用Verilog的强大功能，通过深入理解FPGA的内部结构优化代码资源利用率，采用经典数学算法确保计算结果的准确性和高效性。具有高效性、可移植性和易用性等优势，适用于对实时性要求较高的应用场景，为开
FPGA极易入门教程----数码管篇（1）静态显示_数码管静态显示 2401_87555332 fpga开发
图2：共阴极数码管显示数字“1”其他数字的演示就不做了，根据这个原理可以整理出0~9这10个数字的编码方式（适用共阳极，共阴极只要将编码取反即可）：图3：共阳极数码管编码表这里涉及到两个概念：段选：单个数码管的二极管控制信号（a~g），控制段选可以实现数码管显示不同的数字位选：单个数码管的“电源开关”信号，只有在位选有效的情况下（有电情况下），控制数码管的段选才有意义也就是说通过控制位选可以控制数
AUTOSAR汽车电子嵌入式编程精讲300篇-基于FPGA的CAN FD汽车总线数据交互系统设计格图素书 fpga开发汽车
目录前言汽车总线以及发展趋势汽车总线技术汽车总线发展趋势CANFD总线国内外研究现状2系统方案及CANFD协议分析2.1系统控制方案设计2.2CANFD总线帧结构分析2.2.1数据帧分析2.2.2远程帧分析2.2.3过载帧分析2.2.4错误帧分析2.2.5帧间隔分析2.3位流编码以及位时序分析2.3.1位流编码分析2.3.2位时间分析2.3.3位时间切换及位同步分析本文篇幅较长，分为上中下三篇，文
Verilog 语法篇硬件描述语言 7yewh 【FPGA 知识点笔记汇总】fpga开发硬件工程驱动开发 arm开发物联网 iot
Verilog是一种硬件描述语言，用于设计、模拟和综合数字电路和系统。它主要用于描述ASIC（专用集成电路）或FPGA（现场可编程门阵列）等硬件设备的结构和行为。定义与用途：Verilog是一种硬件描述语言（HDL），主要用于数字电路的建模、仿真、综合与验证。设计人员利用它来描述电路的结构、行为以及时序关系，从而生成实际的硬件电路（如FPGA或ASIC）。发展背景：1984年，PhilMoorby
Xilinx 7系列FPGA架构之时钟资源（一） FPGA技术实战 FPGA器件架构 Xinx FPGA硬件设计 FPGA 架构时钟时钟输入
引言：从本文开始，我们陆续介绍Xilinx7系列FPGA的时钟资源架构，熟练掌握时钟资源对于FPGA硬件设计工程师及软件设计工程师都非常重要。本章概述7系列FPGA时钟，比较了7系列FPGA时钟和前几代FPGA差异，总结7系列FPGA中的时钟连接。有关7系列FPGA时钟资源使用的详细信息，请关注后续文章。时钟资源架构概述7系列FPGA与前一代FPGA时钟资源差异时钟资源连接概述1.时钟资源架构概述
FPGA与ASIC：到底选哪个好？博览鸿蒙 FPGA fpga开发
不少人想转行FPGA，但在ASIC和FPGA之间犹豫不决。要做出选择，首先需要清楚两者的区别和各自特点。FPGA(FieldProgrammableGateArray)是一种现场可编程门阵列芯片，本质上它是一种半定制的芯片，可以根据需要重新编程，以适应不同的功能需求。FPGA兼具硬件和软件的特点，可以在硬件层面进行控制，也可以编程实现算法功能，具有较高的灵活性和快速开发的优势。而ASIC(Appl
入行FPGA设计工程师需要提前学习哪些内容？博览鸿蒙 FPGA fpga开发
FPGA作为一种灵活可编程的硬件平台，广泛应用于嵌入式系统、通信、数据处理等领域。很多人选择转行FPGA设计工程师，但对于新手来说，可能在学习过程中会遇到一些迷茫和困惑。为了帮助大家更好地准备，本文将详细介绍入行FPGA设计工程师所需学习的内容。FPGA设计的重要性FPGA设计是硬件设计中非常重要的一环，具有高灵活性、快速的验证周期以及较短的产品上市时间等优势。相较于ASIC，FPGA设计不需要进
星辰——人工智能中台 jingmuxu123 人工智能自然语言处理 nlp
星辰闪耀，赋能不止。2020年，智慧眼AILab正式发布并启用新一代人工智能平台—星辰人工智能中台。星辰人工智能中台主要包括算力层、容器层、引擎层和能力层四部分，为行业智能应用提供AI能力支撑的统一共享服务平台，满足了人工智能算法场景的高度定制化需求。人工智能中台四个部分介绍算力层面：可以实现对众多CPU、GPU、FPGA和ARM等国内外计算资源进行有机整合。容器层面：支持和数据中台进行无缝对接，
（16）System Verilog联合体union详解宁静致远dream System Verilog教程 stm32 深度学习机器学习
（16）SystemVerilog联合体union详解1.1目录1）目录2）FPGA简介3）SystemVerilog简介4）SystemVerilog联合体union详解5）结语1.2FPGA简介FPGA（FieldProgrammableGateArray）是在PAL、GAL等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的
FPGA约束：如何生成时钟多路复用器及时钟约束？编码实践 fpga开发 matlab
FPGA约束：如何生成时钟多路复用器及时钟约束？在现代数字电路设计中，高速信号的传输对时钟信号的要求非常严格。设计者通常需要生成各种时钟信号，并为其指定合适的时钟约束。为了优化资源使用，FPGA中经常使用时钟多路复用器来同时提供多个时钟。本文将介绍如何使用VerilogHDL编写时钟多路复用器，并为其生成合适的时钟约束。时钟多路复用器的实现代码如下所示：moduleclk_mux#(paramet
（52）多路时钟复用FPGA如何约束一（片外时钟复用约束）宁静致远dream FPGA求职核心竞争力 fpga开发被问的面试题求职路上
1.1多路时钟复用FPGA如何约束一（片外时钟复用约束）1.1.1本节目录1）本节目录；2）本节引言；3）FPGA简介；4）多路时钟复用FPGA如何约束一（片外时钟复用约束）；5）结束语。1.1.2本节引言“不积跬步，无以至千里；不积小流，无以成江海。就是说：不积累一步半步的行程，就没有办法达到千里之远；不积累细小的流水，就没有办法汇成江河大海。1.1.3FPGA简介FPGA（FieldProgr
多路复用时钟和双沿时钟 Hack电子 fpga开发单片机嵌入式硬件
关注、星标公众号，精彩内容每日送达来源：网络素材时钟多路器用于使同一个逻辑功能具有不同的时钟，比如在通信系统中，为了适应不同的数据速率要求，经常要进行时钟切换。有时为了节约功耗，也会把高速时钟切换到低速时钟，或者进行时钟休眠操作。下图是某一类型的时钟多路器：虽然在时钟信号上引入多路逻辑会产生毛刺等问题，但是在不同的应用中，对多路时钟的要求区别很大。时钟切换的最佳途径是使用FPGA内部的专用Cloc
多路时钟复用FPGA约束和实现 MZEing fpga开发
多路时钟复用FPGA约束和实现多路时钟复用（Multi-ClockMultiplexing）是一种常见的技术，在FPGA设计中用于管理多个时钟域。通过合理使用多路时钟复用技术，可以有效减少资源消耗，并简化时钟域交叉问题的处理。本文将介绍多路时钟复用的约束方法，并提供相应的源代码示例。时钟域划分（ClockDomainPartitioning）多路时钟复用的第一步是将设计中的信号划分到不同的时钟域。
厚物科技PXIe/PXI一体化测控平台HW-1043d 厚物科技 PXIe/PXI/VPX 集成测试自动化产品运营科技
PXIe测控系列HW-1043d专为各种测试和测量应用而设计自带嵌入式控制器控制功能及扩展功能一体化设计外部IO接口丰富内置Intel®Core™第七代双核四线程CPU内存最大支持32GB提供4个3UPXIe/PXI混合扩展槽第4槽支持双槽宽的PXIe/PXI功能模块可内置数采、航空总线、FPGA、射频及开关等功能模块系统带温控电路对风扇进行PWM转速控制散热设计符合PXIe/PXI总线规范支撑仰
Intel 与 Yocto 项目的深度融合：全面解析与平台对比嵌入式Jerry Yocto linux 嵌入式硬件 eureka 容器 docker
在嵌入式Linux领域，Yocto项目已成为构建定制化Linux发行版的事实标准，广泛应用于不同架构的SoC平台。Intel作为x86架构的领导者，在Yocto生态中投入了大量资源，为其嵌入式处理器、FPGA和AI加速硬件提供了完整的支持。本文将详细介绍Intel如何在Yocto项目中构建、优化和维护其嵌入式Linux解决方案，并与其他芯片平台（如NXP、AMD、RaspberryPi）进行对比，
多线程编程之存钱与取钱周凡杨 java thread 多线程存钱取钱
生活费问题是这样的：学生每月都需要生活费，家长一次预存一段时间的生活费，家长和学生使用统一的一个帐号，在学生每次取帐号中一部分钱，直到帐号中没钱时通知家长存钱，而家长看到帐户还有钱则不存钱，直到帐户没钱时才存钱。问题分析：首先问题中有三个实体，学生、家长、银行账户，所以设计程序时就要设计三个类。其中银行账户只有一个，学生和家长操作的是同一个银行账户，学生的行为是
java中数组与List相互转换的方法征客丶 JavaScript java jsonp
1.List转换成为数组。（这里的List是实体是ArrayList) 　　调用ArrayList的toArray方法。　　toArray 　　public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。如果列表能放入指定的数组，则返回放入此列表元素的数组。否则，将根据指定数组的运行时类型和此列表的大小分
Shell 流程控制 daizj 流程控制 if else while case shell
Shell 流程控制和Java、PHP等语言不一样，sh的流程控制不可为空，如(以下为PHP流程控制写法)： <?php if(isset($_GET["q"])){ search(q);}else{// 不做任何事情} 在sh/bash里可不能这么写，如果else分支没有语句执行，就不要写这个else，就像这样 if else if if 语句语
Linux服务器新手操作之二周凡杨 Linux 简单操作
1.利用关键字搜寻Man Pages man -k keyword 其中-k 是选项，keyword是要搜寻的关键字如果现在想使用whoami命令，但是只记住了前3个字符who，就可以使用 man -k who来搜寻关键字who的man命令 [haself@HA5-DZ26 ~]$ man -k
socket聊天室之服务器搭建朱辉辉33 socket
因为我们做的是聊天室，所以会有多个客户端，每个客户端我们用一个线程去实现，通过搭建一个服务器来实现从每个客户端来读取信息和发送信息。我们先写客户端的线程。 public class ChatSocket extends Thread{ Socket socket; public ChatSocket(Socket socket){ this.sock
利用finereport建设保险公司决策分析系统的思路和方法老A不折腾 finereport 金融保险分析系统报表系统项目开发
决策分析系统呈现的是数据页面，也就是俗称的报表，报表与报表间、数据与数据间都按照一定的逻辑设定，是业务人员查看、分析数据的平台，更是辅助领导们运营决策的平台。底层数据决定上层分析，所以建设决策分析系统一般包括数据层处理（数据仓库建设）。项目背景介绍通常，保险公司信息化程度很高，基本上都有业务处理系统（像集团业务处理系统、老业务处理系统、个人代理人系统等）、数据服务系统（通过
始终要页面在ifream的最顶层林鹤霄
index.jsp中有ifream，但是session消失后要让login.jsp始终显示到ifream的最顶层。。。始终没搞定，后来反复琢磨之后，得到了解决办法，在这儿给大家分享下。。 index.jsp--->主要是加了颜色的那一句 <html> <iframe name="top" ></iframe> <ifram
MySQL binlog恢复数据 aigo mysql
1，先确保my.ini已经配置了binlog： # binlog log_bin = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.log log_bin_index = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.index log_error = D:/mysql-5.6.21-win
OCX打成CBA包并实现自动安装与自动升级 alxw4616 ocx cab
近来手上有个项目,需要使用ocx控件 (ocx是什么? http://baike.baidu.com/view/393671.htm) 在生产过程中我遇到了如下问题. 1. 如何让 ocx 自动安装? a) 如何签名? b) 如何打包? c) 如何安装到指定目录? 2.
Hashmap队列和PriorityQueue队列的应用百合不是茶 Hashmap队列 PriorityQueue队列
HashMap队列已经是学过了的,但是最近在用的时候不是很熟悉,刚刚重新看以一次, HashMap是K,v键 ,值 put()添加元素 //下面试HashMap去掉重复的 package com.hashMapandPriorityQueue; import java.util.H
JDK1.5 returnvalue实例 bijian1013 java thread java多线程 returnvalue
Callable接口：返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。 Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。 ExecutorService接口方
angularjs指令中动态编译的方法(适用于有异步请求的情况) 内嵌指令无效 bijian1013 JavaScript AngularJS
在directive的link中有一个$http请求，当请求完成后根据返回的值动态做element.append('......');这个操作，能显示没问题，可问题是我动态组的HTML里面有ng-click，发现显示出来的内容根本不执行ng-click绑定的方法！
【Java范型二】Java范型详解之extend限定范型参数的类型 bit1129 extend
在第一篇中，定义范型类时，使用如下的方式： public class Generics<M, S, N> { //M,S,N是范型参数 } 这种方式定义的范型类有两个基本的问题： 1. 范型参数定义的实例字段，如private M m = null;由于M的类型在运行时才能确定，那么我们在类的方法中，无法使用m，这跟定义pri
【HBase十三】HBase知识点总结 bit1129 hbase
1. 数据从MemStore flush到磁盘的触发条件有哪些？ a.显式调用flush，比如flush 'mytable' b.MemStore中的数据容量超过flush的指定容量，hbase.hregion.memstore.flush.size,默认值是64M 2. Region的构成是怎么样？ 1个Region由若干个Store组成
服务器被DDOS攻击防御的SHELL脚本 ronin47
mkdir /root/bin vi /root/bin/dropip.sh #!/bin/bash/bin/netstat -na|grep ESTABLISHED|awk ‘{print $5}’|awk -F:‘{print $1}’|sort|uniq -c|sort -rn|head -10|grep -v -E ’192.168|127.0′|awk ‘{if($2!=null&a
java程序员生存手册-craps 游戏-一个简单的游戏 bylijinnan java
import java.util.Random; public class CrapsGame { /** * *一个简单的赌*博游戏，游戏规则如下： *玩家掷两个骰子，点数为1到6，如果第一次点数和为7或11，则玩家胜， *如果点数和为2、3或12，则玩家输， *如果和为其它点数，则记录第一次的点数和，然后继续掷骰，直至点数和等于第一次掷出的点
TOMCAT启动提示NB: JAVA_HOME should point to a JDK not a JRE解决开窍的石头 JAVA_HOME
当tomcat是解压的时候，用eclipse启动正常，点击startup.bat的时候启动报错; 报错如下： The JAVA_HOME environment variable is not defined correctly This environment variable is needed to run this program NB: JAVA_HOME shou
[操作系统内核]操作系统与互联网 comsci 操作系统
我首先申明：我这里所说的问题并不是针对哪个厂商的，仅仅是描述我对操作系统技术的一些看法操作系统是一种与硬件层关系非常密切的系统软件，按理说，这种系统软件应该是由设计CPU和硬件板卡的厂商开发的，和软件公司没有直接的关系，也就是说，操作系统应该由做硬件的厂商来设计和开发
富文本框ckeditor_4.4.7 文本框的简单使用支持IE11 cuityang 富文本框
<html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <title>知识库内容编辑</tit
Property null not found darrenzhu datagrid Flex Advanced propery null
When you got error message like "Property null not found ***", try to fix it by the following way: 1)if you are using AdvancedDatagrid, make sure you only update the data in the data prov
MySQl数据库字符串替换函数使用 dcj3sjt126com mysql 函数替换
需求：需要将数据表中一个字段的值里面的所有的 . 替换成 _ 原来的数据是 site.title site.keywords .... 替换后要为 site_title site_keywords 使用的SQL语句如下： updat
mac上终端起动MySQL的方法 dcj3sjt126com mysql mac
首先去官网下载: http://www.mysql.com/downloads/ 我下载了5.6.11的dmg然后安装,安装完成之后..如果要用终端去玩SQL.那么一开始要输入很长的:/usr/local/mysql/bin/mysql 这不方便啊,好想像windows下的cmd里面一样输入mysql -uroot -p1这样...上网查了下..可以实现滴. 打开终端,输入: 1
Gson使用一（Gson） eksliang json gson
转载请出自出处：http://eksliang.iteye.com/blog/2175401 一.概述从结构上看Json，所有的数据（data）最终都可以分解成三种类型：第一种类型是标量（scalar），也就是一个单独的字符串（string）或数字（numbers），比如"ickes"这个字符串。第二种类型是序列（sequence），又叫做数组（array）
android点滴4 gundumw100 android
Android 47个小知识 http://www.open-open.com/lib/view/open1422676091314.html Android实用代码七段（一） http://www.cnblogs.com/over140/archive/2012/09/26/2611999.html http://www.cnblogs.com/over140/arch
JavaWeb之JSP基本语法 ihuning javaweb
目录 JSP模版元素 JSP表达式 JSP脚本片断 EL表达式 JSP注释特殊字符序列的转义处理如何查找JSP页面中的错误 JSP模版元素 JSP页面中的静态HTML内容称之为JSP模版元素，在静态的HTML内容之中可以嵌套JSP
App Extension编程指南（iOS8/OS X v10.10）中文版啸笑天 ext
当iOS 8.0和OS X v10.10发布后，一个全新的概念出现在我们眼前，那就是应用扩展。顾名思义，应用扩展允许开发者扩展应用的自定义功能和内容，能够让用户在使用其他app时使用该项功能。你可以开发一个应用扩展来执行某些特定的任务，用户使用该扩展后就可以在多个上下文环境中执行该任务。比如说，你提供了一个能让用户把内容分
SQLServer实现无限级树结构 macroli oracle sql SQL Server
表结构如下：数据库id path titlesort 排序 1 0 首页 0 2 0,1 新闻 1 3 0,2 JAVA 2 4 0,3 JSP 3 5 0,2,3 业界动态 2 6 0,2,3 国内新闻 1 创建一个存储过程来实现，如果要在页面上使用可以设置一个返回变量将至传过去 create procedure test as begin decla
Css居中div，Css居中img，Css居中文本，Css垂直居中div qiaolevip 众观千象学习永无止境每天进步一点点 css
/**********Css居中Div**********/ div.center { width: 100px; margin: 0 auto; } /**********Css居中img**********/ img.center { display: block; margin-left: auto; margin-right: auto; }
Oracle 常用操作(实用) 吃猫的鱼 oracle
SQL>select text from all_source where owner=user and name=upper('&plsql_name'); SQL>select * from user_ind_columns where index_name=upper('&index_name'); 将表记录恢复到指定时间段以前
iOS中使用RSA对数据进行加密解密 witcheryne ios rsa iPhone objective c
RSA算法是一种非对称加密算法,常被用于加密数据传输.如果配合上数字摘要算法, 也可以用于文件签名. 本文将讨论如何在iOS中使用RSA传输加密数据. 本文环境 mac os openssl-1.0.1j, openssl需要使用1.x版本, 推荐使用[homebrew](http://brew.sh/)安装. Java 8 RSA基本原理 RS