Arduino11大滤波器(网上收集).docx

一、 限幅滤波法（又称程序判断滤波法）
1. /*
2. A、名称：限幅滤波法（又称程序判断滤波法）
3. B、方法：
4.     根据经验判断，确定两次采样允许的最大偏差值（设为A），
5.     每次检测到新值时判断：
6.     如果本次值与上次值之差<=A，则本次值有效，
7.     如果本次值与上次值之差>A，则本次值无效，放弃本次值，用上次值代替本次值。
8. C、优点：
9.     能有效克服因偶然因素引起的脉冲干扰。
10. D、缺点：
11.     无法抑制那种周期性的干扰。
12.     平滑度差。
13. E、整理：shenhaiyu 2013-11-01
14. */
15.  
16. int Filter_Value;
17. int Value;
18.  
19. void setup() {
20.   Serial.begin(9600);       // 初始化串口通信
21.   randomSeed(analogRead(0)); // 产生随机种子
22.   Value = 300;
23. }
24.  
25. void loop() {
26.   Filter_Value = Filter();       // 获得滤波器输出值
27.   Value = Filter_Value;          // 最近一次有效采样的值，该变量为全局变量
28.   Serial.println(Filter_Value); // 串口输出
29.   delay(50);
30. }
31.  
32. // 用于随机产生一个300左右的当前值
33. int Get_AD() {
34.   return random(295, 305);
35. }
36.  
37. // 限幅滤波法（又称程序判断滤波法）
38. #define FILTER_A 1
39. int Filter() {
40.   int NewValue;
41.   NewValue = Get_AD();
42.   if(((NewValue - Value) > FILTER_A) || ((Value - NewValue) > FILTER_A))
43.     return Value;
44.   else
45.     return NewValue;
46. }
1. /*
2.

3. A、名称：限幅滤波法（又称程序判断滤波法）
4.

5. B、方法：
6.

7.     根据经验判断，确定两次采样允许的最大偏差值（设为A），
8.

9.     每次检测到新值时判断：
10.

11.     如果本次值与上次值之差<=A，则本次值有效，
12.

13.     如果本次值与上次值之差>A，则本次值无效，放弃本次值，用上次值代替本次值。
14.

15. C、优点：
16.

17.     能有效克服因偶然因素引起的脉冲干扰。
18.

19. D、缺点：
20.

21.     无法抑制那种周期性的干扰。
22.

23.     平滑度差。
24.

25. E、整理：shenhaiyu 2013-11-01
26.

27. */
28.

29.  
30.

31. int Filter_Value;
32.

33. int Value;
34.

35.  
36.

37. void setup() {
38.

39.   Serial.begin(9600);       // 初始化串口通信
40.

41.   randomSeed(analogRead(0)); // 产生随机种子
42.

43.   Value = 300;
44.

45. }
46.

47.  
48.

49. void loop() {
50.

51.   Filter_Value = Filter();       // 获得滤波器输出值
52.

53.   Value = Filter_Value;          // 最近一次有效采样的值，该变量为全局变量
54.

55.   Serial.println(Filter_Value); // 串口输出
56.

57.   delay(50);
58.

59. }
60.

61.  
62.

63. // 用于随机产生一个300左右的当前值
64.

65. int Get_AD() {
66.

67.   return random(295, 305);
68.

69. }
70.

71.  
72.

73. // 限幅滤波法（又称程序判断滤波法）
74.

75. #define FILTER_A 1
76.

77. int Filter() {
78.

79.   int NewValue;
80.

81.   NewValue = Get_AD();
82.

83.   if(((NewValue - Value) > FILTER_A) || ((Value - NewValue) > FILTER_A))
84.

85.     return Value;
86.

87.   else
88.

89.     return NewValue;
90.

91. }
92.

二、 中位值滤波法

