滤波算法总结

几种经典常用的滤波算法 1、限幅滤波法(又称程序判断滤波法) A、方法: 根据经验判断,确定两次采样允许的最大偏差值(设为 A) 每次检测到新值时判断: 如果本次值与上次值之差 <=A, 则本次值有效 如果本次值与上次值之差 > A, 则本次值无效, 放弃本次值, 用上次值代替本次值 B、优点: 能有效克服因偶然因素引起的脉冲干扰 C、缺点 无法抑制那种周期性的干扰 平滑度差 2、中位值滤波法 A、方法: 连续采样 N 次(N 取奇数) 把 N 阅读详情
以下内容转自:http://www.geek-workshop.com/thread-7694-1-1.html


最近用Arduino做电子秤,为了解决数据的跳变研究了不少滤波算法。网上能找到大把的十大滤波算法帖子,每一篇都不太一样,都号称精编啊,除错啊什么的,可是放到板子里却没一个能正常跑起来的。于是决定自己整理一下这些程序,完美移植到Arduino中。

所以大家看到这个帖子的时候,不要怀疑我重复发帖。我的代码都是经过反复试验,复制到Arduino中就能开跑的成品代码,移植到自己的程序中非常方便。而且都仔细研究了各个算法,把错误都修正了的(别的程序连冒泡算法都是溢出的,不信自己找来细看看),所以也算个小原创吧,在别人基础上的原创。

转载请注明出处:极客工坊  http://www.geek-workshop.com/thread-7694-1-1.html

By shenhaiyu 2013-11-01



1、限幅滤波法(又称程序判断滤波法)
2、中位值滤波法
3、算术平均滤波法
4、递推平均滤波法(又称滑动平均滤波法)
5、中位值平均滤波法(又称防脉冲干扰平均滤波法)
6、限幅平均滤波法
7、一阶滞后滤波法
8、加权递推平均滤波法
9、消抖滤波法
10、限幅消抖滤波法
11、新增加 卡尔曼滤波(非扩展卡尔曼),代码在17楼(点击这里)感谢zhangzhe0617分享

程序默认对int类型数据进行滤波,如需要对其他类型进行滤波,只需要把程序中所有int替换成long、float或者double即可。



1、限幅滤波法(又称程序判断滤波法)
ARDUINO 代码 复制打印
       
  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. }





2、中位值滤波法
ARDUINO 代码 复制打印
       
  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. }





3、算术平均滤波法
ARDUINO 代码 复制打印
       
  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. }





4、递推平均滤波法(又称滑动平均滤波法)
ARDUINO 代码 复制打印
       
  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. }





5、中位值平均滤波法(又称防脉冲干扰平均滤波法)
ARDUINO 代码 复制打印
       
  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. }*/





6、限幅平均滤波法
ARDUINO 代码 复制打印
       
  1. /*
  2. A、名称:限幅平均滤波法
  3. B、方法:
  4.     相当于“限幅滤波法”+“递推平均滤波法”;
  5.     每次采样到的新数据先进行限幅处理,
  6.     再送入队列进行递推平均滤波处理。
  7. C、优点:
  8.     融合了两种滤波法的优点;
  9.     对于偶然出现的脉冲性干扰,可消除由于脉冲干扰所引起的采样值偏差。
  10. D、缺点:
  11.     比较浪费RAM。
  12. E、整理:shenhaiyu 2013-11-01
  13. */
  14.  
  15. #define FILTER_N 12
  16. int Filter_Value;
  17. int filter_buf [FILTER_N ];
  18.  
  19. void setup ( ) {
  20.    Serial. begin ( 9600 );       // 初始化串口通信
  21.    randomSeed ( analogRead ( 0 ) ); // 产生随机种子
  22.   filter_buf [FILTER_N - 2 ] = 300;
  23. }
  24.  
  25. void loop ( ) {
  26.   Filter_Value = Filter ( );       // 获得滤波器输出值
  27.    Serial. println (Filter_Value ); // 串口输出
  28.    delay ( 50 );
  29. }
  30.  
  31. // 用于随机产生一个300左右的当前值
  32. int Get_AD ( ) {
  33.    return random ( 295, 305 );
  34. }
  35.  
  36. // 限幅平均滤波法
  37. #define FILTER_A 1
  38. int Filter ( ) {
  39.    int i;
  40.    int filter_sum = 0;
  41.   filter_buf [FILTER_N - 1 ] = Get_AD ( );
  42.    if ( ( (filter_buf [FILTER_N - 1 ] - filter_buf [FILTER_N - 2 ] ) > FILTER_A ) || ( (filter_buf [FILTER_N - 2 ] - filter_buf [FILTER_N - 1 ] ) > FILTER_A ) )
  43.     filter_buf [FILTER_N - 1 ] = filter_buf [FILTER_N - 2 ];
  44.    for (i = 0; i < FILTER_N - 1; i++ ) {
  45.     filter_buf [i ] = filter_buf [i + 1 ];
  46.     filter_sum += filter_buf [i ];
  47.    }
  48.    return ( int )filter_sum / (FILTER_N - 1 );
  49. }





