【DA算法】基于DA算法的FIR滤波器的FPGA实现

最新推荐文章于 2022-11-28 13:35:30 发布
最新推荐文章于 2022-11-28 13:35:30 发布
阅读量3.5k 收藏 46
点赞数 8
分类专栏： FPGA 板块1:通信与信号处理 文章标签： DA算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccsss22/article/details/123910414
版权

1.软件版本

quartusii

2.本算法理论知识

      DA算法的主要特点是，巧妙地利用查找表将固定系数的MAC运算转化为查表操作，其运算速度不随系数和输入数据位数的增加而降低，而且相对直接实现乘法器而言，在硬件规模上得到了极大的改善。对于FIR（有限长单位冲激响应）滤波器，其基本结构是一个分节的延时线，每一节的输出加权累加，得到滤波器的输出。其输出y就是输入x和系数h的内积：

      

 将式（3）中的第二部分展开，重新分别求和，这也是“分布式算法”名称的由来，可以得到：

 这样就可以将式（3）化简为

 计算h[n]xb[n]，就是用查找表实现一个映射，然后再将此映射经过相应的二次幂加权，最后即可得到滤波器的输出。

分布式FIR的实现结构

    图1给出了分布式FIR滤波器最直接的实现结构，虚线为流水线寄存器。对于小位宽的数据来讲，Da算法不仅速度快，而且所占用的芯片资源也很少。

 

对于式（4）括号中的每一个乘积项都代表了输入变量的某一位与常量的二进制“与”操作，加号代表了算术和操作，指数因子对括号中的值加权。如果事先构造一个查找表，该表储存了括号中所有可能的组合值，就可以通过所有输入变量相对应的组合向量(xb[N-1], xb[N-2], … ,xb[0])对该表进行寻址。该表结构如表1所示。

表1 构造规则

       在LUT实现分布式算法是，由于LUT的规模随着N的增加而呈指数增加，如果滤波器系数N过多，则查表的规模十分庞大。为了减小规模，可以利用部分表计算。由于FIR滤波器是线性滤波器，因此低阶滤波器输出可以相加，由此定义一个高阶滤波器的输出。例如，可以把16输入的查找表分割成4个并行的查找表，如图2所示。依次类推，可以将更大的LUT分割成多个小LUT。如果加上流水线，这一结构的改变并不会降低速度，却可以大大减小设计规模。

 下面开始在FPGA中进行设计与实现。

    考虑到，基于DA算的程序，其查找表的复杂度会随着输入的位宽和滤波器的阶数的增加而大大增加，这里，我们在满足设计指标的前提下，将滤波器的输入位宽改为12位，阶数为16阶。

3.核心代码

module firfilter_da(	CLK,
					Reset,
					DIN,
					Dout
					);
//-----------------------
//  port declaration
//-----------------------
	input	CLK;
	input	Reset;
	input [7:0]	DIN;
	output [15:0] Dout;

//输入信号寄存器	
	reg [7:0]		DIN_8b_0;
	reg [7:0]		DIN_8b_1;
	reg [7:0]		DIN_8b_2;
	reg [7:0]		DIN_8b_3;
	reg [7:0]		DIN_8b_4;
	reg	[7:0] 	DIN_8b_5;
	reg [7:0] 	DIN_8b_6;
	reg [7:0] 	DIN_8b_7;
	reg [7:0] 	DIN_8b_8;
	reg [7:0] 	DIN_8b_9;
	reg [7:0] 	DIN_8b_10;
	reg [7:0] 	DIN_8b_11;
	reg [7:0] 	DIN_8b_12;
	reg [7:0] 	DIN_8b_13;
	reg [7:0] 	DIN_8b_14;

//加法结果暂存器	
	reg [25:0] temp_1_1,temp_1_2,temp_1_3,temp_1_4;
	reg [25:0] temp_2_1,temp_2_2;
	reg [25:0] temp_3;  
	
	assign	Dout = temp_3[25:10]; 

