C语言实现FIR

最新推荐文章于 2023-11-10 13:13:36 发布
最新推荐文章于 2023-11-10 13:13:36 发布
阅读量1.9k 收藏 2
点赞数
文章标签： 语言 c output basic buffer hp

#include <stdio.h>

#ifdef WIN32

    #include <conio.h>

#endif 

#define SAMPLE  double      /* define the type used for data samples */

void clear(int ntaps, SAMPLE z[])      

{

    int ii;

    for (ii = 0; ii < ntaps; ii++) {

        z[ii] = 0;

    }

}

SAMPLE fir_basic(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[])       

{

    int ii;

    SAMPLE accum;

    

    /* store input at the beginning of the delay line */

    z[0] = input;

    /* calc FIR */

    accum = 0;

    for (ii = 0; ii < ntaps; ii++) {

        accum += h[ii] * z[ii];

    }

    /* shift delay line */

    for (ii = ntaps - 2; ii >= 0; ii--) {

        z[ii + 1] = z[ii];

    }

    return accum;

}

SAMPLE fir_circular(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],

                    int *p_state)         

{

    int ii, state;

    SAMPLE accum;

    state = *p_state;               /* copy the filter's state to a local */

    /* store input at the beginning of the delay line */

    z[state] = input;

    if (++state >= ntaps) {         /* incr state and check for wrap */

        state = 0;

    }

    /* calc FIR and shift data */

    accum = 0;

    for (ii = ntaps - 1; ii >= 0; ii--) {

        accum += h[ii] * z[state];

        if (++state >= ntaps) {     /* incr state and check for wrap */

            state = 0;

        }

    }

    *p_state = state;               /* return new state to caller */

    return accum;

}

SAMPLE fir_shuffle(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[])         

{

    int ii;

    SAMPLE accum;

    

    /* store input at the beginning of the delay line */

    z[0] = input;

    /* calc FIR and shift data */

    accum = h[ntaps - 1] * z[ntaps - 1];

    for (ii = ntaps - 2; ii >= 0; ii--) {

        accum += h[ii] * z[ii];

        z[ii + 1] = z[ii];

    }

    return accum;

}

SAMPLE fir_split(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],

                 int *p_state)

{

    int ii, end_ntaps, state = *p_state;

    SAMPLE accum;

    SAMPLE const *p_h;

    SAMPLE *p_z;

    /* setup the filter */

    accum = 0;

    p_h = h;

    /* calculate the end part */

    p_z = z + state;

    *p_z = input;

    end_ntaps = ntaps - state;

    for (ii = 0; ii < end_ntaps; ii++) {

        accum += *p_h++ * *p_z++;

    }

    /* calculate the beginning part */

    p_z = z;

    for (ii = 0; ii < state; ii++) {

        accum += *p_h++ * *p_z++;

    }

    /* decrement the state, wrapping if below zero */

    if (--state < 0) {

        state += ntaps;

    }

    *p_state = state;       /* return new state to caller */

    return accum;

}

SAMPLE fir_double_z(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],

            int *p_state)

{

    SAMPLE accum;

    int ii, state = *p_state;

    SAMPLE const *p_h, *p_z;

    /* store input at the beginning of the delay line as well as ntaps more */

    z[state] = z[state + ntaps] = input;

    /* calculate the filter */

    p_h = h;

    p_z = z + state;

    accum = 0;

    for (ii = 0; ii < ntaps; ii++) {

        accum += *p_h++ * *p_z++;

    }

    /* decrement state, wrapping if below zero */

    if (--state < 0) {

        state += ntaps;

    }

    *p_state = state;       /* return new state to caller */

    return accum;

}

SAMPLE fir_double_h(SAMPLE input, int ntaps, const SAMPLE h[], SAMPLE z[],

                    int *p_state)

{

    SAMPLE accum;

    int ii, state = *p_state;

    SAMPLE const *p_h, *p_z;

    /* store input at the beginning of the delay line */

    z[state] = input;

    /* calculate the filter */

    p_h = h + ntaps - state;

    p_z = z;

    accum = 0;

    for (ii = 0; ii < ntaps; ii++) {

        accum += *p_h++ * *p_z++;

    }

    /* decrement state, wrapping if below zero */

    if (--state < 0) {

        state += ntaps;

    }

    *p_state = state;       /* return new state to caller */

    return accum;

}

int main(void)

