二阶带通滤波器 c++

二阶带通滤波器是一种常用的信号处理器件，用于筛选特定频率范围内的信号。它可以通过传递函数的实现形式和Matlab Fcn的实现形式来描述。在Matlab中使用Fcn实现滤波器可以方便地进行信号仿真分析，通过调整参数和观察输出结果来验证滤波器的性能。而在实际应用中，我们通常会将滤波器的算法移植到下位机中，比如嵌入式设备，这时就需要使用C语言或者C++语言进行编程和烧录。

相关问题

c++实现巴特沃斯带通滤波器

巴特沃斯带通滤波器是一种数字信号处理滤波器，可以通过将频率范围限制在一定的带宽内来滤除信号中的噪声或其他干扰。它是一种IIR滤波器，通常由一个或多个二阶滤波器级联而成。

以下是C语言实现巴特沃斯带通滤波器的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define PI 3.14159265358979323846

// 二阶滤波器结构体定义
typedef struct {
    double a1, a2, b0, b1, b2; // IIR滤波器系数
    double x1, x2, y1, y2; // 过去的输入/输出样本值
} Filter2nd;

// 初始化二阶滤波器
void initFilter2nd(Filter2nd *filt, double fs, double f1, double f2) {
    double omega1 = 2 * PI * f1 / fs;
    double omega2 = 2 * PI * f2 / fs;
    double c1 = cos(omega1);
    double c2 = cos(omega2);
    double s1 = sin(omega1);
    double s2 = sin(omega2);
    double alpha = s1 * s2 / (c1 * c2 + s1 * s2);

    filt->b0 = alpha;
    filt->b1 = 0;
    filt->b2 = -alpha;
    filt->a1 = 2 * (c1 * c2 - s1 * s2) / (c1 * c2 + s1 * s2);
    filt->a2 = -(c1 * c2 + s1 * s2) / (c1 * c2 + s1 * s2);

    filt->x1 = 0;
    filt->x2 = 0;
    filt->y1 = 0;
    filt->y2 = 0;
}

// 单个样本点的二阶滤波器处理
double filterSample2nd(Filter2nd *filt, double x) {
    double y = filt->b0 * x + filt->b1 * filt->x1 + filt->b2 * filt->x2
             - filt->a1 * filt->y1 - filt->a2 * filt->y2;
    filt->x2 = filt->x1;
    filt->x1 = x;
    filt->y2 = filt->y1;
    filt->y1 = y;
    return y;
}

// 实现巴特沃斯带通滤波器
void butterworthBandpassFilter(double *input, double *output, int length, double fs, double f1, double f2, int order) {
    Filter2nd *filt = (Filter2nd *) malloc(sizeof(Filter2nd) * order);
    for (int i = 0; i < order; i++) {
        initFilter2nd(&filt[i], fs, f1, f2);
    }

    for (int i = 0; i < length; i++) {
        double x = input[i];
        for (int j = 0; j < order; j++) {
            x = filterSample2nd(&filt[j], x);
        }
        output[i] = x;
    }

    free(filt);
}

int main() {
    double fs = 1000; // 采样率
    double f1 = 10; // 通带下限频率
    double f2 = 50; // 通带上限频率
    int order = 4; // 滤波器阶数

    // 生成测试信号
    int length = 1000;
    double *input = (double *) malloc(sizeof(double) * length);
    double *output = (double *) malloc(sizeof(double) * length);
    for (int i = 0; i < length; i++) {
        double t = (double) i / fs;
        input[i] = sin(2 * PI * 20 * t) + 0.5 * sin(2 * PI * 100 * t) + 0.2 * sin(2 * PI * 200 * t);
    }

    // 进行滤波处理
    butterworthBandpassFilter(input, output, length, fs, f1, f2, order);

    // 输出结果到文件
    FILE *fp = fopen("output.txt", "w");
    for (int i = 0; i < length; i++) {
        fprintf(fp, "%f\n", output[i]);
    }
    fclose(fp);

    free(input);
    free(output);

    return 0;
}

该代码中实现了一个二阶滤波器结构体`Filter2nd`和初始化函数`initFilter2nd`，以及单个样本点的滤波函数`filterSample2nd`。然后通过`butterworthBandpassFilter`函数实现了对输入信号的带通滤波处理。具体实现方式是对每个样本点依次通过多个二阶滤波器进行处理，得到最终的输出信号。最后将结果输出到文件中。