//查找表函数，将与A3,A2,A1,A0对应相乘的各个位进行查找	
function[15:0] look_A3_A0;
	  input [3:0] DIN;
	  begin
	  	case(DIN)
			   4'b0000: look_A3_A0=16'h0;
			   4'b0001: look_A3_A0=16'h0;
			   4'b0010: look_A3_A0=16'h65;
			   4'b0011: look_A3_A0=16'h65;
			   4'b0100: look_A3_A0=16'h18f;
			   4'b0101: look_A3_A0=16'h18f;
			   4'b0110: look_A3_A0=16'h1f4;
			   4'b0111: look_A3_A0=16'h1f4;
			   4'b1000: look_A3_A0=16'h35a;
			   4'b1001: look_A3_A0=16'h35a;
			   4'b1010: look_A3_A0=16'h3bf;
			   4'b1011: look_A3_A0=16'h3bf;
			   4'b1100: look_A3_A0=16'h4e9;
			   4'b1101: look_A3_A0=16'h4e9;
			   4'b1110: look_A3_A0=16'h54e;
			   4'b1111: look_A3_A0=16'h54e;
			endcase
		end
	endfunction
	  	  
//查找表函数，将与A7,A6,A5,A4对应相乘的各个位进行查找
	function[15:0] look_A7_A4;
	  input [3:0] DIN;
	  begin
	  	case(DIN) 
			   4'b0000: look_A7_A4=16'h0;
			   4'b0001: look_A7_A4=16'h579;
			   4'b0010: look_A7_A4=16'h78e;
			   4'b0011: look_A7_A4=16'hd07;
			   4'b0100: look_A7_A4=16'h935;
			   4'b0101: look_A7_A4=16'heae;
			   4'b0110: look_A7_A4=16'h10c3;
			   4'b0111: look_A7_A4=16'h163c;
			   4'b1000: look_A7_A4=16'h0a1f;
			   4'b1001: look_A7_A4=16'h0f98;
			   4'b1010: look_A7_A4=16'h11ad;
			   4'b1011: look_A7_A4=16'h1726;
			   4'b1100: look_A7_A4=16'h1354;
			   4'b1101: look_A7_A4=16'h18cd;
			   4'b1110: look_A7_A4=16'h1ae2;
			   4'b1111: look_A7_A4=16'h205b;
			endcase
		end
	endfunction 

//查找表查找结果寄存器	
	reg [16:0] lookup0_1,lookup0_2,lookup0_3,lookup0_4,
             lookup1_1,lookup1_2,lookup1_3,lookup1_4,
             lookup2_1,lookup2_2,lookup2_3,lookup2_4,
             lookup3_1,lookup3_2,lookup3_3,lookup3_4,
             lookup4_1,lookup4_2,lookup4_3,lookup4_4,
             lookup5_1,lookup5_2,lookup5_3,lookup5_4,
             lookup6_1,lookup6_2,lookup6_3,lookup6_4,
             lookup7_1,lookup7_2,lookup7_3,lookup7_4;
	reg [17:0] sum0_1,sum0_2,sum1_1,sum1_2,
             sum2_1,sum2_2,sum3_1,sum3_2,
             sum4_1,sum4_2,sum5_1,sum5_2,
             sum6_1,sum6_2,sum7_1,sum7_2;
	reg [18:0] sum0,sum1,sum2,sum3,sum4,sum5,sum6,sum7;
	
	reg	[3:0]	count_4b;
	