{

    #define NTAPS 6

    static const SAMPLE h[NTAPS] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 };

    static SAMPLE h2[2 * NTAPS];

    static SAMPLE z[2 * NTAPS];

    #define IMP_SIZE (3 * NTAPS)

    static SAMPLE imp[IMP_SIZE];

    SAMPLE output;

    int ii, state;

    /* make impulse input signal */

    clear(IMP_SIZE, imp);

    imp[5] = 1.0;

    /* create a SAMPLEd h */

    for (ii = 0; ii < NTAPS; ii++) {

        h2[ii] = h2[ii + NTAPS] = h[ii];

    }

    /* test FIR algorithms */

    printf("Testing fir_basic:/n   ");

    clear(NTAPS, z);

    for (ii = 0; ii < IMP_SIZE; ii++) {

        output = fir_basic(imp[ii], NTAPS, h, z);

        printf("%3.1lf ", (double) output);

    }   

    printf("/n/n");

    printf("Testing fir_shuffle:/n   ");

    clear(NTAPS, z);

    state = 0;

    for (ii = 0; ii < IMP_SIZE; ii++) {

        output = fir_shuffle(imp[ii], NTAPS, h, z);

        printf("%3.1lf ", (double) output);

    }   

    printf("/n/n");

    printf("Testing fir_circular:/n   ");

    clear(NTAPS, z);

    state = 0;

    for (ii = 0; ii < IMP_SIZE; ii++) {

        output = fir_circular(imp[ii], NTAPS, h, z, &state);

        printf("%3.1lf ", (double) output);

    }   

    printf("/n/n");

    printf("Testing fir_split:/n   ");

    clear(NTAPS, z);

    state = 0;

    for (ii = 0; ii < IMP_SIZE; ii++) {

        output = fir_split(imp[ii], NTAPS, h, z, &state);

        printf("%3.1lf ", (double) output);

    }   

    printf("/n/n");

    printf("Testing fir_double_z:/n   ");

    clear(2 * NTAPS, z);

    state = 0;

    for (ii = 0; ii < IMP_SIZE; ii++) {

        output = fir_double_z(imp[ii], NTAPS, h, z, &state);

        printf("%3.1lf ", (double) output);

    }   

    printf("/n/n");

    printf("Testing fir_double_h:/n   ");

    clear(NTAPS, z);

    state = 0;

    for (ii = 0; ii < IMP_SIZE; ii++) {

        output = fir_double_h(imp[ii], NTAPS, h2, z, &state);

        printf("%3.1lf ", (double) output);

    }   

    #ifdef WIN32

        printf("/n/nHit any key to continue.");

        getch();

    #endif

    return 0;

}

1. fir_basic: 实现基本的FIR滤波器

  2. fir_circular: 说明环行buffer是如何实现FIR的。

  3. fir_shuffle: 一些TI的处理器上使用的shuffle down技巧

  4. fir_split: 把FIR滤波器展开为两块，避免使用环行缓存。

  5. fir_double_z: 使用双精度的延迟线，使可以使用一个flat buffer。

  6. fir_double_h: 使用双精度的系数，使可以使用一个flat buffer。 