c++实现巴特沃斯带通滤波器代码

巴特沃斯带通滤波器是一种数字滤波器，它可以将指定范围内的频率信号通过，而将其他频率信号滤除。下面是一个C语言实现的巴特沃斯带通滤波器代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define PI 3.14159265358979323846

//定义结构体保存滤波器状态
typedef struct {
    double *x;   //输入数据数组
    double *y;   //输出数据数组
    int n;       //滤波器阶数
    double *a;   //分母系数
    double *b;   //分子系数
} ButterworthFilter;

//计算巴特沃斯带通滤波器系数
void butterworth_bandpass_coeff(int n, double f1, double f2, double fs, double *a, double *b)
{
    double omega1 = 2 * PI * f1 / fs;
    double omega2 = 2 * PI * f2 / fs;
    double c1 = cos(omega1);
    double s1 = sin(omega1);
    double c2 = cos(omega2);
    double s2 = sin(omega2);
    double alpha = s1 * s2 / (c1 * c2);
    double beta = 1 / tan((omega2 - omega1) / 2);
    double gamma = (1 - alpha) / 2;
    double a0 = 1 + alpha * beta + gamma * beta * beta;
    double a1 = 2 * (gamma * beta * beta - 1);
    double a2 = 1 - alpha * beta + gamma * beta * beta;
    double b0 = gamma * beta * beta;
    double b1 = 0;
    double b2 = -gamma * beta * beta;

    //归一化系数
    double k = a0;
    a[0] = a0 / k;
    a[1] = a1 / k;
    a[2] = a2 / k;
    b[0] = b0 / k;
    b[1] = b1 / k;
    b[2] = b2 / k;
}

//初始化滤波器
void butterworth_filter_init(ButterworthFilter *filter, int n)
{
    filter->n = n;
    filter->a = (double *) malloc((n + 1) * sizeof(double));
    filter->b = (double *) malloc((n + 1) * sizeof(double));
    filter->x = (double *) calloc(n + 1, sizeof(double));
    filter->y = (double *) calloc(n + 1, sizeof(double));
}

//释放滤波器内存
void butterworth_filter_free(ButterworthFilter *filter)
{
    free(filter->a);
    free(filter->b);
    free(filter->x);
    free(filter->y);
}

//巴特沃斯带通滤波器
double butterworth_bandpass_filter(ButterworthFilter *filter, double x)
{
    int i;
    double y = filter->b[0] * x;
    for (i = 1; i <= filter->n; i++)
        y += filter->b[i] * filter->x[i] - filter->a[i] * filter->y[i];
    for (i = filter->n; i > 0; i--)
        filter->x[i] = filter->x[i - 1];
    for (i = filter->n; i > 0; i--)
        filter->y[i] = filter->y[i - 1];
    filter->x[0] = x;
    filter->y[0] = y;
    return y;
}

//测试代码
int main()
{
    int n = 2;              //滤波器阶数
    double f1 = 20;         //通带下边界频率
    double f2 = 2000;       //通带上边界频率
    double fs = 8000;       //采样频率
    ButterworthFilter filter;
    butterworth_filter_init(&filter, n);
    butterworth_bandpass_coeff(n, f1, f2, fs, filter.a, filter.b);

    //模拟输入信号
    int i, len = 1000;
    double x[len], y[len];
    for (i = 0; i < len; i++) {
        x[i] = sin(2 * PI * 1000 * i / fs) + sin(2 * PI * 3000 * i / fs) + sin(2 * PI * 5000 * i / fs);
        y[i] = butterworth_bandpass_filter(&filter, x[i]);
        printf("%f,%f\n", x[i], y[i]);
    }

    butterworth_filter_free(&filter);
    return 0;
}

该代码实现了一个二阶巴特沃斯带通滤波器，可以通过修改滤波器阶数、通带频率范围和采样频率来适应不同的应用场景。在测试代码中，我们使用正弦信号模拟了一个频率为1kHz、3kHz和5kHz的混合信号，并将其输入到巴特沃斯带通滤波器中，输出滤波后的信号。由于滤波器只允许通过1kHz到3kHz之间的频率信号，因此输出信号中只有1kHz和3kHz的成分。