devbox
lpred
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

12种初级滤波器详细介绍（及其C语言实现）_c语言滤波器

作者：lpred | 2024-01-12 16:49:27

赞

踩

c语言滤波器

目录

1.算术平均滤波

原理

代码

2.一阶滞后滤波

原理

代码

3.限幅消抖滤波

原理

代码

4.递推平均滤波

原理

代码

5.加权递推平均滤波

原理

代码

6.中值滤波

原理

代码

7.中位值平均滤波法

原理

代码

8.一阶低通滤波

原理

代码

9.二阶低通滤波

原理

代码

10.一阶高通滤波

原理

代码

11.二阶高通滤波

原理

代码

12.带通有限脉冲响应滤波器（BPF）

原理

代码

1.算术平均滤波

原理

算术平均滤波是一种最简单常用的数字滤波算法之一，也是一种基于时间域的滤波方法。其原理是将连续采集到的一组数据进行加和，并求出其平均值，以此作为滤波后的输出值。这种方法能够有效平滑信号，去除噪声干扰，同时保留信号的趋势和主要特征。

算术平均滤波的基本原理是取一段时间内的信号值的平均值作为输出。这段时间可以是固定的，也可以是动态调整的，取决于具体的实现。

  1. 初始化： 设置一个窗口大小（表示取平均的时间范围）和一个缓存区，用于存储窗口内的信号值。

  2. 输入信号： 在每个时刻，输入一个新的信号值。

  3. 更新缓存区： 将新的信号值加入缓存区，并去除窗口之外的最早的信号值，以保持窗口大小不变。

  4. 计算平均值： 对缓存区内的所有信号值取平均值。

  5. 输出： 将平均值作为输出信号。

算术平均滤波对于平稳的信号非常有效，因为它能够消除瞬时噪声。然而，它对于快速变化的信号响应较慢，因为窗口内的信号值需要时间来适应变化。

代码

  1. #include <stdio.h>
  2.  
  3. #define WINDOW_SIZE 5
  4.  
  5. // 定义算术平均滤波器结构体
  6. typedef struct {
  7.     int window[WINDOW_SIZE];
  8.     int index;
  9. } AverageFilter;
  10.  
  11. // 初始化滤波器
  12. void initializeFilter(AverageFilter* filter) {
  13.     for (int i = 0; i < WINDOW_SIZE; ++i) {
  14.         filter->window[i] = 0;
  15.     }
  16.     filter->index = 0;
  17. }
  18.  
  19. // 算术平均滤波函数
  20. int filterValue(AverageFilter* filter, int input) {
  21.     // 更新缓存区
  22.     filter->window[filter->index] = input;
  23.     filter->index = (filter->index + 1) % WINDOW_SIZE;
  24.  
  25.     // 计算平均值
  26.     int sum = 0;
  27.     for (int i = 0; i < WINDOW_SIZE; ++i) {
  28.         sum += filter->window[i];
  29.     }
  30.     int average = sum / WINDOW_SIZE;
  31.  
  32.     return average;
  33. }
  34.  
  35. int main() {
  36.     // 初始化滤波器
  37.     AverageFilter myFilter;
  38.     initializeFilter(&myFilter);
  39.  
  40.     // 使用示例
  41.     int inputValues[] = {10, 15, 20, 18, 22, 25, 17};
  42.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  43.  
  44.     printf("Input Values:\tFiltered Values:\n");
  45.  
  46.     for (int i = 0; i < numValues; ++i) {
  47.         int filteredValue = filterValue(&myFilter, inputValues[i]);
  48.         printf("%d\t\t%d\n", inputValues[i], filteredValue);
  49.     }
  50.  
  51.     return 0;
  52. }

AverageFilter 结构体用于存储滤波器的状态信息，包括一个窗口大小为 WINDOW_SIZE 的缓存区和当前索引。 initializeFilter 函数用于初始化滤波器，而 filterValue 函数实现了算术平均滤波的操作。在 main 函数中，我们创建了一个 AverageFilter 实例，并对一系列输入值进行滤波处理，输出平均值。

2.一阶滞后滤波

原理

一阶滞后滤波法是一种常见的滤波方法，也被称为指数加权平均滤波。它基于一个简单的思想，即当前的输出值是前一次输出值和当前输入值的加权平均值。这种加权平均值的计算方法使得前一次的输出值在当前输出值中占有一定的比重，从而可以平滑信号，并减小由于突然变化引起的干扰。

一阶滞后滤波的基本原理是通过引入一个时间常数（time constant）来调节滞后程度。时间常数决定了滤波器对信号变化的响应速度。较大的时间常数会导致较慢的响应，更强的平滑效果，但可能较慢地跟踪信号的快速变化；较小的时间常数则会导致较快的响应，但可能对噪声更敏感。

一阶滞后滤波的差分方程可以表示为：

y[n] = (1-a)\cdot y[n-1]+a\cdot x[n]

其中：

  • y[n] 是当前时刻的输出。
  • y[n-1] 是上一时刻的输出。
  • x[n] 是当前时刻的输入。
  • \alpha 是介于 0 和 1 之间的常数，表示时间常数。

在这个方程中，\alpha 越接近 1，滤波器的响应就越慢，平滑效果越强。