7、一阶滞后滤波法
ARDUINO 代码 复制打印
       
  1. /*
  2. A、名称:一阶滞后滤波法
  3. B、方法:
  4.     取a=0-1,本次滤波结果=(1-a)*本次采样值+a*上次滤波结果。
  5. C、优点:
  6.     对周期性干扰具有良好的抑制作用;
  7.     适用于波动频率较高的场合。
  8. D、缺点:
  9.     相位滞后,灵敏度低;
  10.     滞后程度取决于a值大小;
  11.     不能消除滤波频率高于采样频率1/2的干扰信号。
  12. E、整理:shenhaiyu 2013-11-01
  13. */
  14.  
  15. int Filter_Value;
  16. int Value;
  17.  
  18. void setup ( ) {
  19.    Serial. begin ( 9600 );       // 初始化串口通信
  20.    randomSeed ( analogRead ( 0 ) ); // 产生随机种子
  21.   Value = 300;
  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_A 0.01
  37. int Filter ( ) {
  38.    int NewValue;
  39.   NewValue = Get_AD ( );
  40.   Value = ( int ) ( ( float )NewValue * FILTER_A + ( 1.0 - FILTER_A ) * ( float )Value );
  41.    return Value;
  42. }





8、加权递推平均滤波法
ARDUINO 代码 复制打印
       
  1. /*
  2. A、名称:加权递推平均滤波法
  3. B、方法:
  4.     是对递推平均滤波法的改进,即不同时刻的数据加以不同的权;
  5.     通常是,越接近现时刻的数据,权取得越大。
  6.     给予新采样值的权系数越大,则灵敏度越高,但信号平滑度越低。
  7. C、优点:
  8.     适用于有较大纯滞后时间常数的对象,和采样周期较短的系统。
  9. D、缺点:
  10.     对于纯滞后时间常数较小、采样周期较长、变化缓慢的信号;
  11.     不能迅速反应系统当前所受干扰的严重程度,滤波效果差。
  12. E、整理:shenhaiyu 2013-11-01
  13. */
  14.  
  15. int Filter_Value;
  16.  
  17. void setup ( ) {
  18.    Serial. begin ( 9600 );       // 初始化串口通信
  19.    randomSeed ( analogRead ( 0 ) ); // 产生随机种子
  20. }
  21.  
  22. void loop ( ) {
  23.   Filter_Value = Filter ( );       // 获得滤波器输出值
  24.    Serial. println (Filter_Value ); // 串口输出
  25.    delay ( 50 );
  26. }
  27.  
  28. // 用于随机产生一个300左右的当前值
  29. int Get_AD ( ) {
  30.    return random ( 295, 305 );
  31. }
  32.  
  33. // 加权递推平均滤波法
  34. #define FILTER_N 12
  35. int coe [FILTER_N ] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };    // 加权系数表
  36. int sum_coe = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12; // 加权系数和
  37. int filter_buf [FILTER_N + 1 ];
  38. int Filter ( ) {
  39.    int i;
  40.    int filter_sum = 0;
  41.   filter_buf [FILTER_N ] = Get_AD ( );
  42.    for (i = 0; i < FILTER_N; i++ ) {
  43.     filter_buf [i ] = filter_buf [i + 1 ]; // 所有数据左移,低位仍掉
  44.     filter_sum += filter_buf [i ] * coe [i ];
  45.    }
  46.   filter_sum /= sum_coe;
  47.    return filter_sum;
  48. }