1. /*
2. A、名称：中位值滤波法
3. B、方法：
4.     连续采样N次（N取奇数），把N次采样值按大小排列，
5.     取中间值为本次有效值。
6. C、优点：
7.     能有效克服因偶然因素引起的波动干扰；
8.     对温度、液位的变化缓慢的被测参数有良好的滤波效果。
9. D、缺点：
10.     对流量、速度等快速变化的参数不宜。
11. E、整理：shenhaiyu 2013-11-01
12. */
13.  
14. int Filter_Value;
15.  
16. void setup() {
17.   Serial.begin(9600);       // 初始化串口通信
18.   randomSeed(analogRead(0)); // 产生随机种子
19. }
20.  
21. void loop() {
22.   Filter_Value = Filter();       // 获得滤波器输出值
23.   Serial.println(Filter_Value); // 串口输出
24.   delay(50);
25. }
26.  
27. // 用于随机产生一个300左右的当前值
28. int Get_AD() {
29.   return random(295, 305);
30. }
31.  
32. // 中位值滤波法
33. #define FILTER_N 101
34. int Filter() {
35.   int filter_buf[FILTER_N];
36.   int i, j;
37.   int filter_temp;
38.   for(i = 0; i < FILTER_N; i++) {
39.     filter_buf[i] = Get_AD();
40.     delay(1);
41.   }
42.   // 采样值从小到大排列（冒泡法）
43.   for(j = 0; j < FILTER_N - 1; j++) {
44.     for(i = 0; i < FILTER_N - 1 - j; i++) {
45.       if(filter_buf[i] > filter_buf[i + 1]) {
46.         filter_temp = filter_buf[i];
47.         filter_buf[i] = filter_buf[i + 1];
48.         filter_buf[i + 1] = filter_temp;
49.       }
50.     }
51.   }
52.   return filter_buf[(FILTER_N - 1) / 2];
53. }
1. /*
2.

3. A、名称：中位值滤波法
4.

5. B、方法：
6.

7.     连续采样N次（N取奇数），把N次采样值按大小排列，
8.

9.     取中间值为本次有效值。
10.

11. C、优点：
12.

13.     能有效克服因偶然因素引起的波动干扰；
14.

15.     对温度、液位的变化缓慢的被测参数有良好的滤波效果。
16.

17. D、缺点：
18.

19.     对流量、速度等快速变化的参数不宜。
20.

21. E、整理：shenhaiyu 2013-11-01
22.

23. */
24.

25.  
26.

27. int Filter_Value;
28.

29.  
30.

31. void setup() {
32.

33.   Serial.begin(9600);       // 初始化串口通信
34.

35.   randomSeed(analogRead(0)); // 产生随机种子
36.

37. }
38.

39.  
40.

41. void loop() {
42.

43.   Filter_Value = Filter();       // 获得滤波器输出值
44.

45.   Serial.println(Filter_Value); // 串口输出
46.

47.   delay(50);
48.

49. }
50.

51.  
52.

53. // 用于随机产生一个300左右的当前值
54.

55. int Get_AD() {
56.

57.   return random(295, 305);
58.

59. }
60.

61.  
62.

63. // 中位值滤波法
64.

65. #define FILTER_N 101
66.

67. int Filter() {
68.

69.   int filter_buf[FILTER_N];
70.

71.   int i, j;
72.

73.   int filter_temp;
74.

75.   for(i = 0; i < FILTER_N; i++) {
76.

77.     filter_buf[i] = Get_AD();
78.

79.     delay(1);
80.

81.   }
82.

83.   // 采样值从小到大排列（冒泡法）
84.

85.   for(j = 0; j < FILTER_N - 1; j++) {
86.

87.     for(i = 0; i < FILTER_N - 1 - j; i++) {
88.

89.       if(filter_buf[i] > filter_buf[i + 1]) {
90.

91.         filter_temp = filter_buf[i];
92.

93.         filter_buf[i] = filter_buf[i + 1];
94.

95.         filter_buf[i + 1] = filter_temp;
96.

97.       }
98.

99.     }
100.

101.   }
102.

103.   return filter_buf[(FILTER_N - 1) / 2];
104.

105. }
106.

三、 算术平均滤波法