代码

  1. #include <stdio.h>
  2.  
  3. // 定义一阶滞后滤波器结构体
  4. typedef struct {
  5.     float alpha; // 时间常数
  6.     float previous_output;
  7. } FirstOrderLagFilter;
  8.  
  9. // 初始化滤波器
  10. void initializeFilter(FirstOrderLagFilter* filter, float alpha) {
  11.     filter->alpha = alpha;
  12.     filter->previous_output = 0.0;
  13. }
  14.  
  15. // 一阶滞后滤波函数
  16. float filterValue(FirstOrderLagFilter* filter, float input) {
  17.     // 计算输出
  18.     float output = (1.0 - filter->alpha) * filter->previous_output + filter->alpha * input;
  19.  
  20.     // 更新上一次的输出
  21.     filter->previous_output = output;
  22.  
  23.     return output;
  24. }
  25.  
  26. int main() {
  27.     // 初始化滤波器，设置时间常数为0.2
  28.     FirstOrderLagFilter myFilter;
  29.     initializeFilter(&myFilter, 0.2);
  30.  
  31.     // 使用示例
  32.     float inputValues[] = {10.0, 15.0, 20.0, 18.0, 22.0, 25.0, 17.0};
  33.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  34.  
  35.     printf("Input Values:\tFiltered Values:\n");
  36.  
  37.     for (int i = 0; i < numValues; ++i) {
  38.         float filteredValue = filterValue(&myFilter, inputValues[i]);
  39.         printf("%.2f\t\t%.2f\n", inputValues[i], filteredValue);
  40.     }
  41.  
  42.     return 0;
  43. }

FirstOrderLagFilter 结构体用于存储滤波器的状态信息，包括时间常数和上一次的输出。initializeFilter 函数用于初始化滤波器，而 filterValue 函数实现了一阶滞后滤波的操作。在 main 函数中，我们创建了一个 FirstOrderLagFilter 实例，并对一系列输入值进行滤波处理，输出滤波后的值。

3.限幅消抖滤波

原理

限幅消抖滤波法是一种简单有效的数字滤波算法，常用于对采集到的离散信号进行去抖动处理。它可以去除信号中的瞬时噪声和突发干扰，同时保留信号的主要特征。

限幅消抖滤波法的原理是通过设置一个合适的阈值，将信号限制在一个固定的范围内，并消除信号中的抖动。当信号的变化速度超过阈值时，限制信号的变化幅度，以消除抖动；当信号变化速度较缓时，允许信号在一定范围内波动，以保留信号的主要特征。在实际应用中，通常将限幅消抖滤波法与其他滤波算法结合使用，以进一步提高滤波效果。

  1. 限幅（Clipping）： 首先，将输入信号限制在一个预定的范围内。这个范围由上下限值确定。如果输入信号超出这个范围，它将被截断或限制在范围的边界上。

  2. 消抖（Debouncing）： 消抖是指去除输入信号中的瞬时干扰或噪声，以获得更加平滑的输出。这可以通过在一定时间内对输入信号进行平均、滤波或延时来实现。

限幅消抖滤波的应用场景主要涉及那些由于环境原因或传感器特性而引入干扰的系统。例如，当使用传感器测量某个物理量时，由于传感器的特性或环境噪声，可能会产生一些突发的异常值。通过限制幅度和消除瞬时干扰，可以得到更加稳定和可靠的测量结果。在一些要求实时性较高的应用中，可能会选择简单的限幅操作。在对信号平滑性要求较高的场合，可能需要采用更复杂的滤波算法。

代码

  1. #include <stdio.h>
  2.  
  3. // 定义限幅消抖滤波器结构体
  4. typedef struct {
  5.     int min_limit;
  6.     int max_limit;
  7.     int previous_value;
  8.     int smoothing_factor;
  9. } Filter;
  10.  
  11. // 初始化滤波器
  12. void initializeFilter(Filter* filter, int min_limit, int max_limit, int smoothing_factor) {
  13.     filter->min_limit = min_limit;
  14.     filter->max_limit = max_limit;
  15.     filter->previous_value = 0; // 初始值为0
  16.     filter->smoothing_factor = smoothing_factor;
  17. }
  18.  
  19. // 限幅消抖滤波函数
  20. int filterValue(Filter* filter, int input) {
  21.     // 限幅
  22.     if (input < filter->min_limit) {
  23.         input = filter->min_limit;
  24.     } else if (input > filter->max_limit) {
  25.         input = filter->max_limit;
  26.     }
  27.  
  28.     // 消抖（滑动平均）
  29.     int output = (filter->previous_value * (filter->smoothing_factor - 1) + input) / filter->smoothing_factor;
  30.     
  31.     // 更新上一次的值
  32.     filter->previous_value = output;
  33.  
  34.     return output;
  35. }
  36.  
  37. int main() {
  38.     // 初始化滤波器，设置限幅范围为[0, 100]，消抖因子为3
  39.     Filter myFilter;
  40.     initializeFilter(&myFilter, 0, 100, 3);
  41.  
  42.     // 使用示例
  43.     int inputValues[] = {50, 120, 80, 90, 110, 30, 70};
  44.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  45.  
  46.     printf("Input Values:\tFiltered Values:\n");
  47.     
  48.     for (int i = 0; i < numValues; ++i) {
  49.         int filteredValue = filterValue(&myFilter, inputValues[i]);
  50.         printf("%d\t\t%d\n", inputValues[i], filteredValue);
  51.     }
  52.  
  53.     return 0;
  54. }

Filter 结构体用于存储滤波器的状态信息，包括限幅范围、上一次的值以及消抖因子。initializeFilter 函数用于初始化滤波器，而 filterValue 函数实现了限幅和滑动平均消抖的操作。在 main 函数中，我们创建了一个 Filter 实例，并对一系列输入值进行滤波处理，输出限幅和消抖后的值。