// 输入信号的初始化
always @(posedge CLK or posedge Reset)
begin
	if(Reset)
	  begin
		count_4b<=0;
		DIN_8b_0<=0;
		DIN_8b_1<=0;
		DIN_8b_2<=0;
		DIN_8b_3<=0;
		DIN_8b_4<=0;
		DIN_8b_5<=0;
		DIN_8b_6<=0;
		DIN_8b_7<=0;
		DIN_8b_8<=0;
		DIN_8b_9<=0;
		DIN_8b_10<=0;
		DIN_8b_11<=0;
		DIN_8b_12<=0;
		DIN_8b_13<=0;
		DIN_8b_14<=0;
	  end
	else
	  begin
		if(count_4b==15)
		  begin
			DIN_8b_0<=DIN_8b_1;
			DIN_8b_1<=DIN_8b_2;
			DIN_8b_2<=DIN_8b_3;
			DIN_8b_3<=DIN_8b_4;
			DIN_8b_4<=DIN_8b_5;
			DIN_8b_5<=DIN_8b_6;
			DIN_8b_6<=DIN_8b_7;
			DIN_8b_7<=DIN_8b_8;
			DIN_8b_8<=DIN_8b_9;
			DIN_8b_9<=DIN_8b_10;
			DIN_8b_10<=DIN_8b_11;
			DIN_8b_11<=DIN_8b_12;
			DIN_8b_12<=DIN_8b_13;
			DIN_8b_13<=DIN_8b_14;
			DIN_8b_14<=DIN;
		  end
		else	
		  begin
		  case(count_4b)
			'd0: DIN_8b_0=DIN;
			'd1: DIN_8b_1=DIN;
			'd2: DIN_8b_2=DIN;
			'd3: DIN_8b_3=DIN;			
			'd4: DIN_8b_4=DIN;
			'd5: DIN_8b_5=DIN;
			'd6: DIN_8b_6=DIN;
			'd7: DIN_8b_7=DIN;
			'd8: DIN_8b_8=DIN;
			'd9: DIN_8b_9=DIN;
			'd10: DIN_8b_10=DIN;
			'd11: DIN_8b_11=DIN;
			'd12: DIN_8b_12=DIN;
			'd13: DIN_8b_13=DIN;
			'd14: DIN_8b_14=DIN;
			default:;
		  endcase
		  	count_4b=count_4b+1;			
		  end
	  end
end