1. /*
2. A、名称：算术平均滤波法
3. B、方法：
4.     连续取N个采样值进行算术平均运算：
5.     N值较大时：信号平滑度较高，但灵敏度较低；
6.     N值较小时：信号平滑度较低，但灵敏度较高；
7.     N值的选取：一般流量，N=12；压力：N=4。
8. C、优点：
9.     适用于对一般具有随机干扰的信号进行滤波；
10.     这种信号的特点是有一个平均值，信号在某一数值范围附近上下波动。
11. D、缺点：
12.     对于测量速度较慢或要求数据计算速度较快的实时控制不适用；
13.     比较浪费RAM。
14. E、整理：shenhaiyu 2013-11-01
15. */
16.  
17. int Filter_Value;
18.  
19. void setup() {
20.   Serial.begin(9600);       // 初始化串口通信
21.   randomSeed(analogRead(0)); // 产生随机种子
22. }
23.  
24. void loop() {
25.   Filter_Value = Filter();       // 获得滤波器输出值
26.   Serial.println(Filter_Value); // 串口输出
27.   delay(50);
28. }
29.  
30. // 用于随机产生一个300左右的当前值
31. int Get_AD() {
32.   return random(295, 305);
33. }
34.  
35. // 算术平均滤波法
36. #define FILTER_N 12
37. int Filter() {
38.   int i;
39.   int filter_sum = 0;
40.   for(i = 0; i < FILTER_N; i++) {
41.     filter_sum += Get_AD();
42.     delay(1);
43.   }
44.   return (int)(filter_sum / FILTER_N);
45. }
1. /*
2.

3. A、名称：算术平均滤波法
4.

5. B、方法：
6.

7.     连续取N个采样值进行算术平均运算：
8.

9.     N值较大时：信号平滑度较高，但灵敏度较低；
10.

11.     N值较小时：信号平滑度较低，但灵敏度较高；
12.

13.     N值的选取：一般流量，N=12；压力：N=4。
14.

15. C、优点：
16.

17.     适用于对一般具有随机干扰的信号进行滤波；
18.

19.     这种信号的特点是有一个平均值，信号在某一数值范围附近上下波动。
20.

21. D、缺点：
22.

23.     对于测量速度较慢或要求数据计算速度较快的实时控制不适用；
24.

25.     比较浪费RAM。
26.

27. E、整理：shenhaiyu 2013-11-01
28.

29. */
30.

31.  
32.

33. int Filter_Value;
34.

35.  
36.

37. void setup() {
38.

39.   Serial.begin(9600);       // 初始化串口通信
40.

41.   randomSeed(analogRead(0)); // 产生随机种子
42.

43. }
44.

45.  
46.

47. void loop() {
48.

49.   Filter_Value = Filter();       // 获得滤波器输出值
50.

51.   Serial.println(Filter_Value); // 串口输出
52.

53.   delay(50);
54.

55. }
56.

57.  
58.

59. // 用于随机产生一个300左右的当前值
60.

61. int Get_AD() {
62.

63.   return random(295, 305);
64.

65. }
66.

67.  
68.

69. // 算术平均滤波法
70.

71. #define FILTER_N 12
72.

73. int Filter() {
74.

75.   int i;
76.

77.   int filter_sum = 0;
78.

79.   for(i = 0; i < FILTER_N; i++) {
80.

81.     filter_sum += Get_AD();
82.

83.     delay(1);
84.

85.   }
86.

87.   return (int)(filter_sum / FILTER_N);
88.

89. }
90.

四、 递推平均滤波法（又称滑动平均滤波法）

1. /*
2. A、名称：递推平均滤波法（又称滑动平均滤波法）
3. B、方法：
4.     把连续取得的N个采样值看成一个队列，队列的长度固定为N，
5.     每次采样到一个新数据放入队尾，并扔掉原来队首的一次数据（先进先出原则），
6.     把队列中的N个数据进行算术平均运算，获得新的滤波结果。
7.     N值的选取：流量，N=12；压力，N=4；液面，N=4-12；温度，N=1-4。
8. C、优点：
9.     对周期性干扰有良好的抑制作用，平滑度高；
10.     适用于高频振荡的系统。
11. D、缺点：
12.     灵敏度低，对偶然出现的脉冲性干扰的抑制作用较差；
13.     不易消除由于脉冲干扰所引起的采样值偏差；
14.     不适用于脉冲干扰比较严重的场合；
15.     比较浪费RAM。
16. E、整理：shenhaiyu 2013-11-01
17. */
18.  
19. int Filter_Value;
20.  
21. void setup() {
22.   Serial.begin(9600);       // 初始化串口通信
23.   randomSeed(analogRead(0)); // 产生随机种子
24. }
25.  
26. void loop() {
27.   Filter_Value = Filter();       // 获得滤波器输出值
28.   Serial.println(Filter_Value); // 串口输出
29.   delay(50);
30. }
31.  
32. // 用于随机产生一个300左右的当前值
33. int Get_AD() {
34.   return random(295, 305);
35. }
36.  
37. // 递推平均滤波法（又称滑动平均滤波法）
38. #define FILTER_N 12
39. int filter_buf[FILTER_N + 1];
40. int Filter() {
41.   int i;
42.   int filter_sum = 0;
43.   filter_buf[FILTER_N] = Get_AD();
44.   for(i = 0; i < FILTER_N; i++) {
45.     filter_buf[i] = filter_buf[i + 1]; // 所有数据左移，低位仍掉
46.     filter_sum += filter_buf[i];
47.   }
48.   return (int)(filter_sum / FILTER_N);
49. }
1. /*
2.

3. A、名称：递推平均滤波法（又称滑动平均滤波法）
4.

5. B、方法：
6.

7.     把连续取得的N个采样值看成一个队列，队列的长度固定为N，
8.

9.     每次采样到一个新数据放入队尾，并扔掉原来队首的一次数据（先进先出原则），
10.

11.     把队列中的N个数据进行算术平均运算，获得新的滤波结果。
12.

13.     N值的选取：流量，N=12；压力，N=4；液面，N=4-12；温度，N=1-4。
14.

15. C、优点：
16.

17.     对周期性干扰有良好的抑制作用，平滑度高；
18.

19.     适用于高频振荡的系统。
20.

21. D、缺点：
22.

23.     灵敏度低，对偶然出现的脉冲性干扰的抑制作用较差；
24.

25.     不易消除由于脉冲干扰所引起的采样值偏差；
26.

27.     不适用于脉冲干扰比较严重的场合；
28.

29.     比较浪费RAM。
30.

31. E、整理：shenhaiyu 2013-11-01
32.

33. */
34.