4.递推平均滤波

原理

递推平均滤波法，又称为滑动平均滤波法，是一种对于输入信号进行平滑处理的算法。该算法采用一定的方式对一定数量的输入信号进行加权平均，得到一个平滑的输出信号。具体地，递推平均滤波法使用一个固定长度的窗口，每当有新的输入信号到来时，就将窗口内的旧的信号淘汰掉，并将新的信号加入到窗口中，然后重新计算窗口内所有信号的平均值作为当前的输出信号。因此，随着新的信号不断到来，窗口内的信号会不断滑动，而输出信号也会不断变化，从而实现对输入信号的平滑处理。

递推平均滤波法的优点是简单、实时性好，对于周期性的噪声有一定的抑制效果。其缺点是在处理突变的输入信号时，输出信号会有一定的延迟，且在窗口大小不够大的情况下，噪声的抑制效果会比较有限。

下面是递推平均滤波法的算法步骤：

  1. 定义一个固定长度为 N 的窗口，并初始化窗口内的所有数据为 0。
  2. 当有新的输入信号 x_i 到来时，将窗口内的第一个信号 x_{i-N} 移除，并将新的信号 x_i 加入到窗口中。
  3. 计算窗口内所有信号的平均值，作为当前的输出信号 y_i 。
  4. 返回输出信号 y_i ，并等待下一次输入信号到来。

代码

  1. #define N 10   // 窗口大小
  2.  
  3. float moving_average_filter(float x) {
  4.     static float buffer[N] = {0};
  5.     static float sum = 0;
  6.     static int ptr = 0;
  7.     sum = sum - buffer[ptr] + x;
  8.     buffer[ptr] = x;
  9.     ptr = (ptr + 1) % N;
  10.     return sum / N;
  11. }

其中，N 为窗口大小，x 表示输入信号，y 表示输出信号，buffer 为窗口缓存，sum 为窗口内数据的累加和。

在这个函数中，我们使用了一个静态的窗口缓存 buffer 来存储窗口内的数据，使用 sum 来记录窗口内数据的累加和，使用 ptr 来记录当前窗口内最后一个数据的位置。当有新的输入信号 x 到来时，我们将窗口内第一个数据 buffer[ptr-N] 移除，并将新的信号 x 加入到窗口中。然后，我们重新计算窗口内所有信号的平均值作为当前的输出信号，并将作为当前的输出信号，返回输出信号，并等待下一次输入信号到来。

5.加权递推平均滤波

原理

加权递推平均滤波是一种滤波技术，它对信号的当前值和过去的滤波结果进行加权组合，以获得平滑的输出。与一阶滞后滤波不同，加权递推平均滤波使用多个权重来对不同时刻的输入信号进行加权，以更灵活地调整对历史数据的依赖程度。

y[n] = \sum _{i=0}^{N}w_i\cdot x[n-1]

其中：

  • y[n] 是当前时刻的输出。
  • x[n-1] 是过去的输入信号值，i 表示过去的时间步。
  • w_i 是权重系数，表示对应时刻的权重。

权重系数的选择是加权递推平均滤波的关键，它决定了滤波器对历史数据的关注程度。通常情况下，权重系数越大，对应时刻的输入信号在输出中的影响就越大。这样设计的目的是在保持对当前值敏感的同时，平滑掉噪声或瞬时变化。

代码

  1. #include <stdio.h>
  2.  
  3. #define NUM_WEIGHTS 3
  4.  
  5. // 定义加权递推平均滤波器结构体
  6. typedef struct {
  7.     float weights[NUM_WEIGHTS];
  8.     float buffer[NUM_WEIGHTS];
  9.     int index;
  10. } WeightedRecursiveAverageFilter;
  11.  
  12. // 初始化滤波器
  13. void initializeFilter(WeightedRecursiveAverageFilter* filter, float* weights) {
  14.     for (int i = 0; i < NUM_WEIGHTS; ++i) {
  15.         filter->weights[i] = weights[i];
  16.         filter->buffer[i] = 0.0;
  17.     }
  18.     filter->index = 0;
  19. }
  20.  
  21. // 加权递推平均滤波函数
  22. float filterValue(WeightedRecursiveAverageFilter* filter, float input) {
  23.     // 更新缓存区
  24.     filter->buffer[filter->index] = input;
  25.     filter->index = (filter->index + 1) % NUM_WEIGHTS;
  26.  
  27.     // 计算加权平均值
  28.     float output = 0.0;
  29.     for (int i = 0; i < NUM_WEIGHTS; ++i) {
  30.         output += filter->weights[i] * filter->buffer[(filter->index - i + NUM_WEIGHTS) % NUM_WEIGHTS];
  31.     }
  32.  
  33.     return output;
  34. }
  35.  
  36. int main() {
  37.     // 初始化滤波器，设置权重系数
  38.     float weights[] = {0.2, 0.5, 0.3};
  39.     WeightedRecursiveAverageFilter myFilter;
  40.     initializeFilter(&myFilter, weights);
  41.  
  42.     // 使用示例
  43.     float inputValues[] = {10.0, 15.0, 20.0, 18.0, 22.0, 25.0, 17.0};
  44.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  45.  
  46.     printf("Input Values:\tFiltered Values:\n");
  47.  
  48.     for (int i = 0; i < numValues; ++i) {
  49.         float filteredValue = filterValue(&myFilter, inputValues[i]);
  50.         printf("%.2f\t\t%.2f\n", inputValues[i], filteredValue);
  51.     }
  52.  
  53.     return 0;
  54. }