9、消抖滤波法
ARDUINO 代码 复制打印
       
  1. /*
  2. A、名称:消抖滤波法
  3. B、方法:
  4.     设置一个滤波计数器,将每次采样值与当前有效值比较:
  5.     如果采样值=当前有效值,则计数器清零;
  6.     如果采样值<>当前有效值,则计数器+1,并判断计数器是否>=上限N(溢出);
  7.     如果计数器溢出,则将本次值替换当前有效值,并清计数器。
  8. C、优点:
  9.     对于变化缓慢的被测参数有较好的滤波效果;
  10.     可避免在临界值附近控制器的反复开/关跳动或显示器上数值抖动。
  11. D、缺点:
  12.     对于快速变化的参数不宜;
  13.     如果在计数器溢出的那一次采样到的值恰好是干扰值,则会将干扰值当作有效值导入系统。
  14. E、整理:shenhaiyu 2013-11-01
  15. */
  16.  
  17. int Filter_Value;
  18. int Value;
  19.  
  20. void setup ( ) {
  21.    Serial. begin ( 9600 );       // 初始化串口通信
  22.    randomSeed ( analogRead ( 0 ) ); // 产生随机种子
  23.   Value = 300;
  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 i = 0;
  40. int Filter ( ) {
  41.    int new_value;
  42.   new_value = Get_AD ( );
  43.    if (Value != new_value ) {
  44.     i++;
  45.     if (i > FILTER_N ) {
  46.       i = 0;
  47.       Value = new_value;
  48.     }
  49.    }
  50.    else
  51.     i = 0;
  52.    return Value;
  53. }





10、限幅消抖滤波法
ARDUINO 代码 复制打印
       
  1. /*
  2. A、名称:限幅消抖滤波法
  3. B、方法:
  4.     相当于“限幅滤波法”+“消抖滤波法”;
  5.     先限幅,后消抖。
  6. C、优点:
  7.     继承了“限幅”和“消抖”的优点;
  8.     改进了“消抖滤波法”中的某些缺陷,避免将干扰值导入系统。
  9. D、缺点:
  10.     对于快速变化的参数不宜。
  11. E、整理:shenhaiyu 2013-11-01
  12. */
  13.  
  14. int Filter_Value;
  15. int Value;
  16.  
  17. void setup ( ) {
  18.    Serial. begin ( 9600 );       // 初始化串口通信
  19.    randomSeed ( analogRead ( 0 ) ); // 产生随机种子
  20.   Value = 300;
  21. }
  22.  
  23. void loop ( ) {
  24.   Filter_Value = Filter ( );       // 获得滤波器输出值
  25.    Serial. println (Filter_Value ); // 串口输出
  26.    delay ( 50 );
  27. }
  28.  
  29. // 用于随机产生一个300左右的当前值
  30. int Get_AD ( ) {
  31.    return random ( 295, 305 );
  32. }
  33.  
  34. // 限幅消抖滤波法
  35. #define FILTER_A 1
  36. #define FILTER_N 5
  37. int i = 0;
  38. int Filter ( ) {
  39.    int NewValue;
  40.    int new_value;
  41.   NewValue = Get_AD ( );
  42.    if ( ( (NewValue - Value ) > FILTER_A ) || ( (Value - NewValue ) > FILTER_A ) )
  43.     new_value = Value;
  44.    else
  45.     new_value = NewValue;
  46.    if (Value != new_value ) {
  47.     i++;
  48.     if (i > FILTER_N ) {
  49.       i = 0;
  50.       Value = new_value;
  51.     }
  52.    }
  53.    else
  54.     i = 0;
  55.    return Value;
  56. }


建议编辑一下这个帖子作为滤波专用的,这样大家查起来也方便。下面是卡尔曼滤波,不是扩展的,但是输出平稳的俯仰和滚转应该够了(凑乎用吧我也不是专业写代码的,欢迎大家拍)
  1. #include <Wire.h> // I2C library, gyroscope

  2. // Accelerometer ADXL345
  3. #define ACC (0x53)    //ADXL345 ACC address
  4. #define A_TO_READ (6)        //num of bytes we are going to read each time (two bytes for each axis)


  5. // Gyroscope ITG3200 
  6. #define GYRO 0x68 // gyro address, binary = 11101000 when AD0 is connected to Vcc (see schematics of your breakout board)
  7. #define G_SMPLRT_DIV 0x15   
  8. #define G_DLPF_FS 0x16   
  9. #define G_INT_CFG 0x17
  10. #define G_PWR_MGM 0x3E

  11. #define G_TO_READ 8 // 2 bytes for each axis x, y, z


  12. // offsets are chip specific. 
  13. int a_offx = 0;
  14. int a_offy = 0;
  15. int a_offz = 0;

  16. int g_offx = 0;
  17. int g_offy = 0;
  18. int g_offz = 0;
  19. ////////////////////////

  20. ////////////////////////
  21. char str[512]; 

  22. void initAcc() {
  23.   //Turning on the ADXL345
  24.   writeTo(ACC, 0x2D, 0);      
  25.   writeTo(ACC, 0x2D, 16);
  26.   writeTo(ACC, 0x2D, 8);
  27.   //by default the device is in +-2g range reading
  28. }

  29. void getAccelerometerData(int* result) {
  30.   int regAddress = 0x32;    //first axis-acceleration-data register on the ADXL345
  31.   byte buff[A_TO_READ];
  32.   
  33.   readFrom(ACC, regAddress, A_TO_READ, buff); //read the acceleration data from the ADXL345
  34.   
  35.   //each axis reading comes in 10 bit resolution, ie 2 bytes.  Least Significat Byte first!!
  36.   //thus we are converting both bytes in to one int
  37.   result[0] = (((int)buff[1]) << 8) | buff[0] + a_offx;   
  38.   result[1] = (((int)buff[3]) << 8) | buff[2] + a_offy;
  39.   result[2] = (((int)buff[5]) << 8) | buff[4] + a_offz;
  40. }

  41. //initializes the gyroscope
  42. void initGyro()
  43. {
  44.   /*****************************************
  45.   * ITG 3200
  46.   * power management set to:
  47.   * clock select = internal oscillator
  48.   *     no reset, no sleep mode
  49.   *   no standby mode
  50.   * sample rate to = 125Hz
  51.   * parameter to +/- 2000 degrees/sec
  52.   * low pass filter = 5Hz
  53.   * no interrupt
  54.   ******************************************/
  55.   writeTo(GYRO, G_PWR_MGM, 0x00);
  56.   writeTo(GYRO, G_SMPLRT_DIV, 0x07); // EB, 50, 80, 7F, DE, 23, 20, FF
  57.   writeTo(GYRO, G_DLPF_FS, 0x1E); // +/- 2000 dgrs/sec, 1KHz, 1E, 19
  58.   writeTo(GYRO, G_INT_CFG, 0x00);
  59. }


  60. void getGyroscopeData(int * result)
  61. {
  62.   /**************************************
  63.   Gyro ITG-3200 I2C
  64.   registers:
  65.   temp MSB = 1B, temp LSB = 1C
  66.   x axis MSB = 1D, x axis LSB = 1E
  67.   y axis MSB = 1F, y axis LSB = 20
  68.   z axis MSB = 21, z axis LSB = 22
  69.   *************************************/

  70.   int regAddress = 0x1B;
  71.   int temp, x, y, z;
  72.   byte buff[G_TO_READ];
  73.   
  74.   readFrom(GYRO, regAddress, G_TO_READ, buff); //read the gyro data from the ITG3200
  75.   
  76.   result[0] = ((buff[2] << 8) | buff[3]) + g_offx;
  77.   result[1] = ((buff[4] << 8) | buff[5]) + g_offy;
  78.   result[2] = ((buff[6] << 8) | buff[7]) + g_offz;
  79.   result[3] = (buff[0] << 8) | buff[1]; // temperature
  80.   
  81. }


  82. float xz=0,yx=0,yz=0;
  83. float p_xz=1,p_yx=1,p_yz=1;
  84. float q_xz=0.0025,q_yx=0.0025,q_yz=0.0025;
  85. float k_xz=0,k_yx=0,k_yz=0;
  86. float r_xz=0.25,r_yx=0.25,r_yz=0.25;
  87.   //int acc_temp[3];
  88.   //float acc[3];
  89.   int acc[3];
  90.   int gyro[4];
  91.   float Axz;
  92.   float Ayx;
  93.   float Ayz;
  94.   float t=0.025;
  95. void setup()
  96. {
  97.   Serial.begin(9600);
  98.   Wire.begin();
  99.   initAcc();
  100.   initGyro();
  101.   
  102. }

  103. //unsigned long timer = 0;
  104. //float o;
  105. void loop()
  106. {
  107.   
  108.   getAccelerometerData(acc);
  109.   getGyroscopeData(gyro);
  110.   //timer = millis();
  111.   sprintf(str, "%d,%d,%d,%d,%d,%d", acc[0],acc[1],acc[2],gyro[0],gyro[1],gyro[2]);
  112.   
  113.   //acc[0]=acc[0];
  114.   //acc[2]=acc[2];
  115.   //acc[1]=acc[1];
  116.   //r=sqrt(acc[0]*acc[0]+acc[1]*acc[1]+acc[2]*acc[2]);
  117.   gyro[0]=gyro[0]/ 14.375;
  118.   gyro[1]=gyro[1]/ (-14.375);
  119.   gyro[2]=gyro[2]/ 14.375;
  120.   
  121.    
  122.   Axz=(atan2(acc[0],acc[2]))*180/PI;
  123.   Ayx=(atan2(acc[0],acc[1]))*180/PI;
  124.   /*if((acc[0]!=0)&&(acc[1]!=0))
  125.     {
  126.       Ayx=(atan2(acc[0],acc[1]))*180/PI;
  127.     }
  128.     else
  129.     {
  130.       Ayx=t*gyro[2];
  131.     }*/
  132.   Ayz=(atan2(acc[1],acc[2]))*180/PI;
  133.   
  134.   
  135. //kalman filter
  136.   calculate_xz();
  137.   calculate_yx();
  138.   calculate_yz();
  139.   
  140.   //sprintf(str, "%d,%d,%d", xz_1, xy_1, x_1);
  141.   //Serial.print(xz);Serial.print(",");
  142.   //Serial.print(yx);Serial.print(",");
  143.   //Serial.print(yz);Serial.print(",");
  144.   //sprintf(str, "%d,%d,%d,%d,%d,%d", acc[0],acc[1],acc[2],gyro[0],gyro[1],gyro[2]);
  145.   //sprintf(str, "%d,%d,%d",gyro[0],gyro[1],gyro[2]);
  146.     Serial.print(Axz);Serial.print(",");
  147.     //Serial.print(Ayx);Serial.print(",");
  148.     //Serial.print(Ayz);Serial.print(",");
  149.   //Serial.print(str);
  150.   //o=gyro[2];//w=acc[2];
  151.   //Serial.print(o);Serial.print(",");
  152.   //Serial.print(w);Serial.print(",");
  153.   Serial.print("\n");

  154.   
  155.   //delay(50);
  156. }
  157. void calculate_xz()
  158. {

  159. xz=xz+t*gyro[1];
  160. p_xz=p_xz+q_xz;
  161. k_xz=p_xz/(p_xz+r_xz);
  162. xz=xz+k_xz*(Axz-xz);
  163. p_xz=(1-k_xz)*p_xz;
  164. }
  165. void calculate_yx()
  166. {
  167.   
  168.   yx=yx+t*gyro[2];
  169.   p_yx=p_yx+q_yx;
  170.   k_yx=p_yx/(p_yx+r_yx);
  171.   yx=yx+k_yx*(Ayx-yx);
  172.   p_yx=(1-k_yx)*p_yx;

  173. }
  174. void calculate_yz()
  175. {
  176.   yz=yz+t*gyro[0];
  177.   p_yz=p_yz+q_yz;
  178.   k_yz=p_yz/(p_yz+r_yz);
  179.   yz=yz+k_yz*(Ayz-yz);
  180.   p_yz=(1-k_yz)*p_yz;

  181. }


  182. //---------------- Functions
  183. //Writes val to address register on ACC
  184. void writeTo(int DEVICE, byte address, byte val) {
  185.    Wire.beginTransmission(DEVICE); //start transmission to ACC 
  186.    Wire.write(address);        // send register address
  187.    Wire.write(val);        // send value to write
  188.    Wire.endTransmission(); //end transmission
  189. }


  190. //reads num bytes starting from address register on ACC in to buff array
  191. void readFrom(int DEVICE, byte address, int num, byte buff[]) {
  192.   Wire.beginTransmission(DEVICE); //start transmission to ACC 
  193.   Wire.write(address);        //sends address to read from
  194.   Wire.endTransmission(); //end transmission
  195.   
  196.   Wire.beginTransmission(DEVICE); //start transmission to ACC
  197.   Wire.requestFrom(DEVICE, num);    // request 6 bytes from ACC
  198.   
  199.   int i = 0;
  200.   while(Wire.available())    //ACC may send less than requested (abnormal)
  201.   { 
  202.     buff[i] = Wire.read(); // receive a byte
  203.     i++;
  204.   }
  205.   Wire.endTransmission(); //end transmission
  206. }
复制代码

点评





十大滤波(C++版) 在翻阅了网上多个版本的滤波算法,发现很多仍停留在多年以前,很多版本的更替没有完成。自己和小伙伴研究了一下,研究成果如下,因为都是比较浅显的研究,如果有不符合常理的地方,请大家指出,一起进步。 阅读详情

相关推荐

滤波算法(二)—— 中位值滤波算法

1、算法介绍 中位值滤波算法的实现方法是采集N个周期的数据,去掉N个周期数据中的最大值和最小值,取剩下的数据的平均值。中位值滤波算法特别适用于会偶然出现异常值的系统。中位值滤波算法应用比较广泛,比如用于一些比赛的评分,经常是去掉一个最高分去掉一个最低分,将其他评分取平均值作为选手的最终得分。 优点:相比于平均值滤波算法,中位值滤波算法能够有效滤除偶然的脉冲干扰。 缺点:与平均...

bigmarshal的博客 2万+

滤波算法——十大滤波算法程序大全

最近做数据采集相关的,用到去除信号抖动相关的算法,网上找了些大神分享的资源,整理如下,尊重他人成果,附转载链接:https://www.geek-workshop.com/thread-7694-1-1.html 1、限幅滤波法(又称程序判断滤波法) 2、中位值滤波法 3、算术平均滤波法 4、递推平均滤波法(又称滑动平均滤波法) 5、中位值平均滤波法(又称防脉冲干扰平均滤波法) 6、限幅...

数字世界 万物互联 1万+

滑动平均滤波算法

  算数平均滤波需要多次采样后才能得出一个有效值,如果被检测量变化较快,多次采样后才输出一次有效值,表现就是系统反应迟钝。将当前采样值与之前连续的历史采样值进行平均,这样每次采样结束即可得出有效值。因为参与计算的历史值个数固定且内容不断前移覆盖更新,类似滑动的数据块窗口,因此成为滑动平均滤波算法。   假如采样6次,每次使用最近5个历史值与当前最新值求算数平均值,输出一个有效值;下次采样时再覆盖最早时间的点做同样操作。类似环形数组,求最近6个值的平均值。   滑动平均滤波,输出的结果与先前历史记录有关,假如

123 2万+

几种常用的滤波算法

几种常用的滤波算法 在嵌入式开发中经常会用到一些滤波算法,我整理了一些资料把这些算法封装成可以直接调用的函数,方便以后的开发,包括限幅滤波、中位值滤波法、 算术平均滤波法、一阶滞后滤波法、加权递推平均滤波法、消抖滤波法 ,其他的一些包括卡尔曼滤波什么的之后有机会再整理 #include "filter.h" /* 限幅滤波   A方法: 根据经验判断,确定两次采样允许的最大偏差值(设为A),每次检测到新值时判断: 如果本次值与上次值之差<=A,则本次值有效,如果本次值与上次值之差>A,

嵌入式与人工智能 2万+

常用滤波算法简介

一种动态系统状态估计算法,通过递归预测和观测修正,实时融合多源数据(如传感器输入),用于导航、机器人定位、金融预测等场景。非线性滤波器,通过滑动窗口取中位数消除脉冲噪声(如椒盐噪声),保护图像边缘,广泛应用于工业质检、文档扫描。| ✅ 实时性强,适合动态系统 | ❌ 依赖精确模型,非线性场景需改进 || ✅ 彻底消除脉冲噪声 | ❌ 对高斯噪声无效,大窗口模糊细节 || ✅ 高效抑制高斯噪声 | ❌ 边缘模糊,丢失纹理细节 || ✅ 边缘保护强,计算高效 | ❌ 依赖引导图像质量 |

墨顿随笔 2133

几种嵌入式中常见的滤波算法

以上介绍了几种在嵌入式系统中常见的滤波算法。这些算法具有不同的特点和适用场景,开发者需要根据实际应用需求选择合适的滤波方法。滤波算法的正确选择和实现对于提高嵌入式系统的性能、可靠性和稳定性至关重要。随着技术的不断发展,未来还将有更多先进的滤波算法涌现,为嵌入式系统的设计和开发带来更多可能性。

qq_43341279的博客 2162

滤波算法详解

滤波算法

qq_31329259的博客 6760

用于称重仪表的几种数字滤波算法

用于称重仪表的几种数字滤波算法 电子称 滤波算法

点云滤波算法

本文讲解了点云常用的滤波算法及相关代码

qq_37894979的博客 5277

从补码原理到实践:RISC-V中addi指令的符号扩展机制详解

本文深入解析了RISC-V架构中addi指令的符号扩展机制。从补码的数学原理出发,详细阐述了12位立即数在指令编码中如何通过符号位进行扩展,并结合lui指令,揭示了加载任意32位立即数的正确方法与实践陷阱,帮助开发者编写高效可靠的底层代码。

weixin_29161719的博客 141

疑难问题(二)——PyTorch 2.3.0 ‘import torch‘ 错误排查:深入解析‘shm.dll‘加载失败与系统路径修复

本文深入解析了在Windows系统上安装PyTorch 2.3.0后,执行'import torch'时遇到的'shm.dll'加载失败错误(OSError)。该问题通常源于系统DLL搜索路径缺失,导致无法找到关键的共享内存通信组件或其依赖项。文章提供了核心解决方案:通过手动修改PyTorch的`__init__.py`文件,将用户基目录下的Library\bin路径添加到DLL搜索列表中,从而从根本上修复此导入错误,并给出了详细的修改步骤和验证方法。

weixin_29056865的博客 308

《图像滤波算法综述》

通过对高斯滤波、中值滤波、双边滤波和锐化滤波等常见算法的了解和应用,我们可以根据不同的噪声类型、图像特点和应用需求选择合适的滤波算法。它的基本思想是在滤波过程中同时考虑像素点的空间距离和灰度差异,从而在去除噪声的同时尽可能地保留图像的边缘和细节。它的基本思想是通过一个引导图像来确定滤波的方向和强度,从而在去除噪声的同时尽可能地保留图像的边缘和细节。均值滤波是一种典型的线性滤波算法,它的基本思想是用像素邻域内的像素值的平均值来代替该像素点的像素值。例如,对于边缘和细节丰富的图像,双边滤波通常是最有效的算法;

m0_44975814的博客 1664

详细介绍pytorch重要的API

Tensor 是 PyTorch 中最基本的数据结构,提供了多种创建和操作张量的函数。Autograd 提供了自动求导功能,可以跟踪 Tensor 上的操作并计算梯度。损失函数用于衡量模型预测值与真实值之间的差异,提供了多种损失函数。是构建神经网络的基础类,提供了定义网络层和前向传播的方法。提供了 GPU 计算的支持,包括设备管理、内存管理等。提供了一些常用的函数式操作,如激活函数、损失函数等。提供了常用的数据集、模型架构和图像转换工具。提供了数据加载和预处理的工具,包括。

hello! 1223

10种滤波算法

10种滤波算法

ryan123455的博客 4686

三维点云孔洞修复(附Python代码和公共点云数据集链接)

(1)物体自身缺失(2)物体自身形状复杂,很多凹凸面不够规则甚至存在空腔,空腔内部无法被三维激光扫描仪扫描到(3)物体部分区域对激光扫描不敏感,未被扫描上(4)扫描仪的扫描稳定性。

yanghl1215的博客 6956

T-Box功能详解及应用

T - BOX,其全称为 Telematics Box,作为远程 / 车载通信模块,是一款集车身网络与无线通讯功能于一体的智能终端设备。它充当了多媒体车机与 TSP(汽车远程服务提供商)以及互联网之间的无线路由器角色,为用户创造了远程访问的可能。用户借助T - BOX能够对车辆配备的各个 ECU(电子控制单元)进行远程操控,包括远程启动或停止发动机开启或关闭空调天窗后备箱门车门,以及实现闪灯鸣笛等功能。

wgl110110的博客 5657

常用的滤波算法与经验分享

在一些设备中,我们需要对一些高频信号进行滤波,例如AD值读取。滤波分为软件滤波与硬件滤波,在实际开发中,硬件滤波往往不够,所以,我们需要掌握一些滤波算法。 本文分享:1,常用的软件滤波算法,2,开发中的经验。 软件滤波算法 1,中位值滤波法 原理:连续采样N次(N为奇数),对N次采样值进行大小排序,去中间值为本次采样值。 优点:能有效克服因偶然因素引起的波动干扰; 缺点:对温度、液位的变化缓慢的被测参数有良好的滤波效果。 2,平均值滤波法(去除MAX,MIN) 原理:连续采...

嵌入式与人工智能 4874

逆向工程视角:MFI芯片通信协议在Linux环境下的行为分析

本文从逆向工程角度深入分析了MFI芯片在Linux环境下的通信协议行为,重点探讨了树莓派与MFI芯片通过I2C接口交互的技术细节。文章详细介绍了信号捕获、协议栈逆向、动态调试技巧以及安全机制分析,为开发者提供了在Linux驱动层面实现MFI认证的实用方法。

time3的博客 179

滤波算法对比

滤波(Wave filtering)是将信号中特定波段频率滤除的操作,是抑制和防止干扰的一项重要措施。滤波算法的目的是从原始有干扰的测量数据中提取出有用信号,或者对信号进行某种特定的处理以改善其质量。

m0_58683132的博客 1885

利用Langchain生成合成数据的实践指南

合成数据是相对于从真实世界事件中收集的数据而言的人工生成的数据。它用于模拟真实数据,同时避免隐私泄露或遇到真实数据中的局限性。:尽管合成数据有诸多优点,但应谨慎使用,因为它可能无法捕捉真实世界的复杂性。

eahba的博客 399

一键生成Microsoft Store应用直链下载:绕过商店故障的终极方案

遇到商店无法加载时,复制链接 → 粘贴到Adguard → 下载主程序包 → 开启开发者模式安装。整个过程耗时不超过2分钟,彻底摆脱商店依赖!

安德洛夫 2198

图像滤波算法系列实战总结之一

简述:   图像滤波是为了去除图像中存在的噪声,提升图像的有效信息清晰度。一般情况下,噪声在傅里叶变换频谱中处于图像中的高频段,所以衍生出一系列低通滤波算法,(Lower Pass Filter, LPF)算法在滤除噪声的同时也会一定程度的对边缘高频信息削弱。通常,滤波算法主要通过与图形进行卷积运算来进行图像滤波。早期滤波算法主要有:均值滤波、中值滤波、高斯滤波、双边滤波算法等。在介绍各个滤波算法...

AutoXTruck专栏 2527

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

滤波算法,看这个就够了

本文着重将滤波模板改为可直接复制使用的模板,您不再需要任何的操作,只需要传入数据参数就能得到想要的数据

亿只萌新的博客 4885

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

单片机的滤波算法

关于滤波,我们常常听说有滤波电路、滤波器、滤波对抗器等等,这些都是有效的解决单片机的信号干扰问题,都是从硬件上进行滤波处理,从而增加检测值的精确度。下面我们来简单介绍一下软件是如何进行单片机滤波的,这就要引出我们今天的主题--滤波算法。 滤波算法是什么呢?既然是算法,那就要运用到数学公式了,即通过算法将我们检测到误差大的数据进行处理,从而达到滤波作用。下面通过例子来讲述几种常用的滤波算...

masebati的博客 2499

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

单片机上使用的几种滤波算法

实用单片机采集数据时,往往需要对一些采集的数据进行计算,常用的计算方式比如求平均值、加权平均算法等;本次也记录几个学习过的算法。

mochen_32的博客 2590

【滤波算法】几种自适应滤波算法

自适应滤波算法主要包括最小均方(Least Mean Squares, LMS)算法、归一化最小均方(Normalized Least Mean Squares, NLMS)算法和递推最小二乘(Recursive Least Squares, RLS)算法等。下面是这些算法在MATLAB中的基本实现。

G_redsky的博客 2801
上一篇: 手机产品上的传感器的工厂测试
下一篇: 一些代码检查工具的信息
YasinLeeX
博客等级 码龄19年 380粉丝 310原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YasinLeeX

再来一杯西湖龙井。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值