35.  
36.

37. int Filter_Value;
38.

39.  
40.

41. void setup() {
42.

43.   Serial.begin(9600);       // 初始化串口通信
44.

45.   randomSeed(analogRead(0)); // 产生随机种子
46.

47. }
48.

49.  
50.

51. void loop() {
52.

53.   Filter_Value = Filter();       // 获得滤波器输出值
54.

55.   Serial.println(Filter_Value); // 串口输出
56.

57.   delay(50);
58.

59. }
60.

61.  
62.

63. // 用于随机产生一个300左右的当前值
64.

65. int Get_AD() {
66.

67.   return random(295, 305);
68.

69. }
70.

71.  
72.

73. // 递推平均滤波法（又称滑动平均滤波法）
74.

75. #define FILTER_N 12
76.

77. int filter_buf[FILTER_N + 1];
78.

79. int Filter() {
80.

81.   int i;
82.

83.   int filter_sum = 0;
84.

85.   filter_buf[FILTER_N] = Get_AD();
86.

87.   for(i = 0; i < FILTER_N; i++) {
88.

89.     filter_buf[i] = filter_buf[i + 1]; // 所有数据左移，低位仍掉
90.

91.     filter_sum += filter_buf[i];
92.

93.   }
94.

95.   return (int)(filter_sum / FILTER_N);
96.

97. }
98.

五、 中位值平均滤波法（又称防脉冲干扰平均滤波法）

1. /*
2. A、名称：中位值平均滤波法（又称防脉冲干扰平均滤波法）
3. B、方法：
4.     采一组队列去掉最大值和最小值后取平均值，
5.     相当于“中位值滤波法”+“算术平均滤波法”。
6.     连续采样N个数据，去掉一个最大值和一个最小值，
7.     然后计算N-2个数据的算术平均值。
8.     N值的选取：3-14。
9. C、优点：
10.     融合了“中位值滤波法”+“算术平均滤波法”两种滤波法的优点。
11.     对于偶然出现的脉冲性干扰，可消除由其所引起的采样值偏差。
12.     对周期干扰有良好的抑制作用。
13.     平滑度高，适于高频振荡的系统。
14. D、缺点：
15.     计算速度较慢，和算术平均滤波法一样。
16.     比较浪费RAM。
17. E、整理：shenhaiyu 2013-11-01
18. */
19.  
20. int Filter_Value;
21.  
22. void setup() {
23.   Serial.begin(9600);       // 初始化串口通信
24.   randomSeed(analogRead(0)); // 产生随机种子
25. }
26.  
27. void loop() {
28.   Filter_Value = Filter();       // 获得滤波器输出值
29.   Serial.println(Filter_Value); // 串口输出
30.   delay(50);
31. }
32.  
33. // 用于随机产生一个300左右的当前值
34. int Get_AD() {
35.   return random(295, 305);
36. }
37.  
38. // 中位值平均滤波法（又称防脉冲干扰平均滤波法）（算法1）
39. #define FILTER_N 100
40. int Filter() {
41.   int i, j;
42.   int filter_temp, filter_sum = 0;
43.   int filter_buf[FILTER_N];
44.   for(i = 0; i < FILTER_N; i++) {
45.     filter_buf[i] = Get_AD();
46.     delay(1);
47.   }
48.   // 采样值从小到大排列（冒泡法）
49.   for(j = 0; j < FILTER_N - 1; j++) {
50.     for(i = 0; i < FILTER_N - 1 - j; i++) {
51.       if(filter_buf[i] > filter_buf[i + 1]) {
52.         filter_temp = filter_buf[i];
53.         filter_buf[i] = filter_buf[i + 1];
54.         filter_buf[i + 1] = filter_temp;
55.       }
56.     }
57.   }
58.   // 去除最大最小极值后求平均
59.   for(i = 1; i < FILTER_N - 1; i++) filter_sum += filter_buf[i];
60.   return filter_sum / (FILTER_N - 2);
61. }
62.  
63.  
64. //  中位值平均滤波法（又称防脉冲干扰平均滤波法）（算法2）
65. /*
66. #define FILTER_N 100
67. int Filter() {
68.   int i;
69.   int filter_sum = 0;
70.   int filter_max, filter_min;
71.   int filter_buf[FILTER_N];
72.   for(i = 0; i < FILTER_N; i++) {
73.     filter_buf[i] = Get_AD();
74.     delay(1);
75.   }
76.   filter_max = filter_buf[0];
77.   filter_min = filter_buf[0];
78.   filter_sum = filter_buf[0];
79.   for(i = FILTER_N - 1; i > 0; i--) {
80.     if(filter_buf[i] > filter_max)
81.       filter_max=filter_buf[i];
82.     else if(filter_buf[i] < filter_min)
83.       filter_min=filter_buf[i];
84.     filter_sum = filter_sum + filter_buf[i];
85.     filter_buf[i] = filter_buf[i - 1];
86.   }
87.   i = FILTER_N - 2;
88.   filter_sum = filter_sum - filter_max - filter_min + i / 2; // +i/2 的目的是为了四舍五入
89.   filter_sum = filter_sum / i;
90.   return filter_sum;
91. }*/