WeightedRecursiveAverageFilter 结构体用于存储滤波器的状态信息，包括权重系数和缓存区。initializeFilter 函数用于初始化滤波器，而 filterValue 函数实现了加权递推平均滤波的操作。在 main 函数中，我们创建了一个 WeightedRecursiveAverageFilter 实例，并对一系列输入值进行滤波处理，输出滤波后的值。

6.中值滤波

原理

中值滤波是一种非线性滤波方法，常用于去除信号中的脉冲噪声或椒盐噪声。它的原理是将一组数据排序，然后选择中间位置的值作为滤波结果。中值滤波对于去除离群值（异常值）非常有效，因为它不受异常值的影响。

  1. 选择窗口大小： 窗口大小决定了用于计算中值的数据点数量。通常，窗口大小是一个奇数，以确保存在中间位置的值。

  2. 将窗口内的数据排序： 对窗口内的数据进行排序，确定中间位置的值。

  3. 选择中值： 选择排序后的数据集的中间位置的值作为输出。

中值滤波的优势在于它能够有效地保留信号的边缘信息，而不像线性滤波那样引入过多的平滑。因此，中值滤波在一些对信号细节要求较高的应用中比较有用。需要注意的是，中值滤波可能会导致信号的某些特征被模糊化，因此在应用中需要谨慎选择邻域大小和形状，以及滤波器的使用场景。

代码

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. #define WINDOW_SIZE 3
  5.  
  6. // 定义中值滤波器结构体
  7. typedef struct {
  8.     int window[WINDOW_SIZE];
  9. } MedianFilter;
  10.  
  11. // 初始化滤波器
  12. void initializeFilter(MedianFilter* filter) {
  13.     // 初始化窗口
  14.     for (int i = 0; i < WINDOW_SIZE; ++i) {
  15.         filter->window[i] = 0;
  16.     }
  17. }
  18.  
  19. // 中值滤波函数
  20. int filterValue(MedianFilter* filter, int input) {
  21.     // 将新的值插入窗口
  22.     for (int i = WINDOW_SIZE - 1; i > 0; --i) {
  23.         filter->window[i] = filter->window[i - 1];
  24.     }
  25.     filter->window[0] = input;
  26.  
  27.     // 对窗口内的数据进行排序
  28.     for (int i = 0; i < WINDOW_SIZE - 1; ++i) {
  29.         for (int j = i + 1; j < WINDOW_SIZE; ++j) {
  30.             if (filter->window[j] < filter->window[i]) {
  31.                 // 交换值
  32.                 int temp = filter->window[i];
  33.                 filter->window[i] = filter->window[j];
  34.                 filter->window[j] = temp;
  35.             }
  36.         }
  37.     }
  38.  
  39.     // 选择中值
  40.     int median = filter->window[WINDOW_SIZE / 2];
  41.  
  42.     return median;
  43. }
  44.  
  45. int main() {
  46.     // 初始化滤波器
  47.     MedianFilter myFilter;
  48.     initializeFilter(&myFilter);
  49.  
  50.     // 使用示例
  51.     int inputValues[] = {10, 15, 20, 18, 22, 25, 17};
  52.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  53.  
  54.     printf("Input Values:\tFiltered Values:\n");
  55.  
  56.     for (int i = 0; i < numValues; ++i) {
  57.         int filteredValue = filterValue(&myFilter, inputValues[i]);
  58.         printf("%d\t\t%d\n", inputValues[i], filteredValue);
  59.     }
  60.  
  61.     return 0;
  62. }

MedianFilter 结构体用于存储滤波器的状态信息，包括一个窗口。initializeFilter 函数用于初始化滤波器，而 filterValue 函数实现了中值滤波的操作。在 main 函数中，我们创建了一个 MedianFilter 实例，并对一系列输入值进行滤波处理，输出中值。

7.中位值平均滤波法

原理

中位值平均滤波法（Median Filtering with Averaging）是一种结合了中值滤波和平均滤波的方法。在这种滤波法中，首先通过中值滤波获得当前时刻的输出，然后将该输出与一定时期内的平均值进行加权平均。这种方法的目的是综合利用中值滤波和平均滤波的优势，对信号进行平滑处理，并能够有效地去除脉冲噪声或其他突发性噪声。

中位值平均滤波法的基本步骤如下：

  1. 中值滤波： 使用中值滤波器，通过排序窗口内的数据并选择中间值，得到一个初步的滤波结果。

  2. 平均滤波： 将中值滤波得到的结果与一定时期内的平均值进行加权平均。通常，这里的平均值是使用递推平均滤波法得到的。

  3. 输出： 输出平均滤波的结果作为最终的滤波输出。

这种滤波法的优势在于中值滤波能够有效去除离群值和脉冲噪声，而平均滤波则能够对信号进行较好的平滑。通过结合这两种方法，中位值平均滤波法在一些特定噪声环境下表现得比单一滤波方法更为鲁棒。