//利用查找表对输入的信号进行结果的查找，等到七个结果
always @(posedge CLK or posedge Reset)
begin
		if(Reset)
			begin
						//0
						lookup0_1 <= 0;
            lookup0_2 <= 0;
            lookup0_3 <= 0;
            lookup0_4 <= 0;
            sum0_1 <= 0;
            sum0_2 <= 0;
            sum0     <= 0;
            //1
            lookup1_1 <= 0;
            lookup1_2 <= 0;
            lookup1_3 <= 0;
            lookup1_4 <= 0;
            sum1_1 <= 0;
            sum1_2 <= 0;
            sum1     <= 0;
            //2
            lookup2_1 <= 0;
            lookup2_2 <= 0;
            lookup2_3 <= 0;
            lookup2_4 <= 0;
            sum2_1 <= 0;
            sum2_2 <= 0;
            sum2     <= 0;
            //3
            lookup3_1 <= 0;
            lookup3_2 <= 0;
            lookup3_3 <= 0;
            lookup3_4 <= 0;
            sum3_1 <= 0;
            sum3_2 <= 0;
            sum3     <= 0;
            //4
            lookup4_1 <= 0;
            lookup4_2 <= 0;
            lookup4_3 <= 0;
            lookup4_4 <= 0;
            sum4_1 <= 0;
            sum4_2 <= 0;
            sum4     <= 0;
            //5
            lookup5_1 <= 0;
            lookup5_2 <= 0;
            lookup5_3 <= 0;
            lookup5_4 <= 0;
            sum5_1 <= 0;
            sum5_2 <= 0;
            sum5     <= 0;
            //6
            lookup6_1 <= 0;
            lookup6_2 <= 0;
            lookup6_3 <= 0;
            lookup6_4 <= 0;
            sum6_1 <= 0;
            sum6_2 <= 0;
            sum6     <= 0;
            //7
            lookup7_1 <= 0;
            lookup7_2 <= 0;
            lookup7_3 <= 0;
            lookup7_4 <= 0;
            sum7_1 <= 0;
            sum7_2 <= 0;
            sum7     <= 0;
          end
		else
			if(count_4b==15)
			begin
          	//0
          	lookup0_1 <= look_A3_A0({DIN_8b_12[0],DIN_8b_13[0],DIN_8b_14[0],DIN[0]});
          	lookup0_2 <= look_A7_A4({DIN_8b_8[0],DIN_8b_9[0],DIN_8b_10[0],DIN_8b_11[0]});
          	lookup0_3 <= look_A7_A4({DIN_8b_7[0],DIN_8b_6[0],DIN_8b_5[0],DIN_8b_4[0]});
          	lookup0_4 <= look_A3_A0({DIN_8b_3[0],DIN_8b_2[0],DIN_8b_1[0],DIN_8b_0[0]});
          	sum0_1 <= lookup0_1 + lookup0_2;
          	sum0_2 <= lookup0_3 + lookup0_4;
          	sum0     <= sum0_1 + sum0_2;
          	//1
          	lookup1_1 <= look_A3_A0({DIN_8b_12[1],DIN_8b_13[1],DIN_8b_14[1],DIN[1]});
          	lookup1_2 <= look_A7_A4({DIN_8b_8[1],DIN_8b_9[1],DIN_8b_10[1],DIN_8b_11[1]});
          	lookup1_3 <= look_A7_A4({DIN_8b_7[1],DIN_8b_6[1],DIN_8b_5[1],DIN_8b_4[1]});
          	lookup1_4 <= look_A3_A0({DIN_8b_3[1],DIN_8b_2[1],DIN_8b_1[1],DIN_8b_0[1]});
          	sum1_1 <= lookup1_1 + lookup1_2;
          	sum1_2 <= lookup1_3 + lookup1_4;
          	sum1     <= sum1_1 + sum1_2;
          	//2
          	lookup2_1 <= look_A3_A0({DIN_8b_12[2],DIN_8b_13[2],DIN_8b_14[2],DIN[2]});
          	lookup2_2 <= look_A7_A4({DIN_8b_8[2],DIN_8b_9[2],DIN_8b_10[2],DIN_8b_11[2]});
          	lookup2_3 <= look_A7_A4({DIN_8b_7[2],DIN_8b_6[2],DIN_8b_5[2],DIN_8b_4[2]});
          	lookup2_4 <= look_A3_A0({DIN_8b_3[2],DIN_8b_2[2],DIN_8b_1[2],DIN_8b_0[2]});
          	sum2_1 <= lookup2_1 + lookup2_2;
          	sum2_2 <= lookup2_3 + lookup2_4;
          	sum2     <= sum2_1 + sum2_2;
          	//3
          	lookup3_1 <= look_A3_A0({DIN_8b_12[3],DIN_8b_13[3],DIN_8b_14[3],DIN[3]});
          	lookup3_2 <= look_A7_A4({DIN_8b_8[3],DIN_8b_9[3],DIN_8b_10[3],DIN_8b_11[3]});
          	lookup3_3 <= look_A7_A4({DIN_8b_7[3],DIN_8b_6[3],DIN_8b_5[3],DIN_8b_4[3]});
          	lookup3_4 <= look_A3_A0({DIN_8b_3[3],DIN_8b_2[3],DIN_8b_1[3],DIN_8b_0[3]});
          	sum3_1 <= lookup3_1 + lookup3_2;
          	sum3_2 <= lookup3_3 + lookup3_4;
          	sum3     <= sum3_1 + sum3_2;
          	//4
          	lookup4_1 <= look_A3_A0({DIN_8b_12[4],DIN_8b_13[4],DIN_8b_14[4],DIN[4]});
          	lookup4_2 <= look_A7_A4({DIN_8b_8[4],DIN_8b_9[4],DIN_8b_10[4],DIN_8b_11[4]});
          	lookup4_3 <= look_A7_A4({DIN_8b_7[4],DIN_8b_6[4],DIN_8b_5[4],DIN_8b_4[4]});
          	lookup4_4 <= look_A3_A0({DIN_8b_3[4],DIN_8b_2[4],DIN_8b_1[4],DIN_8b_0[4]});
          	sum4_1 <= lookup4_1 + lookup4_2;
          	sum4_2 <= lookup4_3 + lookup4_4;
          	sum4     <= sum4_1 + sum4_2;
          	//5
          	lookup5_1 <= look_A3_A0({DIN_8b_12[5],DIN_8b_13[5],DIN_8b_14[5],DIN[5]});
          	lookup5_2 <= look_A7_A4({DIN_8b_8[5],DIN_8b_9[5],DIN_8b_10[5],DIN_8b_11[5]});
          	lookup5_3 <= look_A7_A4({DIN_8b_7[5],DIN_8b_6[5],DIN_8b_5[5],DIN_8b_4[5]});
          	lookup5_4 <= look_A3_A0({DIN_8b_3[5],DIN_8b_2[5],DIN_8b_1[5],DIN_8b_0[5]});
          	sum5_1 <= lookup5_1 + lookup5_2;
          	sum5_2 <= lookup5_3 + lookup5_4;
          	sum5     <= sum5_1 + sum5_2;
          	//6
          	lookup6_1 <= look_A3_A0({DIN_8b_12[6],DIN_8b_13[6],DIN_8b_14[6],DIN[6]});
          	lookup6_2 <= look_A7_A4({DIN_8b_8[6],DIN_8b_9[6],DIN_8b_10[6],DIN_8b_11[6]});
          	lookup6_3 <= look_A7_A4({DIN_8b_7[6],DIN_8b_6[6],DIN_8b_5[6],DIN_8b_4[6]});
          	lookup6_4 <= look_A3_A0({DIN_8b_3[6],DIN_8b_2[6],DIN_8b_1[6],DIN_8b_0[6]});
          	sum6_1 <= lookup6_1 + lookup6_2;
          	sum6_2 <= lookup6_3 + lookup6_4;
          	sum6     <= sum6_1 + sum6_2;
          	//7
          	lookup7_1 <= look_A3_A0({DIN_8b_12[7],DIN_8b_13[7],DIN_8b_14[7],DIN[7]});
          	lookup7_2 <= look_A7_A4({DIN_8b_8[7],DIN_8b_9[7],DIN_8b_10[7],DIN_8b_11[7]});
          	lookup7_3 <= look_A7_A4({DIN_8b_7[7],DIN_8b_6[7],DIN_8b_5[7],DIN_8b_4[7]});
          	lookup7_4 <= look_A3_A0({DIN_8b_3[7],DIN_8b_2[7],DIN_8b_1[7],DIN_8b_0[7]});
          	sum7_1 <= lookup7_1 + lookup7_2;
          	sum7_2 <= lookup7_3 + lookup7_4;
          	sum7     <= sum7_1 + sum7_2;
          end
         else;