liuyuhe_me
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
FIR算法C语言实现
08-20
本文主要介绍了FIR算法C语言实现情况
FIR滤波器的C语言实现
04-22
FIR滤波器的C语言实现，用C编写的FIR滤波器，包括各个子函数在内，存成了word文档形式供下载。 FIR滤波器与无限持续时间脉冲响应 (IIR) 滤波器相比，具有有限持续时间脉冲响应的数字滤波器（全零或 FIR 滤波器）既有优点又有缺点。 主要优点： 1. 具有精确的线性相位 2. 始终稳定 3. 设计方法通常是线性的 4. 可以在硬件中高效实现 5. 滤波器启动瞬态具有有限持续时间 FIR 滤波器的主要缺点： 1. 要达到同样的性能水平，其所需阶数远高于IIR 滤波器 2. 滤波器的延迟通常比同等性能的IIR 滤波器大得多
c语言实现FIR（窗函数设计法）
最新发布
weixin_59250390的博客
11-10 3859
现在大多教程都是matlab的教程，那我用C语言实现一下FIR此博客为个人学习/*----窗类型-----*///三角形窗未完成，所以其实三角形和矩形的一样#define Rectangle 1 //矩形#define triangle 2 //三角#define Hanning 3 //汉宁#define Hamming 4 //海明#define Blackman 5 //布拉克曼/*----滤波类型-----*/
C语言实现fir低通滤波器
07-01
使用c语言实现了简单的fir低通滤波器，程序易懂，而且ppt中有相应的简单解释，希望对大家有用
[数字信号处理]单位冲击响应与频响以及FIR实现代码（C语言）
热门推荐
zhoufan的专栏
05-29 2万+
1.单位冲击响应与频响         就如同之前所说的一样，使用下图所示的单位冲击响应，所设计的滤波器，是无法实现的。          现在，让我们看看其这个滤波器的频响。所谓频响，就是计算其单位冲击响应的离散时间傅里叶变换，        我们可以看出，这个滤波器的频响的计算结果是实数，并没有虚数部分。也就是，其相位谱一直是0，也就意味着，这个滤波器输入与输出之间没有延
FIR1_fir_fir1c语言_FIR1_C语言实现fir1_matlab
09-11
标题中的"FIR1_fir_fir1c语言_FIR1_C语言实现fir1_matlab"指的是一项关于数字信号处理的项目，特别是针对有限 impulse response（FIR）滤波器的实现。在数字信号处理领域，FIR滤波器是一种广泛应用的滤波器类型，因...
FIR1_fir_fir1c语言_FIR1_C语言实现fir1_matlab.zip
10-11
标题 "FIR1_fir_fir1c语言_FIR1_C语言实现fir1_matlab.zip" 暗示了这是一个关于数字信号处理的资源包，具体聚焦于FIR滤波器的设计与C语言实现。FIR（Finite Impulse Response，有限冲击响应）滤波器是一种在数字信号...
C语言实现FIR滤波
12-02
本主题将详细探讨如何使用C语言来实现FIR滤波器，并确保其结果与Matlab计算一致。 首先，我们需要理解FIR滤波器的基本原理。FIR滤波器是通过一个固定长度的脉冲响应（即滤波器系数）对输入信号进行卷积来得到输出...
FIR1_fir_fir1c语言_FIR1_C语言实现fir1_matlab_源码.zip
09-30
该压缩包文件“FIR1_fir_fir1c语言_FIR1_C语言实现fir1_matlab_源码.zip”包含了一系列与数字信号处理相关的源代码，主要关注FIR（Finite Impulse Response，有限冲激响应）滤波器的设计与实现。在IT领域，FIR滤波器...
FIR 数字滤波器 C语言实现
04-11
C语言作为通用编程语言，是实现FIR滤波器的理想选择，因为它既灵活又高效。 在C语言中实现FIR滤波器，通常包括以下几个关键步骤： 1. **滤波器设计**：设计滤波器的频率响应，即确定滤波器的系数。这可以通过窗...
fir滤波器的c语言实现
07-15
使用c语言编写的fir有限冲激响应滤波器
FIR算法介绍 C语言
03-30
FIR算法介绍以及C语言实现方法！本文是PIC带的原文，本人贴出来供大家交流！
FIR滤波器设计C语言程序
05-27
窗函数设计FIR滤波，用C语言实现，在C环境下运行
FIR滤波器c语言实现
02-10
网上搜了搜FIR的c语言实现，发现博客上的都一堆报错，我就自己用改了改，c源码，绝对可以用，便于理解FIR滤波器的实现。代码中，我用的是100阶FIR低通滤波器，matlab生成的滤波器系数。完全按照公式来的，最后输出滤波前和滤波后的512个点数，用matlab绘图，效果不错。对比发现，实际FIR存在相移，本代码中为（100+1）/2个序列。
基于C语言的FIR滤波器
02-15
本程序用c语言实现FIR滤波器设计，采用的凯撒窗函数法，滤波器阶数、阻带宽度、阻带衰减等都可以通过修改相关系数达到特定的需要，同时通过调整相关系数可以实现带通，带阻，低通，高通等功能。
C语言实现FIR滤波器(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-20 719
C语言实现FIR滤波器(附完整源码)
C语言实现FIR滤波器
09-06
基于ADSP实现的FIR滤波器程序，采用C语言编写。
直接型FIR滤波器的C语言实现
Combine Art and Sciences.
01-20 1万+
直接型FIR滤波器的C语言实现    设输入数据x[N],输出数据y[N],滤波器系数h[n] 1.直接法(由y(m)=h(0)*x(m)+h(1)*x(m-1)+...+h(N-1)*x(m-n-1)); void fir(short x[], short h[], short y[]) { int i,j; long long sum; fo
c语言课程设计fir滤波器设计,fir滤波器设计c语言
weixin_39942488的博客
05-24 433
C语言编写FIR滤波器，代码如下：#include <>#include <>#include<>/**********************************宏定义**************************************/#define PI#define Size_Datas 512/***********************...
c语言实现FIR滤波器实例
08-11
### 回答1： 以下是一个简单的C语言实现FIR滤波器的示例代码： ```c #include <stdio.h> #define N 5 // FIR滤波器的阶数 float h[N] = {0.2, 0.3, 0.5, 0.3, 0.2}; // FIR滤波器的系数 int main() { float input[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 输入信号 float output[10] = {0}; // 输出信号 for (int n = 0; n < 10; n++) { for (int i = 0; i < N; i++) { if (n - i >= 0) { output[n] += h[i] * input[n - i]; } } } // 输出结果 for (int n = 0; n < 10; n++) { printf("output[%d] = %f\n", n, output[n]); } return 0; } ``` 该代码中定义了一个5阶的FIR滤波器，输入信号为长度为10的一维数组。通过嵌套循环计算每个输出样本的值，最终输出结果。在实际应用中，FIR滤波器的系数需要根据具体的应用场景进行设计和调整。 ### 回答2： FIR（Finite Impulse Response）滤波器是一类数字滤波器，其输出仅取决于有限数量的输入样本。下面是一个用C语言实现的简单FIR滤波器示例。 首先，我们需要定义FIR滤波器的参数。常见的参数包括滤波器的长度（N）、滤波器系数数组（h[]）和输入输出缓冲区。 ```c #define N 10 // 滤波器长度 float h[N] = {0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2}; // 滤波器系数 float buffer[N] = {0}; // 输入输出缓冲区 ``` 然后，我们可以编写一个函数来实现FIR滤波器的操作。 ```c float fir_filter(float input) { float output = 0; // 将新的输入值存入缓冲区 for (int i = N - 1; i >= 1; i--) { buffer[i] = buffer[i - 1]; } buffer[0] = input; // 计算输出值 for (int i = 0; i < N; i++) { output += h[i] * buffer[i]; } return output; } ``` 在主函数中，我们可以使用该函数来进行滤波操作。 ```c int main() { // 输入信号示例 float input_signal[] = {0.5, 1.0, 0.8, 0.3, 0.9}; // 滤波后的输出信号 float output_signal[5] = {0}; // 对输入信号进行滤波操作 for (int i = 0; i < 5; i++) { output_signal[i] = fir_filter(input_signal[i]); } // 输出滤波后的信号 for (int i = 0; i < 5; i++) { printf("Output signal[%d] = %f\n", i, output_signal[i]); } return 0; } ``` 以上就是一个简单的使用C语言实现的FIR滤波器的示例。根据具体的需求，你可以根据示例进行修改和完善。 ### 回答3： FIR滤波器，又称为有限脉冲响应滤波器，是一种常见的数字滤波器。下面以C语言为例，简要介绍如何实现一个FIR滤波器的示例。 首先，需要定义FIR滤波器的系数数组，这些系数用于对输入信号进行滤波处理。可以通过手动设定系数，或者使用窗函数等方法生成。 假设我们定义一个长度为N的系数数组coeff[N]，并且有一个输入信号数组inputSignal[N]，我们的目标是对输入信号进行滤波处理，得到输出信号outputSignal[N]。 接下来，我们可以使用如下的代码来实现FIR滤波器的处理过程： ```c #define N 10 // FIR滤波器的系数长度 float coeff[N] = {0.1, 0.2, 0.3, 0.4, 0.3, 0.2, 0.1, -0.1, -0.2, -0.3}; // 举例设定的系数数组 void FIRFilter(float* inputSignal, float* outputSignal, int signalLength) { int i, j; // 初始化输出信号为0 for(i = 0; i < signalLength; i++) { outputSignal[i] = 0; } // 实现FIR滤波器的过程 for(i = N-1; i < signalLength; i++) { for(j = 0; j < N; j++) { outputSignal[i] += inputSignal[i-j] * coeff[j]; } } } ``` 上述代码中，定义了一个FIRFilter函数，接收输入信号数组inputSignal、输出信号数组outputSignal以及信号的长度signalLength作为参数。其中，内部通过两个循环实现了滑动窗口的累加操作，滤波的结果存放在输出信号数组outputSignal中。 在使用上述代码时，我们只需要将输入信号和输出信号的数组传入FIRFilter函数即可完成滤波过程，得到滤波后的输出信号。 当然，这只是一个简单的FIR滤波器示例，实际上FIR滤波器还有很多优化的方法，例如使用快速傅里叶变换(FFT)来加速计算，或者采用流水线处理等技术来提高运算效率。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值