代码

  1. #include <stdio.h>
  2.  
  3. #define WINDOW_SIZE 5
  4.  
  5. // 定义中位值平均滤波器结构体
  6. typedef struct {
  7.     int window[WINDOW_SIZE];
  8.     float alpha; // 平均滤波的权重系数
  9. } MedianAverageFilter;
  10.  
  11. // 初始化滤波器
  12. void initializeFilter(MedianAverageFilter* filter, float alpha) {
  13.     for (int i = 0; i < WINDOW_SIZE; ++i) {
  14.         filter->window[i] = 0;
  15.     }
  16.     filter->alpha = alpha;
  17. }
  18.  
  19. // 中位值平均滤波函数
  20. float filterValue(MedianAverageFilter* filter, int input) {
  21.     // 更新窗口
  22.     for (int i = WINDOW_SIZE - 1; i > 0; --i) {
  23.         filter->window[i] = filter->window[i - 1];
  24.     }
  25.     filter->window[0] = input;
  26.  
  27.     // 中值滤波
  28.     int sortedValues[WINDOW_SIZE];
  29.     for (int i = 0; i < WINDOW_SIZE; ++i) {
  30.         sortedValues[i] = filter->window[i];
  31.     }
  32.     for (int i = 0; i < WINDOW_SIZE - 1; ++i) {
  33.         for (int j = i + 1; j < WINDOW_SIZE; ++j) {
  34.             if (sortedValues[j] < sortedValues[i]) {
  35.                 // 交换值
  36.                 int temp = sortedValues[i];
  37.                 sortedValues[i] = sortedValues[j];
  38.                 sortedValues[j] = temp;
  39.             }
  40.         }
  41.     }
  42.     int median = sortedValues[WINDOW_SIZE / 2];
  43.  
  44.     // 平均滤波
  45.     float output = (1.0 - filter->alpha) * median + filter->alpha * input;
  46.  
  47.     return output;
  48. }
  49.  
  50. int main() {
  51.     // 初始化滤波器，设置平均滤波的权重系数
  52.     float alpha = 0.2;
  53.     MedianAverageFilter myFilter;
  54.     initializeFilter(&myFilter, alpha);
  55.  
  56.     // 使用示例
  57.     int inputValues[] = {10, 15, 20, 18, 22, 25, 17};
  58.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  59.  
  60.     printf("Input Values:\tFiltered Values:\n");
  61.  
  62.     for (int i = 0; i < numValues; ++i) {
  63.         float filteredValue = filterValue(&myFilter, inputValues[i]);
  64.         printf("%d\t\t%.2f\n", inputValues[i], filteredValue);
  65.     }
  66.  
  67.     return 0;
  68. }

MedianAverageFilter 结构体用于存储滤波器的状态信息，包括窗口和平均滤波的权重系数。initializeFilter 函数用于初始化滤波器，而 filterValue 函数实现了中位值平均滤波的操作。在 main 函数中，我们创建了一个 MedianAverageFilter 实例，并对一系列输入值进行滤波处理，输出滤波后的值。

8.一阶低通滤波

原理

低通滤波（Low Pass Filter）用于从一个信号中去除高于某个频率的成分。它的基本原理是，信号中高于某个频率的成分在信号传输或接收过程中会发生衰减，而低于该频率的成分则不受影响。因此，通过将信号通过一个低通滤波器，可以去除高频噪声，保留信号中的低频成分。

一阶低通滤波器是低通滤波的一阶离散形式，用于滤除输入信号中的高频分量，只保留低频分量。它通过减弱高频部分的幅度，从而实现对信号的平滑处理。一阶低通滤波器的基本原理涉及限制信号的变化速率，对快速变化的信号进行衰减，而对缓慢变化的信号保留。

一阶低通滤波的形式与一阶滞后滤波完全相同。倒不如说一阶滞后滤波其实就是一阶低通滤波，只不过当该滤波器用于不同的作用时，我们将其冠以了不同的称呼。

y[n] = (1-a)\cdot y[n-1]+a\cdot x[n]

其中：

  • y[n] 是当前时刻的输出。
  • y[n-1] 是上一时刻的输出。
  • x[n] 是当前时刻的输入。
  • \alpha 是介于 0 和 1 之间的常数，表示时间常数。

在这个方程中，\alpha 越小，时间常数越大，低通滤波器的截止频率就越低，对高频部分的抑制效果就越强。

一阶低通滤波器常用于需要平滑信号或去除高频噪声的应用场景。它们在信号处理、通信系统、控制系统等领域都有广泛的应用。

代码

  1. #include <stdio.h>
  2.  
  3. // 定义一阶低通滤波器结构体
  4. typedef struct {
  5.     float alpha;           // 时间常数
  6.     float previous_output; // 上一时刻的输出
  7. } LowPassFilter;
  8.  
  9. // 初始化滤波器
  10. void initializeFilter(LowPassFilter* filter, float alpha) {
  11.     filter->alpha = alpha;
  12.     filter->previous_output = 0.0;
  13. }
  14.  
  15. // 一阶低通滤波函数
  16. float filterValue(LowPassFilter* filter, float input) {
  17.     // 计算输出
  18.     float output = (1.0 - filter->alpha) * filter->previous_output + filter->alpha * input;
  19.  
  20.     // 更新上一次的输出
  21.     filter->previous_output = output;
  22.  
  23.     return output;
  24. }
  25.  
  26. int main() {
  27.     // 初始化滤波器，设置时间常数为0.2
  28.     float alpha = 0.2;
  29.     LowPassFilter myFilter;
  30.     initializeFilter(&myFilter, alpha);
  31.  
  32.     // 使用示例
  33.     float inputValues[] = {10.0, 15.0, 20.0, 18.0, 22.0, 25.0, 17.0};
  34.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  35.  
  36.     printf("Input Values:\tFiltered Values:\n");
  37.  
  38.     for (int i = 0; i < numValues; ++i) {
  39.         float filteredValue = filterValue(&myFilter, inputValues[i]);
  40.         printf("%.2f\t\t%.2f\n", inputValues[i], filteredValue);
  41.     }
  42.  
  43.     return 0;
  44. }

