m基于FPGA的分布式FIR滤波器verilog设计,对比普通结构以及DA结构

简介: m基于FPGA的分布式FIR滤波器verilog设计,对比普通结构以及DA结构

1.算法描述

   DA算法的主要特点是,巧妙地利用查找表将固定系数的MAC运算转化为查表操作,其运算速度不随系数和输入数据位数的增加而降低,而且相对直接实现乘法器而言,在硬件规模上得到了极大的改善。

   对于FIR(有限长单位冲激响应)滤波器,其基本结构是一个分节的延时线,每一节的输出加权累加,得到滤波器的输出。其输出y就是输入x和系数h的内积:

1.png

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

2.png

这样就可以将式(3)化简为

3.png

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

分布式FIR的实现结构

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

4.png

图1 移位加法DA结构

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

5.png

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

6.png

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

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

2.仿真效果预览
版本vivado2019.2

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

7.png

综合结果如下所示:

8.png

其仿真结果如下所示:

9.png

3.verilog核心程序

    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
            
 
 
//利用查找表对输入的信号进行结果的查找,等到七个结果
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
....................................
              //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
01_115m
相关文章
|
10天前
|
机器学习/深度学习 算法 数据安全/隐私保护
基于FPGA的SNN脉冲神经网络之LIF神经元verilog实现,包含testbench
本项目展示了 LIF(Leaky Integrate-and-Fire)神经元算法的实现与应用,含无水印运行效果预览。基于 Vivado2019.2 开发,完整代码配有中文注释及操作视频。LIF 模型模拟生物神经元特性,通过积分输入信号并判断膜电位是否达阈值产生脉冲,相较于 Hodgkin-Huxley 模型更简化,适合大规模神经网络模拟。核心程序片段示例,助您快速上手。
|
2月前
|
算法 数据安全/隐私保护 计算机视觉
基于FPGA的图像双线性插值算法verilog实现,包括tb测试文件和MATLAB辅助验证
本项目展示了256×256图像通过双线性插值放大至512×512的效果,无水印展示。使用Matlab 2022a和Vivado 2019.2开发,提供完整代码及详细中文注释、操作视频。核心程序实现图像缩放,并在Matlab中验证效果。双线性插值算法通过FPGA高效实现图像缩放,确保质量。
|
27天前
|
算法 数据安全/隐私保护 异构计算
基于FPGA的2ASK+帧同步系统verilog开发,包含testbench,高斯信道,误码统计,可设置SNR
本内容展示了基于Vivado2019.2的算法仿真效果,包括设置不同信噪比(SNR=8db和20db)下的结果及整体波形。同时,详细介绍了2ASK调制解调技术的原理与实现,即通过改变载波振幅传输二进制信号,并提供数学公式支持。此外,还涉及帧同步理论,用于确定数据帧起始位置。最后,给出了Verilog核心程序代码,实现了2ASK解调与帧同步功能,结合DDS模块生成载波信号,完成信号处理流程。
27 0
|
3月前
|
存储 编解码 算法
基于FPGA的直接数字频率合成器verilog实现,包含testbench
本项目基于Vivado 2019.2实现DDS算法,提供完整无水印运行效果预览。DDS(直接数字频率合成器)通过数字信号处理技术生成特定频率和相位的正弦波,核心组件包括相位累加器、正弦查找表和DAC。相位累加器在每个时钟周期累加频率控制字,正弦查找表根据相位值输出幅度,DAC将数字信号转换为模拟电压。项目代码包含详细中文注释及操作视频。
|
1月前
|
数据采集 存储 数据可视化
分布式爬虫框架Scrapy-Redis实战指南
本文介绍如何使用Scrapy-Redis构建分布式爬虫系统,采集携程平台上热门城市的酒店价格与评价信息。通过代理IP、Cookie和User-Agent设置规避反爬策略,实现高效数据抓取。结合价格动态趋势分析,助力酒店业优化市场策略、提升服务质量。技术架构涵盖Scrapy-Redis核心调度、代理中间件及数据解析存储,提供完整的技术路线图与代码示例。
111 0
分布式爬虫框架Scrapy-Redis实战指南
|
2月前
|
NoSQL Java 中间件
【📕分布式锁通关指南 02】基于Redis实现的分布式锁
本文介绍了从单机锁到分布式锁的演变,重点探讨了使用Redis实现分布式锁的方法。分布式锁用于控制分布式系统中多个实例对共享资源的同步访问,需满足互斥性、可重入性、锁超时防死锁和锁释放正确防误删等特性。文章通过具体示例展示了如何利用Redis的`setnx`命令实现加锁,并分析了简化版分布式锁存在的问题,如锁超时和误删。为了解决这些问题,文中提出了设置锁过期时间和在解锁前验证持有锁的线程身份的优化方案。最后指出,尽管当前设计已解决部分问题,但仍存在进一步优化的空间,将在后续章节继续探讨。
535 131
【📕分布式锁通关指南 02】基于Redis实现的分布式锁
|
2月前
|
NoSQL Java Redis
Springboot使用Redis实现分布式锁
通过这些步骤和示例,您可以系统地了解如何在Spring Boot中使用Redis实现分布式锁,并在实际项目中应用。希望这些内容对您的学习和工作有所帮助。
225 83
|
6月前
|
NoSQL Java Redis
太惨痛: Redis 分布式锁 5个大坑,又大又深, 如何才能 避开 ?
Redis分布式锁在高并发场景下是重要的技术手段,但其实现过程中常遇到五大深坑:**原子性问题**、**连接耗尽问题**、**锁过期问题**、**锁失效问题**以及**锁分段问题**。这些问题不仅影响系统的稳定性和性能,还可能导致数据不一致。尼恩在实际项目中总结了这些坑,并提供了详细的解决方案,包括使用Lua脚本保证原子性、设置合理的锁过期时间和使用看门狗机制、以及通过锁分段提升性能。这些经验和技巧对面试和实际开发都有很大帮助,值得深入学习和实践。
太惨痛: Redis 分布式锁 5个大坑,又大又深, 如何才能 避开 ?
|
1月前
|
NoSQL Redis
Redis分布式锁如何实现 ?
Redis分布式锁主要依靠一个SETNX指令实现的 , 这条命令的含义就是“SET if Not Exists”,即不存在的时候才会设置值。 只有在key不存在的情况下,将键key的值设置为value。如果key已经存在,则SETNX命令不做任何操作。 这个命令的返回值如下。 ● 命令在设置成功时返回1。 ● 命令在设置失败时返回0。 假设此时有线程A和线程B同时访问临界区代码,假设线程A首先执行了SETNX命令,并返回结果1,继续向下执行。而此时线程B再次执行SETNX命令时,返回的结果为0,则线程B不能继续向下执行。只有当线程A执行DELETE命令将设置的锁状态删除时,线程B才会成功执行S
|
2月前
|
缓存 NoSQL 搜索推荐
【📕分布式锁通关指南 03】通过Lua脚本保证redis操作的原子性
本文介绍了如何通过Lua脚本在Redis中实现分布式锁的原子性操作,避免并发问题。首先讲解了Lua脚本的基本概念及其在Redis中的使用方法,包括通过`eval`指令执行Lua脚本和通过`script load`指令缓存脚本。接着详细展示了如何用Lua脚本实现加锁、解锁及可重入锁的功能,确保同一线程可以多次获取锁而不发生死锁。最后,通过代码示例演示了如何在实际业务中调用这些Lua脚本,确保锁操作的原子性和安全性。
145 6
【📕分布式锁通关指南 03】通过Lua脚本保证redis操作的原子性
下一篇
oss创建bucket