1. /*
2.

3. A、名称：中位值平均滤波法（又称防脉冲干扰平均滤波法）
4.

5. B、方法：
6.

7.     采一组队列去掉最大值和最小值后取平均值，
8.

9.     相当于“中位值滤波法”+“算术平均滤波法”。
10.

11.     连续采样N个数据，去掉一个最大值和一个最小值，
12.

13.     然后计算N-2个数据的算术平均值。
14.

15.     N值的选取：3-14。
16.

17. C、优点：
18.

19.     融合了“中位值滤波法”+“算术平均滤波法”两种滤波法的优点。
20.

21.     对于偶然出现的脉冲性干扰，可消除由其所引起的采样值偏差。
22.

23.     对周期干扰有良好的抑制作用。
24.

25.     平滑度高，适于高频振荡的系统。
26.

27. D、缺点：
28.

29.     计算速度较慢，和算术平均滤波法一样。
30.

31.     比较浪费RAM。
32.

33. E、整理：shenhaiyu 2013-11-01
34.

35. */
36.

37.  
38.

39. int Filter_Value;
40.

41.  
42.

43. void setup() {
44.

45.   Serial.begin(9600);       // 初始化串口通信
46.

47.   randomSeed(analogRead(0)); // 产生随机种子
48.

49. }
50.

51.  
52.

53. void loop() {
54.

55.   Filter_Value = Filter();       // 获得滤波器输出值
56.

57.   Serial.println(Filter_Value); // 串口输出
58.

59.   delay(50);
60.

61. }
62.

63.  
64.

65. // 用于随机产生一个300左右的当前值
66.

67. int Get_AD() {
68.

69.   return random(295, 305);
70.

71. }
72.

73.  
74.

75. // 中位值平均滤波法（又称防脉冲干扰平均滤波法）（算法1）
76.

77. #define FILTER_N 100
78.

79. int Filter() {
80.

81.   int i, j;
82.

83.   int filter_temp, filter_sum = 0;
84.

85.   int filter_buf[FILTER_N];
86.

87.   for(i = 0; i < FILTER_N; i++) {
88.

89.     filter_buf[i] = Get_AD();
90.

91.     delay(1);
92.

93.   }
94.

95.   // 采样值从小到大排列（冒泡法）
96.

97.   for(j = 0; j < FILTER_N - 1; j++) {
98.

99.     for(i = 0; i < FILTER_N - 1 - j; i++) {
100.

101.       if(filter_buf[i] > filter_buf[i + 1]) {
102.

103.         filter_temp = filter_buf[i];
104.

105.         filter_buf[i] = filter_buf[i + 1];
106.

107.         filter_buf[i + 1]