LowPassFilter 结构体用于存储滤波器的状态信息，包括时间常数和上一次的输出。initializeFilter 函数用于初始化滤波器，而 filterValue 函数实现了一阶低通滤波的操作。在 main 函数中，我们创建了一个 LowPassFilter 实例，并对一系列输入值进行滤波处理，输出滤波后的值。

9.二阶低通滤波

原理

二阶低通滤波器是低通滤波器的二阶差分形式，用于滤除输入信号中的高频分量，同时保留低频分量。相比于一阶低通滤波器，二阶低通滤波器在频域上更为复杂，具有更陡的滤波特性。它可以更有效地抑制高频噪声，同时允许低频信号通过。

一个常见的二阶低通滤波器可以通过差分方程表示为：

y[n] = (1-\alpha -\beta)\cdot y[n-2]+2\cdot \alpha \cdot y[n-1]+\beta \cdot x[n]

其中：

  • y[n] 是当前时刻的输出。
  • y[n-1] 和 y[n-2] 是上两个时刻的输出。
  • x[n] 是当前时刻的输入。
  • \alpha 和 \beta 是介于 0 和 1 之间的常数，分别表示两个不同的时间常数，决定了滤波器的特性。

在这个方程中，\alpha 和 \beta 的选择影响了滤波器的频率响应和阶数。较小的时间常数表示较大的截止频率，而较大的时间常数表示较小的截止频率。这样，可以根据具体需求调整时间常数来达到期望的滤波效果。

二阶低通滤波器通常应用于需要更复杂频率响应和更好滤波性能的情况，如音频处理、图像处理和控制系统等领域。

代码

  1. #include <stdio.h>
  2.  
  3. // 定义二阶低通滤波器结构体
  4. typedef struct {
  5.     float alpha;           // 第一个时间常数
  6.     float beta;            // 第二个时间常数
  7.     float previous_output[2]; // 上两个时刻的输出
  8. } SecondOrderLowPassFilter;
  9.  
  10. // 初始化滤波器
  11. void initializeFilter(SecondOrderLowPassFilter* filter, float alpha, float beta) {
  12.     filter->alpha = alpha;
  13.     filter->beta = beta;
  14.     filter->previous_output[0] = 0.0;
  15.     filter->previous_output[1] = 0.0;
  16. }
  17.  
  18. // 二阶低通滤波函数
  19. float filterValue(SecondOrderLowPassFilter* filter, float input) {
  20.     // 计算输出
  21.     float output = (1.0 - filter->alpha - filter->beta) * filter->previous_output[1] +
  22.                    2.0 * filter->alpha * filter->previous_output[0] +
  23.                    filter->beta * input;
  24.  
  25.     // 更新上两次的输出
  26.     filter->previous_output[1] = filter->previous_output[0];
  27.     filter->previous_output[0] = output;
  28.  
  29.     return output;
  30. }
  31.  
  32. int main() {
  33.     // 初始化滤波器，设置两个时间常数
  34.     float alpha = 0.1;
  35.     float beta = 0.1;
  36.     SecondOrderLowPassFilter myFilter;
  37.     initializeFilter(&myFilter, alpha, beta);
  38.  
  39.     // 使用示例
  40.     float inputValues[] = {10.0, 15.0, 20.0, 18.0, 22.0, 25.0, 17.0};
  41.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  42.  
  43.     printf("Input Values:\tFiltered Values:\n");
  44.  
  45.     for (int i = 0; i < numValues; ++i) {
  46.         float filteredValue = filterValue(&myFilter, inputValues[i]);
  47.         printf("%.2f\t\t%.2f\n", inputValues[i], filteredValue);
  48.     }
  49.  
  50.     return 0;
  51. }

SecondOrderLowPassFilter 结构体用于存储滤波器的状态信息，包括两个时间常数和上两次的输出。initializeFilter 函数用于初始化滤波器，而 filterValue 函数实现了二阶低通滤波的操作。在 main 函数中，我们创建了一个 SecondOrderLowPassFilter 实例，并对一系列输入值进行滤波处理，输出滤波后的值。

10.一阶高通滤波

原理

高通滤波（High Pass Filter）可以滤除信号中的低频部分，保留高频部分。高通滤波器的应用非常广泛，例如在音频处理中可以用来去除低频噪声、在图像处理中可以用来增强图像的边缘等。

高通滤波算法的基本思想是：将信号分解成高频和低频两部分，去掉低频部分，只保留高频部分。高通滤波的实现可以通过频域方法和时域方法两种方式实现。

频域方法是将信号转换到频域进行处理，常用的有傅里叶变换和小波变换等。通过滤波器在频域中滤除低频成分，然后再将信号转换回时域。

时域方法则是通过差分等方式，直接在时域中滤除低频部分。

一阶高通滤波器是高通滤波的一阶差分形式，用于滤除输入信号中的低频分量，同时保留高频分量。高通滤波器的作用是弱化或消除信号中的低频成分，从而突出高频变化或忽略缓慢变化的部分。一阶高通滤波器的设计原理涉及对低频分量进行衰减，保留高频部分。

一阶高通滤波器的差分方程一般表示为：

y[n]=\alpha \cdot y[n-1]+\alpha \cdot(x[n] - x[n-1])

其中：

  • y[n] 是当前时刻的输出。
  • y[n-1] 是上一时刻的输出。
  • x[n] 是当前时刻的输入。
  • \alpha 是介于 0 和 1 之间的常数，表示时间常数，决定了滤波器的截止频率。