end

//对得到的七个结果进行移位和相加
always @(posedge CLK or posedge Reset)
begin
	 		if (Reset)
          begin
          	  temp_1_1 <= 0;
          	  temp_1_2 <= 0;
          	  temp_1_3 <= 0;
          	  temp_1_4 <= 0;
          	  temp_2_1 <= 0;
          	  temp_2_2 <= 0;
          	  temp_3   <= 0;
          end          	  
      else
          if(count_4b==15)
						begin
          	  temp_1_1 <= {{7{sum0[18]}},sum0} + {{6{sum1[18]}},sum1,1'b0};
          	  temp_1_2 <= {{5{sum2[18]}},sum2,2'b0} + {{4{sum3[18]}},sum3,3'b0};
          	  temp_1_3 <= {{3{sum4[18]}},sum4,4'b0} + {{2{sum5[18]}},sum5,5'b0};
          	  temp_1_4 <= {sum6[18],sum6,6'b0}- {sum7,7'b0}; 
          	  
          	  temp_2_1 <= temp_1_1 + temp_1_2;
          	  temp_2_2 <= temp_1_3 + temp_1_4;
          	  
          	  temp_3   <= temp_2_1 + temp_2_2 ;
						end 
		   		else;
end
endmodule

 4.操作步骤与仿真结论

滤波器系数结果如下所示：

综合结果如下所示：

其仿真结果如下所示：

5.参考文献

[1]朱涛玉,余志勇. 高效实现FPGA数字下变频的多类滤波器分组级联技术[J]. 现代电子技术, 2008, 31(23):4.

A01-115

6.完整源码获得方式

方式1：微信或者QQ联系博主

方式2：订阅MATLAB/FPGA教程，免费获得教程案例以及任意2份完整源码

fpga和matlab
关注
专栏目录
【FPGA教程案例98】数据处理1——基于FPGA的数据线性插值verilog实现,MATAB辅助验证
FPGA/MATLAB学习教程/源码/项目合作开发
10-12 3336
线性插值是针对一维数据的插值方法。它根据一维数据序列中需要插值的点的左右临近两个数据来进行数值估计。当然了它不是求这两个点数据大小的平均值(在中心点的时候就等于平均值)。而是根据到这两个点的距离来分配比重的。对于FPGA设计线性插值，如果两个相邻的时钟周期之间进行插值，那么相当于x在x0和x1的中间，那么上面的公式就可以简化为：所以，通过上述方法，就可以完成一个简单的一维信号在FPGA中的插值运算了。
【FPGA教程案例99】数据处理2——基于DA分布式算法的FIR滤波器FPGA实现
FPGA/MATLAB学习教程/源码/项目合作开发
10-12 1901
DA算法的主要特点是，巧妙地利用查找表将固定系数的MAC运算转化为查表操作，其运算速度不随系数和输入数据位数的增加而降低，而且相对直接实现乘法器而言，在硬件规模上得到了极大的改善。对于FIR（有限长单位冲激响应）滤波器，其基本结构是一个分节的延时线，每一节的输出加权累加，得到滤波器的输出。考虑到，基于DA算的程序，其查找表的复杂度会随着输入的位宽和滤波器的阶数的增加而大大增加，这里，我们在满足设计指标的前提下，将滤波器的输入位宽改为12位，阶数为16阶。通过仿真，我们可以看到，滤波器成功完成滤波功能。
DA算法串行实现FIR滤波器的verilog代码
05-16
本设计利用分布式DA算法，串行实现4抽头的FIR滤波器
DA分布式fir滤波器实现，在vivado2019.2中开发纯verilog实现可以移植到quartusii或者ISE中。
05-01
DA分布式fir滤波器实现，在vivado2019.2中开发纯verilog实现可以移植到quartusii或者ISE中。
DA （分布式算法）
weixin_30920853的博客
07-06 1982
SOP（SUM OF PRODUCTS） 乘积求和 考虑参数： 乘积数表示格式 是否有符号位 乘积数位宽 累加器位宽 为保证动态范围额外设计的位宽 DA(Distribute Arithmetic) 1.无符号DA 算法流程： 将X[n]看为变量 并按二进制分解表示 Xb[n]：标志位第n次抽样的数的第b位 假设每次抽样的数量化位宽为B 将X项展开并重...
基于FPGA分布式算法FIR滤波器verilog代码
10-04
讨论了分布式算法原理，并提出了基于分布式算法FIR滤波器的实现方法。通过改进型分布式算法结构减少硬件资源消耗，用流水线技术提高运算速度，采用分割查找表方法减小存储规模，并在Matlab和Modelsim仿真平台得到...
基于DA算法的FIR滤波器的FPGA实现.pdf
07-13
实验结果表明，相比于传统的DSP芯片处理方式，基于DA算法的FPGA实现能够更快地完成滤波器的设计与实现，尤其是在处理高阶FIR滤波器时，其运算效率有成倍的提升。 文章最后指出，在实际的FPGA实现过程中，需要对查找...
基于分布式算法的FIR滤波器设计及FPGA实现.pdf
08-08
总之，基于分布式算法的FIR滤波器设计及其在FPGA上的实现是现代数字信号处理中的一项重要技术。分布式算法通过优化乘加运算的方式，不仅提高了运算效率，还减少了硬件资源的占用。而FPGA作为实现工具，其灵活的编程...
基于FPGA的分布式算法FIR滤波器设计
10-18
【基于FPGA的分布式算法FIR滤波器设计】 FIR（Finite Impulse Response）滤波器是数字信号处理中的核心组件，它以其独特的性质在众多领域中得到广泛应用。FIR滤波器能够保证任意的幅频特性，同时具备严格的线性相频...
基于FPGA的高速数据处理系统设计
08-08
本文叙述了采用FPGA实现光纤微扰动传感器的数据处理的具体方案，提供 了一种高速实时数据处理方法。本系统的主要工作是通过基于FPGA的嵌入式系统，实现数据采集、数据存储、LCD显示、USB数据传输和数据处理，完成光 纤微扰动传感的扰动识别和定位功能。
蜻蜓算法DA
01-21
亲测可用的群智能算法，非常好用，包含测试函数和绘图函数。
数字信号处理-11-FPGA FFT IP应用实例
最新发布
Vuko_Coding Zone
11-28 5686
本文根据FFT相关原理进行设计构建工程，仿造前文的工程构建的混频功能的工程，设计工程显示该混频信号的功率谱，然后进行仿真分析。
FPGA 20个例程篇：4.串行DAC输出模拟电压控制LED亮度
wandou0511的博客
04-06 7131
二、常用通信协议，摸索探究： 4.串行DAC输出模拟电压控制LED亮度 首先在此表示抱歉，笔者因为最近杂七杂八的事情比较多，搞得整个人莫名其妙地忙起来，所以博客更新的相对缓慢些，期间也有朋友私信我催更，表示在等着新例程学习呢，打开CSDN APP看到这些留言心里有一丝欣慰。 之前的承诺20个FPGA例程精讲精析，笔者会尽最大可能保持每周一个的速度持续更新，因为编写和整理代码会消耗不少的时间，后续例程的代码也会慢慢复杂起来，下班回来要做饭和陪女友，另外还要持续地学习工作方面.........
da分布式算法
weixin_30608503的博客
11-12 372
参考学习《数字信号处理的FPGA实现》 思想如图: 在下半部分可以看到：是将N阶的数B bit，一位一位的移入LUT然后经过累加器。其中N个数需要2.^N次方长度的LUT，B bit表示需要B个时钟完成一个数据的所有的位。但是有个疑问，为什么在累加的时候寄存器Y要往右移一位（？？？？？）。 在实际的程序中直接累加：（代码如下） 在此程序中：N = 4， B...
系统学习深度学习（二） --自编码器，DA算法，SDA，稀疏自编码器
热门推荐
工作笔记
01-10 1万+
转自：http://blog.csdn.net/zouxy09/article/details/8775524 9.1、AutoEncoder自动编码器         Deep Learning最简单的一种方法是利用人工神经网络的特点，人工神经网络（ANN）本身就是具有层次结构的系统，如果给定一个神经网络，我们假设其输出与输入是相同的，然后训练调整其参数，得到每一层中的权重。自然地，我们就得
蜻蜓算法(DA)
打呼噜的星
06-09 2423
蜻蜓群的目的：捕食（静态群）和迁移（动态群） 五种行为： 1.Separation：个体之间避免碰撞 Si=−∑j=1NX−XjS_i=-\sum_{j=1}^NX-X_jSi​=−∑j=1N​X−Xj​ X表示当前个体，Xj是第j个邻近个体的位置。N为邻近个体数量X表示当前个体，X_j是第j个邻近个体的位置。 N为邻近个体数量X表示当前个体，Xj​是第j个邻近个体的位置。N为邻近个体数量 2.Alignment：与邻近个体速度保持一致 Ai=∑j=1NVjNA_i=\frac{\sum_{j=1}^NV_
FPGA实现的DA算法FIR滤波器设计与验证
基于DA算法的FIR滤波器FPGA设计方法是一种高效、灵活的解决方案，它结合了FPGA的并行处理能力和DA算法的优化计算方式，为数字信号处理提供了一条快速且可扩展的途径。随着FPGA技术的不断发展，这种方法有望在更多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

fpga和matlab

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值