在这个方程中，\alpha 越小，时间常数越大，高通滤波器的截止频率就越低，对低频部分的抑制效果就越弱。

一阶高通滤波器通常应用于需要突出信号中快速变化或高频成分的应用场景。在图像处理、音频处理、传感器信号处理等领域，高通滤波器被广泛用于去除低频噪声或趋势成分。

代码

  1. #include <stdio.h>
  2.  
  3. // 定义一阶高通滤波器结构体
  4. typedef struct {
  5.     float alpha;           // 时间常数
  6.     float previous_output; // 上一时刻的输出
  7. } HighPassFilter;
  8.  
  9. // 初始化滤波器
  10. void initializeFilter(HighPassFilter* filter, float alpha) {
  11.     filter->alpha = alpha;
  12.     filter->previous_output = 0.0;
  13. }
  14.  
  15. // 一阶高通滤波函数
  16. float filterValue(HighPassFilter* filter, float input) {
  17.     // 计算输出
  18.     float output = filter->alpha * (input - filter->previous_output) + filter->previous_output;
  19.  
  20.     // 更新上一次的输出
  21.     filter->previous_output = output;
  22.  
  23.     return output;
  24. }
  25.  
  26. int main() {
  27.     // 初始化滤波器，设置时间常数为0.1
  28.     float alpha = 0.1;
  29.     HighPassFilter myFilter;
  30.     initializeFilter(&myFilter, alpha);
  31.  
  32.     // 使用示例
  33.     float inputValues[] = {10.0, 15.0, 20.0, 18.0, 22.0, 25.0, 17.0};
  34.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  35.  
  36.     printf("Input Values:\tFiltered Values:\n");
  37.  
  38.     for (int i = 0; i < numValues; ++i) {
  39.         float filteredValue = filterValue(&myFilter, inputValues[i]);
  40.         printf("%.2f\t\t%.2f\n", inputValues[i], filteredValue);
  41.     }
  42.  
  43.     return 0;
  44. }

HighPassFilter 结构体用于存储滤波器的状态信息，包括时间常数和上一次的输出。initializeFilter 函数用于初始化滤波器，而 filterValue 函数实现了一阶高通滤波的操作。在 main 函数中，我们创建了一个 HighPassFilter 实例，并对一系列输入值进行滤波处理，输出滤波后的值。

11.二阶高通滤波

原理

二阶高通滤波器是高通滤波的二阶差分形式，用于滤除输入信号中的低频分量，同时保留高频分量。相较于一阶高通滤波器，二阶高通滤波器在频域上更为复杂，具有更陡的滤波特性。它可以更有效地抑制低频噪声，同时允许高频信号通过。

一个常见的二阶高通滤波器可以通过差分方程表示为：

y[n] = \alpha \cdot y[n-2] - \beta \cdot x[n-2] + 2\cdot \beta \cdot x[n-1] - \alpha \cdot y[n-1]

其中：

  • y[n] 是当前时刻的输出。
  • y[n-1] 和 y[n-2] 是上两个时刻的输出。
  • x[n-1] 和 x[n-2] 是上两个时刻的输入。
  • \alpha 和 \beta 是介于 0 和 1 之间的常数，分别表示两个不同的时间常数，决定了滤波器的特性。

在这个方程中，\alpha 和 \beta 的选择影响了滤波器的频率响应和阶数。较小的时间常数表示较大的截止频率，而较大的时间常数表示较小的截止频率。这样，可以根据具体需求调整时间常数来达到期望的滤波效果。

二阶高通滤波器通常应用于需要更复杂频率响应和更好滤波性能的情况，如音频处理、图像处理和控制系统等领域。

代码

  1. #include <stdio.h>
  2.  
  3. // 定义二阶高通滤波器结构体
  4. typedef struct {
  5.     float alpha;           // 第一个时间常数
  6.     float beta;            // 第二个时间常数
  7.     float previous_output[2]; // 上两个时刻的输出
  8.     float previous_input[2];  // 上两个时刻的输入
  9. } SecondOrderHighPassFilter;
  10.  
  11. // 初始化滤波器
  12. void initializeFilter(SecondOrderHighPassFilter* filter, float alpha, float beta) {
  13.     filter->alpha = alpha;
  14.     filter->beta = beta;
  15.     filter->previous_output[0] = 0.0;
  16.     filter->previous_output[1] = 0.0;
  17.     filter->previous_input[0] = 0.0;
  18.     filter->previous_input[1] = 0.0;
  19. }
  20.  
  21. // 二阶高通滤波函数
  22. float filterValue(SecondOrderHighPassFilter* filter, float input) {
  23.     // 计算输出
  24.     float output = filter->alpha * (filter->previous_output[1] - filter->previous_input[1]) +
  25.                    filter->beta * (input - 2.0 * filter->previous_input[1] + filter->previous_input[0]) +
  26.                    filter->alpha * filter->previous_output[0];
  27.  
  28.     // 更新上两次的输出和输入
  29.     filter->previous_output[1] = filter->previous_output[0];
  30.     filter->previous_output[0] = output;
  31.     filter->previous_input[1] = filter->previous_input[0];
  32.     filter->previous_input[0] = input;
  33.  
  34.     return output;
  35. }
  36.  
  37. int main() {
  38.     // 初始化滤波器，设置两个时间常数
  39.     float alpha = 0.1;
  40.     float beta = 0.1;
  41.     SecondOrderHighPassFilter myFilter;
  42.     initializeFilter(&myFilter, alpha, beta);
  43.  
  44.     // 使用示例
  45.     float inputValues[] = {10.0, 15.0, 20.0, 18.0, 22.0, 25.0, 17.0};
  46.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  47.  
  48.     printf("Input Values:\tFiltered Values:\n");
  49.  
  50.     for (int i = 0; i < numValues; ++i) {
  51.         float filteredValue = filterValue(&myFilter, inputValues[i]);
  52.         printf("%.2f\t\t%.2f\n", inputValues[i], filteredValue);
  53.     }
  54.  
  55.     return 0;
  56. }

SecondOrderHighPassFilter 结构体用于存储滤波器的状态信息，包括两个时间常数和上两次的输出和输入。initializeFilter 函数用于初始化滤波器，而 filterValue 函数实现了二阶高通滤波的操作。在 main 函数中，我们创建了一个 SecondOrderHighPassFilter 实例，并对一系列输入值进行滤波处理，输出滤波后的值。

12.带通有限脉冲响应滤波器（BPF）

原理

带通有限脉冲响应滤波器（Bandpass Finite Impulse Response Filter，BPF）是一种特殊类型的滤波器，其频率响应在频率域上对特定频率范围进行通带（通过）操作，而在其他频率范围上进行阻带（衰减）操作。与其他类型的滤波器相比，有限脉冲响应（FIR）滤波器的特点是其脉冲响应是有限长度的。

带通有限脉冲响应滤波器的设计通常涉及确定以下关键参数：

  1. 中心频率（f_c​）： 定义了通带的中心频率，即允许通过的频率范围的中点。

  2. 带宽（B）： 定义了通带的宽度，即允许通过的频率范围的宽度。带宽通常表示为频率范围内通过的频率之间的差异。

  3. 通带波纹（Ripple）： 描述了通带内允许的最大振幅变化。

  4. 阻带衰减（Stopband Attenuation）： 描述了阻带内信号被滤波器抑制的程度。

带通有限脉冲响应滤波器的传递函数可以表示为

H(f) = \frac{\sum _{n=0}^{N-1} h[n]\cdot e^{-j\cdot 2\cdot\pi \cdot f_n}}{\sum _{n=0}^{N-1} h[n]\cdot e^{-j\cdot 2\cdot\pi \cdot f_n}}

其中：

  • H(f) 是频率响应。
  • f 是频率。
  • h[n] 是滤波器的冲激响应系数。
  • N 是冲激响应的长度。

设计带通有限脉冲响应滤波器的方法包括窗函数法、频率采样法、最小均方误差法等。窗函数法是常用的一种设计方法，它通过在频域上使用窗函数来截断冲激响应。

带通有限脉冲响应滤波器在信号处理领域中广泛应用，特别是在通信系统、音频处理和生物医学信号处理等领域。带通滤波器可用于从混合信号中选择特定频率范围的组件，或者用于调整信号的频率特性。

代码

  1. #include <stdio.h>
  2. #include <math.h>
  3.  
  4. #define N 64  // 滤波器的冲激响应长度
  5.  
  6. // 定义带通有限脉冲响应滤波器结构体
  7. typedef struct {
  8.     double h[N];  // 冲激响应系数
  9.     double buffer[N];  // 缓冲区
  10. } BandpassFilter;
  11.  
  12. // 初始化滤波器
  13. void initializeFilter(BandpassFilter* filter) {
  14.     // 假设中心频率为0.1，带宽为0.02，采样率为1
  15.     double fc = 0.1;
  16.     double B = 0.02;
  17.     double fs = 1.0;
  18.  
  19.     // 计算冲激响应系数
  20.     for (int n = 0; n < N; ++n) {
  21.         double t = n - (N - 1) / 2.0;
  22.         if (t == 0) {
  23.             filter->h[n] = 2 * fc / fs;
  24.         } else {
  25.             filter->h[n] = (sin(2 * M_PI * fc * t / fs) / (M_PI * t)) * sin(2 * M_PI * B * t / fs);
  26.         }
  27.     }
  28.  
  29.     // 初始化缓冲区
  30.     for (int i = 0; i < N; ++i) {
  31.         filter->buffer[i] = 0.0;
  32.     }
  33. }
  34.  
  35. // 带通有限脉冲响应滤波函数
  36. double filterValue(BandpassFilter* filter, double input) {
  37.     // 更新缓冲区
  38.     for (int i = N - 1; i > 0; --i) {
  39.         filter->buffer[i] = filter->buffer[i - 1];
  40.     }
  41.     filter->buffer[0] = input;
  42.  
  43.     // 计算输出
  44.     double output = 0.0;
  45.     for (int i = 0; i < N; ++i) {
  46.         output += filter->h[i] * filter->buffer[i];
  47.     }
  48.  
  49.     return output;
  50. }
  51.  
  52. int main() {
  53.     // 初始化带通有限脉冲响应滤波器
  54.     BandpassFilter myFilter;
  55.     initializeFilter(&myFilter);
  56.  
  57.     // 使用示例
  58.     double inputValues[] = {0.5, 0.2, -0.3, 0.8, -0.6, 0.4, -0.1};
  59.     int numValues = sizeof(inputValues) / sizeof(inputValues[0]);
  60.  
  61.     printf("Input Values:\tFiltered Values:\n");
  62.  
  63.     for (int i = 0; i < numValues; ++i) {
  64.         double filteredValue = filterValue(&myFilter, inputValues[i]);
  65.         printf("%.2f\t\t%.2f\n", inputValues[i], filteredValue);
  66.     }
  67.  
  68.     return 0;
  69. }

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号