精华内容
下载资源
问答
  • 2020-05-15 00:55:52

    高阶低通滤波算法

    介绍

    我以前的文章中,我谈到了各种数据库标识符策略,在设计数据库模型时需要注意。 我们得出的结论是,数据库序列非常方便,因为它们在大多数用例中既灵活又高效。

    但是,即使具有缓存的序列 ,应用程序也需要为每个新的序列值进行数据库往返。 如果您的应用程序要求每个事务执行大量插入操作,则可以使用hi / lo算法优化序列分配。

    高/低算法

    高/低算法将序列域分为“高”组。 同步分配一个“ hi”值。 每个“ hi”组都有最大数量的“ lo”条目,可以通过离线分配它们,而不必担心并发重复的条目。

    1. “ hi”令牌是由数据库分配的,并且保证两个并发调用可以看到唯一的连续值
    2. 一旦检索到“ hi”令牌,我们只需要“ incrementSize”(“ lo”条目的数量)
    3. 标识符范围由以下公式给出:
    4. 胶乳

      而“ lo”值将取自:

      乳胶1

      从...开始:

      乳胶2

    5. 使用所有“ lo”值时,将获取新的“ hi”值,并且循环继续

    在这里,您可以有两个并发事务的示例,每个事务都插入多个实体:

    hi_lo_algorithm

    测试理论

    如果我们具有以下实体:

    @Entity
    public class Hilo {
    
        @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "hilo_sequence_generator")
        @GenericGenerator(
                name = "hilo_sequence_generator",
                strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator",
                parameters = {
                        @Parameter(name = "sequence_name", value = "hilo_seqeunce"),
                        @Parameter(name = "initial_value", value = "1"),
                        @Parameter(name = "increment_size", value = "3"),
                        @Parameter(name = "optimizer", value = "hilo")
                })
        @Id
        private Long id;
    }

    我们可以检查在插入多个实体时发出了多少次数据库序列往返:

    @Test
    public void testHiloIdentifierGenerator() {
    	doInTransaction(new TransactionCallable<Void>() {
    		@Override
    		public Void execute(Session session) {
    			for(int i = 0; i < 8; i++) {
    				Hilo hilo = new Hilo();
    				session.persist(hilo);
    				session.flush();
    			}
    			return null;
    		}
    	});
    }

    哪些最终生成以下SQL查询:

    Query:{[call next value for hilo_seqeunce][]} 
    Query:{[insert into Hilo (id) values (?)][1]} 
    Query:{[insert into Hilo (id) values (?)][2]} 
    Query:{[insert into Hilo (id) values (?)][3]} 
    Query:{[call next value for hilo_seqeunce][]} 
    Query:{[insert into Hilo (id) values (?)][4]} 
    Query:{[insert into Hilo (id) values (?)][5]} 
    Query:{[insert into Hilo (id) values (?)][6]} 
    Query:{[call next value for hilo_seqeunce][]} 
    Query:{[insert into Hilo (id) values (?)][7]} 
    Query:{[insert into Hilo (id) values (?)][8]}

    如您所见,对于8个插入的实体,我们只有3个序列调用。 实体插入的事务越多,我们需要的越少,从减少数据库序列往返次数中获得的性能就会越好。

    翻译自: https://www.javacodegeeks.com/2014/06/the-hilo-algorithm.html

    高阶低通滤波算法

    更多相关内容
  • 一阶低通滤波算法

    2017-11-26 20:53:37
    关于一阶低通滤波算法研究,想找LPF滤波资料有没有的同学请看这里
  • 一阶RC低通滤波算法原理与实现

    千次阅读 多人点赞 2020-08-09 12:46:14
    一阶滤波,又叫一阶惯性滤波,或一阶低通滤波,软件实现RC低通滤波器的功能。 - 滤波系数越小,滤波结果越平稳,灵敏度越低 - 滤波系数越大,灵敏度越高,但滤波结果越不稳定 一阶滤波无法完美地兼顾灵敏度和平稳...

    本文整理自网络,参考文献附在文末,侵权请联系!


    1. 一阶低通滤波算法原理

    一阶滤波,又叫一阶惯性滤波,或一阶低通滤波,软件实现RC低通滤波器的功能。

    Y ( n ) = α X ( n ) + ( 1 − α ) Y ( n − 1 ) Y(n)=αX(n) + (1-α)Y(n-1) Y(n)=αX(n)+(1α)Y(n1)

    式中: α α α为滤波系数, X ( n ) X(n) X(n)为本次采样值, Y ( n − 1 ) Y(n-1) Y(n1)为上次滤波输出值, Y ( n ) Y(n) Y(n)为本次滤波输出值
    在这里插入图片描述
    传递函数推导可参考该博文:传送门
    在这里插入图片描述

    2. 一阶滤波算法的特点

    • 对于周期干扰有良好的抑制作用(优)

    • 带来了相位滞后,导致灵敏度低(缺)

    • 不能滤除频率高于采样频率的二分之一(称为奈奎斯特频率)的干扰(例如采样频率为100Hz,则它不能滤除50Hz以上的干扰信号)(缺)

    • 滤波系数越小,滤波结果越平稳,灵敏度越低

    • 滤波系数越大,灵敏度越高,但滤波结果越不稳定

    一阶滤波无法完美地兼顾灵敏度和平稳度。有时,我们只能寻找一个平衡,在可接受的灵敏度范围内取得尽可能好的平稳度。而在一些场合,我们希望拥有这样一种接近理想状态的滤波算法。即:当数据快速变化时,滤波结果能及时跟进(灵敏度优先);当数据趋于稳定,在一个固定的点上下振荡时,滤波结果能趋于平稳(平稳度优先)。

    3. 基本算法的例程

    案例1:油门数据滤波

    // 油门滤波
    thr_lpf+=(1/(1+1/(2.0f*3.14f*T)))*(height_thr-thr_lpf)
    

    案例2:

    #define a   0.01                // 滤波系数a(0-1) 
    
    static float oldOutData = 0;
    
    char filter(void)
    {
        nowData  = get_Data(); 
        nowOutData = a * nowData  + (1.0f - a) * oldOutData;
        oldOutData = nowOutData;
        return nowOutData;  
    }
    
    
    /*
    程序中整数运算比小数运算快,为加快程序的处理速度,
    为计算方便,a取一整数,1-a用256-a来代替,
    a则取0~255,代表新采样值在滤波结果中的权重
    (也可将1-a的基数改为100-a,计算结果做相应处理,这里不做说明)
    */
    
    #define a 128 
    
    char value; //上次滤波值
    char filter()
    {
        char new_value;
        new_value=get_ad();//本次采样值
        return(256-a)*value/256+a*new_value/256}
    

    案例3:MATLAB测试

    % 一阶低通滤波器测试
    close all;
    t = 0.003;
    A = 1/(1+(1/(2*pi*t)));
    tt = 0:t:25;
    y = sin(0.5*tt);
    y_noise = awgn(y,35);
    y_proce = y_noise;
    for i = 2:length(y)
        y_proce(i) = (1-A) * y_proce(i-1) + A * y_noise(i);
    end
    
    plot(tt,y,'r');
    figure(2)
    plot(tt,y_noise,'g');hold on;
    plot(tt,y_proce,'b');
    hold off;
    

    4. 优化:减少乘、除的运算次数以提高运算速度

    思路:先将新采样值与上次滤波结果进行比较,然后根据比较采用不同的公式计算,这样程序的运算效率提高了一倍

    在这里插入图片描述
    在这里插入图片描述

    /*入口:NEW_DATA 新采样值
           OLD_DATA 上次滤波结果
           k        滤波系数(0~255)(代表在滤波结果中的权重)
      出口:         本次滤波结果
     */
     char filter_1(char NEW_DATA,char OLD_DATA,char k)
    {
        int result;
        if(NEW_DATA<OLD_DATA)
        {
            result=OLD_DATA-NEW_DATA;
            result=result*k;
            result=result+128;//+128是为了四色五入
            result=result/256;
            result=OLD_DATA-result;
        }
        else if(NEW_DATA>OLD_DATA)
        {
            result=NEW_DATA-OLD_DATA;
            result=result*k;
            result=result+128;//+128是为了四色五入
            result=result/256;
            result=OLD_DATA-result;
        }
        else result=OLD_DATA;
        return((char)result);
    }
    

    分析:

    • 仍然存在灵敏度与平温度之间的矛盾
    • 小数舍弃带来的误差(单片机很少采用浮点数,小数位要么舍弃要么四舍五入)

    5. 改进:动态调整滤波系数

    实现功能:

    • 当数据快速变化时,滤波结果能及时跟进,并且数据的变化越快,灵敏度应该越高(灵敏度优先原则)
    • 当数据趋于稳定,并在一个范围内振荡时,滤波结果能趋于平稳(平稳度优先原则)
    • 当数据稳定后,滤波结果能逼近并最终等于采样数据(消除因计算中小数带来的误差)
      调整前判断:
    • 数据变化方向是否为同一个方向(如当连续两次的采样值都比其上次滤波结果大时,视为变化方向一致,否则视为不一致)
    • 数据变化是否较快(主要是判断采样值和上一次滤波结果之间的差值)
      调整原则:
    • 当两次数据变化不一致时,说明有抖动,将滤波系数清零,忽略本次新采样值
    • 当数据持续向一个方向变化时,逐渐提高滤波系数,提供本次采样值得权;
    • 当数据变化较快(差值>消抖计数加速反应阈值)时,要加速提高滤波系数

    在这里插入图片描述
    几个常量参数及其取值范围(不同的取值会影响滤波的灵敏度和稳定度):

    1. 消抖计数加速反应阈值,取值根据数据情况确定
    2. 消抖计数最大值,一般取值10;
    3. 滤波系数增量,一般取值范围为10~30
    4. 滤波系数最大值,一般取值255;

    在这里插入图片描述

    在调用一阶滤波程序前,先调用调整滤波系数程序,对系数进行即时调整。滤波效果:

    1. 当采样数据偶然受到干扰,滤波结果中的干扰完全被滤除
    2. 当数据在一个范围内振荡时,滤波结果曲线非常平滑,几乎是一根直线
    3. 当采样数据发生真实的变化时,滤波结果也能比较及时地跟进
    4. 当采样数据趋于稳定时,滤波结果逐渐逼近并最终等于采样数据
    • 最终改进算法,兼顾了灵敏度和平稳度的要求;同时又不太消耗系统的RAM;
    • 只要合理调整几个常量,以使得算法更合适实际应用;

    动态调整滤波例程

    //用MPU6050测得数据;对x轴滤波处理
    
    #define Threshold_1     8       //阈值1用于一阶带参滤波器,变化角度大于此值时,计数增加
    #define Threshold_2     30      //阈值2用于一阶带参滤波器,计数值大于此值时,增大参数,增强滤波跟随
    
    float K_x=0; //滤波系数
    u8 new_flag_x=0;//本次数据变化方向
    u8 num_x=0;//滤波计数器
    
    
    /*****带系数修改的一阶滤波函数
    
    入口: NEW_DATA    新采样的角度值
          OLD_DATA    上次滤波获得的角度结果
          k           滤波系数(代表在滤波结果中的权重)
          flag        上次数据变化方向
    出口: result      本次滤波角度结果
     */
    float filter_1_x(float NEW_DATA,float OLD_DATA,float k,u8 flag)
    {
    
    
        //角度变化方向,new_flag=1表示角度增加,=0表示角度正在减小
        if((NEW_DATA-OLD_DATA)>0)
            new_flag_x=1;
        else if((NEW_DATA-OLD_DATA)<0)
            new_flag_x=0;
    
    
        if(new_flag_x==flag)  //此次变化与前一次变化方向是否一致,相等表示角度变化方向一致
            {
                num_x++;
                if(fabs((NEW_DATA-OLD_DATA))>Threshold_1)
            //当变化角度大于Threshold_1度的时候,进行计数器num快速增加,以达到快速增大K值,提高跟随性
                    num_x+=5;                           
    
                if(num_x>Threshold_2)   //计数阈值设置,当角度递增或递减速度达到一定速率时,增大K值
                {
                    K_x=k+0.2;          //0.2为K_x的增长值,看实际需要修改
                    num_x=0;
                }
            }
        else 
            {
                num_x=0;
                K_x=0.01;     //角度变化稳定时K_x值,看实际修改
            }
    
        OLD_DATA=(1-K_x)*OLD_DATA+K_x*NEW_DATA;
        return OLD_DATA;
    }
    
    

    参考文献:

    展开全文
  • [算法]飞控中的低通滤波算法

    千次阅读 2018-04-03 20:16:01
    [算法]飞控中的低通滤波算法 在匿名飞控的源码的时候经常看见类似下面的算法 thr_lpf+=(1 / (1 + 1/(2.0f * 3.14f * T )))*(height_thr - thr_lpf) 看这个变量名这应该是对油门进行低通滤波 整理一下上式...

    [算法]飞控中的一阶RC低通滤波算法


    在阅读飞控的源码时,我们经常看见类似下面的算法

    thr_lpf+=(1 / (1 + 1/(2.0f * 3.14f * T )))*(height_thr - thr_lpf)

    通过变量名thr_lpf可以知道这是对油门进行低通滤波后的值,可是为什么这个算法可以实现低通滤波呢?它的截止频率是多少呢?我们来一步一步揭开算法背后的秘密。

    首先整理一下上式可以得到:


    令:

    可以得到:

    所以程序其实对应的就是这个迭代过程。

    电路中的滤波

    为了解什么低通滤波,通过搜索发现低通滤波得到的是这样的电路图:

    这个算法和电路里的滤波电路有什么关系吗?接下来我们先对滤波电路进行分析。

    时域分析

    设回路电流为 Ic I c ,由基尔霍夫定律可以写出回路方程为:

    解微分方程可以得到

    其中RC是时间常数,当电阻单位是”欧姆( Ω Ω )”,电容单位是”法拉(F)”时,时间常数的单位是”秒(s)”。

    频域分析

    既然是滤波器,我们最想知道的就是它的截至频率,那么就需要从频域分析。
    以电容电压作为输出,电路的网络函数[^电网络函数]为:

    可得电压的传递函数为:


    增益


    wc w c 为截止角频率


    fc f c 截止频率

    离散化

    先从S域到Z域,再将Z反变换求得差分方程
    z变换(方法很多,如一阶前向差分、双线性变换等这里用一阶后向差分法)
    一阶后向差分法中

    其中T是采样周期,带入S域传递函数中



    z反变换求差分方程后可得:




    可得

    到这里式子已经跟程序里的非常像了,现在就差系数的问题了

    为什么


    因为

    所以


    带入


    可得

    滤波器电路经过离散化分析后得到的就是源程序的迭代过程,两者有着相同的数学描述,硬件电路可以实现低通滤波的效果,那么这个程序同样可以,并且通过计算我们可以得到原程序是截止频率fc=1Hz,那么用MATLAB来测试一下滤波器的性能吧。

    %基波:幅值为31Hz正弦波
    Signal_Original_1 = 3*sin(2*pi*t); 
    %噪声函数 赋值为基波的1/3 10hz 30hz 50hz 100hz 200hz 300hz 400hz 500hz正弦波 
    Noise_White_1  = sin(2*pi*10*t)+sin(2*pi*30*t)+sin(2*pi*50*t)+sin(2*pi*100*t)+sin(2*pi*200*t)+sin(2*pi*300*t)+sin(2*pi*400*t)+sin(2*pi*500*t);    
    %构造的混合信号
    Mix_Signal   = Signal_Original + Noise_White;

    我们用MATLAB自带的有源一阶RC低通滤波器(一阶巴特沃斯低通滤波器)来进行对比

    设计滤波器

    一阶RC滤波器设计

    根据:


    设计截止频率 fC f C =1Hz的一阶RC滤波器:

    其中输入混合信号Mix_Signal,经过滤波得到结果LPF_RC

    Fs = 10000;  %采样频率 10KHz
    fc = 1;      %截止频率 1Hz                       
    for a = 1:1:length(t)
        %T采样周期等于1/采样频率
        lpf1=lpf0+(1 / (1 + 1/(2.0 * 3.14*(1/Fs)*fc)))*(Mix_Signal(a) - lpf0);
        lpf0=lpf1;
        LPF_RC(a)=lpf1;
    end  

    巴特沃斯滤波器设计

    输入混合信号Mix_Signal,经过滤波得到结果Butter_Filter

    %截止频率 fc
    Wc=2*fc/Fs;  
    %返回具有归一化截止频率Wn的lv阶低通数字巴特沃斯滤波器的传递函数系数。                                           
    [b,a]=butter(lv,Wc,'low');
    Butter_Filter=filter(b,a,Mix_Signal);

    快速傅里叶变换

    将波形进行快速傅里叶变换,可以分析波形里包含的正弦波频率和幅值。

    可以看到傅里叶变换后的结果,经过滤波后50hz以后的波基本上都滤干净了,就是10Hz和30HZ还有一点,效果还是非常好的。

    幅频特性曲线

    幅频特性曲线可以量化滤波器的对不同频率谐波的抑制效果。

    标准的RC滤波器传递函数为:

    取其分子系数b=[1],分母系数a=[RC 1]

    b=[1];
    a=[RC 1];
    [mag,phase,w]=bode(b,a);
    dB=20*log10(mag);
    semilogx(w/(2*pi),dB(:),'r'); 

    一阶RC滤波器采用了一阶后向差分法,整理得到:

    根据MATLAB官方给出的离散形式定义传递函数的分子和分母系数,
    https://www.mathworks.com/help/matlab/ref/filter.html?searchHighlight=filter&s_tid=doc_srchtitle

    得到b=[T 0],a=[RC+T -RC];

    b=[T 0];
    a=[RC+T -RC];
    [h,w]=freqz(b,a);
    set(gca,'XScale','log')
    plot((w*Fs/(2*pi)),20*log10(abs(h)),'g')

    巴特沃斯滤波是使用双线性变换的RC标准滤波,MATLAB提供了自带的butter函数计算分子和分母系数。

    [b,a]=butter(lv,Wc,'low');
    [h,w]=freqz(b,a);
    plot((w*Fs/(2*pi)),20*log10(abs(h)),'b'); grid;

    将三个方法的RC滤波幅频特性曲线画在一起,可以看出不管是一阶向后差分的一阶RC滤波,还是双线性变换的巴特沃斯滤波,在100Hz之前的曲线几乎是完全重合的,理论性能和实际性能是一致的。

    在回到最初的算法

    thr_lpf+=(1 / (1 + 1/(2.0f * 3.14f * T )))*(height_thr - thr_lpf)

    你能想到一个这么短的算法里蕴含了这么多数学原理吗?

    参考资料
    http://www.360doc.com/content/15/0714/22/22888854_484947052.shtml
    https://wenku.baidu.com/view/85f8dc20dd36a32d7375814d.html
    https://wenku.baidu.com/view/3efd1b0e51e79b8969022627.html

    [网络函数] 动态电路激励作用下下,响应(输出)相量与激励(输入)相量之比,称为网络函数(network functions),记为H。
    [z变换] Z变换(英文:z-transformation)可将时域信号(即:离散时间序列)变换为在复频域的表达式。它在离散时间信号处理中的地位,如同拉普拉斯变换在连续时间信号处理中的地位。

    关注我的微信公众号,回复【rc】即可获取本文的参考文献和MATLAB源码,同时欢迎加我的个人微信交流。

    展开全文
  • 2 低通滤波 2.1 算法推导 一阶RC滤波器的硬件电路如图: 图中输入电压是Vi,电阻R,电容C,输出电压为Vo。 假设电路的输出阻抗很大(即不带任何负载),输入阻抗很小(理想情况)。可以得到以下公式: Vo=11+j...

    1 卡尔曼滤波

    详见博客 https://blog.csdn.net/moge19/article/details/81750731

    2 低通滤波

    2.1 算法推导

    一阶RC滤波器的硬件电路如图:
    在这里插入图片描述
    图中输入电压是Vi,电阻R,电容C,输出电压为Vo。

    假设电路的输出阻抗很大(即不带任何负载),输入阻抗很小(理想情况)。可以得到以下公式:

    V o = 1 1 + j ω R C V i V_o = \frac{1}{1+j\omega RC}V_i Vo=1+jωRC1Vi

    电容的阻抗是 Z C = 1 j ω C Z_C = \frac{1}{j\omega C} ZC=jωC1

    ω = 2 π f \omega = 2\pi f ω=2πf

    截止频率 f c u t = 1 2 π R C f_{cut} = \frac{1}{2\pi RC} fcut=2πRC1,此频率下的信号,通过这个电路,输出电压和输入电压的关系式是 V o = 1 1 + j V i V_o = \frac{1}{1+j}V_i Vo=1+j1Vi

    或者时域上的表达式:

    V o = V i − R C d V o d t V_o = V_i - RC\frac{dV_o}{dt} Vo=ViRCdtdVo

    上式离散后,可以得到:

    V o ( k ) = V i ( k ) + R C T s V o ( k − 1 ) 1 + R C T s V_o\left ( k \right )=\frac{V_i\left ( k \right )+\frac{RC}{T_s}V_o\left ( k-1 \right )}{1+\frac{RC}{T_s}} Vo(k)=1+TsRCVi(k)+TsRCVo(k1)

    2.2 算法实现

    class RC_filter:
        def __init__(self,sampleFrq,CutFrq):
            self.sampleFrq = sampleFrq
            self.CutFrq = CutFrq
            self.adc_old=0
         
        def LowPassFilter_RC_1order(self,Vi):
            RC = 1.0/2.0/math.pi/self.CutFrq 
            Cof1 = 1/(1+RC * self.sampleFrq)
            Cof2 = RC* self.sampleFrq/(1+RC* self.sampleFrq)
            Vo = Cof1 * Vi + Cof2 * self.adc_old	 	
            self.adc_old = Vo
            return Vo  
    

    3 滑动平均滤波

    算法实现:

     noise_array =  np.random.normal(0, 400, noise_size)
        
        test_array_mean = [0]*32
        mean_array = []
        for i in range(noise_size):
            test_array_mean[i%32] = noise_array[i]
            mean_array.append(sum(test_array_mean)/32)
                
    

    4 FFT转换比较

    源数据频谱图:
    在这里插入图片描述卡尔曼滤波后的频谱
    在这里插入图片描述RC滤波后的频谱
    在这里插入图片描述从图中可以看出一阶的卡尔曼滤波与RC低通滤波的滤波效果一样
    滑动平均滤波后的频谱图:
    在这里插入图片描述从图中可以看出,滑动平均滤波,在低频段较之卡尔曼滤波和低通滤波,其频谱得到的幅值是其余二者的数十倍,这是由于求均值时,将部分噪声数据也计算到信号数据中导致的,因此可以看出,滑动平均滤波不能有效得将噪声数据滤掉,不过在工程因为计算简单,浮点运算少,甚至没有,所以得到广泛运用。

    5 实现代码

    # -*- coding: utf-8 -*-
    """
    Created on Fri Feb 15 20:35:39 2019
    
    @author: ASUS
    """
    
    import numpy as np
    import matplotlib.pyplot as plt
    import math
    from scipy.fftpack import fft,ifft
    class kalman_filter:
        def __init__(self,Q,R):
            self.Q = Q
            self.R = R
            
            self.P_k_k1 = 1
            self.Kg = 0
            self.P_k1_k1 = 1
            self.x_k_k1 = 0
            self.ADC_OLD_Value = 0
            self.Z_k = 0
            self.kalman_adc_old=0
            
        def kalman(self,ADC_Value):
           
            self.Z_k = ADC_Value
            
            #if (abs(self.kalman_adc_old-ADC_Value)>=60):
                #self.x_k1_k1= ADC_Value*0.382 + self.kalman_adc_old*0.618
            #else:
            self.x_k1_k1 = self.kalman_adc_old;
        
            self.x_k_k1 = self.x_k1_k1
            self.P_k_k1 = self.P_k1_k1 + self.Q
        
            self.Kg = self.P_k_k1/(self.P_k_k1 + self.R)
        
            kalman_adc = self.x_k_k1 + self.Kg * (self.Z_k - self.kalman_adc_old)
            self.P_k1_k1 = (1 - self.Kg)*self.P_k_k1
            self.P_k_k1 = self.P_k1_k1
        
            self.kalman_adc_old = kalman_adc
            
            return kalman_adc
    
    class RC_filter:
        def __init__(self,sampleFrq,CutFrq):
            self.sampleFrq = sampleFrq
            self.CutFrq = CutFrq
            self.adc_old=0
           
            
        def LowPassFilter_RC_1order(self,Vi):
            RC = 1.0/2.0/math.pi/self.CutFrq 
            Cof1 = 1/(1+RC * self.sampleFrq)
            Cof2 = RC* self.sampleFrq/(1+RC* self.sampleFrq)
            Vo = Cof1 * Vi + Cof2 * self.adc_old	 	
            self.adc_old = Vo
            return Vo  
    
      
    if __name__ == '__main__':
        noise_size = 1024
        noise_size_half = 512
        kalman_filter =  kalman_filter(0.01,0.5)
        RC_filter = RC_filter(400,5)
        noise_array =  np.random.normal(0, 2, noise_size)
        
            
        adc_value=[]
        
        for i in range(noise_size):
            adc_value.append(0)
    
        adc_value_noise = np.array(adc_value) + noise_array
        adc_filter_1=[]
        
        for i in range(noise_size):
            adc_filter_1.append(kalman_filter.kalman(adc_value_noise[i]))
        plt.plot(adc_value_noise,'r')
        plt.plot(adc_filter_1,'b')   
    
        #plt.plot(test_array)
        plt.show()
        adc_filter_2=[]
        plt.figure(1)
        for i in range(noise_size):
            adc_filter_2.append(RC_filter.LowPassFilter_RC_1order(adc_value_noise[i]))
        
        plt.plot(adc_value_noise,'r-')   
        plt.plot(adc_filter_2,'b')
        #plt.plot(test_array)
        plt.show()
        plt.figure(2)
        
      
        x = range(noise_size)
        y = noise_array
        #x=np.linspace(0,1,1400)      
        #设置需要采样的信号,频率分量有180,390和600
        #y=7*np.sin(2*np.pi*180*x) + 2.8*np.sin(2*np.pi*390*x)+5.1*np.sin(2*np.pi*600*x)
        
        yy=fft(x) #快速傅里叶变换 
        yreal = yy.real # 获取实数部分 
        yimag = yy.imag # 获取虚数部分 
        yf=abs(fft(y)) # 取绝对值 
        yf1=abs(fft(y))/len(x) #归一化处理 
        yf2 = yf1[range(int(len(x)/2))] #由于对称性,只取一半区间 
        xf = np.arange(len(y)) # 频率 
        xf1 = xf
        xf2 = xf[range(int(len(x)/2))] #取一半区间 
        """plt.subplot(221) 
        plt.plot(x[0:noise_size_half],y[0:noise_size_half]) 
        plt.title('Original wave') 
        plt.subplot(222) 
        plt.plot(xf,yf,'r')
        plt.title('FFT of Mixed wave(two sides frequency range)',fontsize=7,color='#7A378B') #注意这里的颜色可以查询颜色代码表 
                  
        plt.subplot(223) 
        plt.plot(xf1,yf1,'g')
        plt.title('FFT of Mixed wave(normalization)',fontsize=9,color='r') """
        #plt.subplot(224) 
        plt.plot(xf2,yf2,'b') 
        plt.title('FFT of kalman_filter)',fontsize=10,color='#F08080') 
        plt.show()
        
        x = range(noise_size)
        y = adc_filter_2
        #x=np.linspace(0,1,1400)      
        #设置需要采样的信号,频率分量有180,390和600
        #y=7*np.sin(2*np.pi*180*x) + 2.8*np.sin(2*np.pi*390*x)+5.1*np.sin(2*np.pi*600*x)
        
        yy    = fft(x) #快速傅里叶变换 
        yreal = yy.real # 获取实数部分 
        yimag = yy.imag # 获取虚数部分 
        yf =abs(fft(y)) # 取绝对值 
        yf1=abs(fft(y))/len(x) #归一化处理 
        yf2= yf1[range(int(len(x)/2))] #由于对称性,只取一半区间 
        xf  = np.arange(len(y)) # 频率 
        xf1 = xf
        xf2 = xf[range(int(len(x)/2))] #取一半区间 
        """plt.subplot(221) 
        plt.plot(x[0:noise_size_half],y[0:noise_size_half]) 
        plt.title('Original wave') 
        plt.subplot(222) 
        plt.plot(xf,yf,'r')
        plt.title('FFT of Mixed wave(two sides frequency range)',fontsize=7,color='#7A378B') #注意这里的颜色可以查询颜色代码表 
                  
        plt.subplot(223) 
        plt.plot(xf1,yf1,'g')
        plt.title('FFT of Mixed wave(normalization)',fontsize=9,color='r') """
        #plt.subplot(224) 
        plt.plot(xf2,yf2,'b') 
        plt.title('FFT of RC)',fontsize=10,color='#F08080') 
        plt.show()
    
    
    
    
    
    展开全文
  • 更新参数的一阶低通滤波算法 C++-附件资源
  • FIR低通滤波

    2019-03-05 15:14:05
    采用C语言方式实现了FIR低通滤波,并用matlab对其进行仿真,经比较结果一致
  • 用Matlab分享一个软件低通滤波算法

    千次阅读 2019-09-01 16:24:30
    前言:前一阵子学习了matlab的一些数据处理的基本操作,但是都没怎么用,很多操作忘记了,昨天晚上看到一个滤波算法思想感觉还不错,现在打算用Matlab来仿真看看具体效果怎样 正文: 代码如下:初次写Matlab的代码...
  • 这是一个非常经典的巴特沃斯滤波器代码,就我所知,目前使用频域分析和滤波主要是用MATLAB来完成,从百度上查询或是csdn中还未有用R语言设计巴特沃斯滤波器的详细样例,本例用大量的解释和调试工作明确了r语言...
  • 一阶低通滤波算法(Yn=a*Xn+(1-a)*Y(n-1))对周期性干扰具有良好的抑制作用,适用于波动频繁的参数滤波,其不足之处是带来了相位滞后,灵敏度低。滞后的程度取决于a值的大小。同时,它不能滤除频率高于采样频率1/2...
  • 算法学习笔记之一阶低通滤波算法

    万次阅读 多人点赞 2016-09-27 11:29:13
    一阶滤波,又叫一阶惯性滤波,或一阶低通滤波。是使用软件编程实现普通硬件RC低通滤波器的功能。 一阶低通滤波算法公式为: Y(n)=αX(n) (1-α)Y(n-1) 式中:α=滤波系数;X(n)=本次采样值;Y(n-1)=上次滤波输出...
  • 高通&低通滤波算法

    千次阅读 2017-04-06 09:59:07
    低通Algorithmic implementation The filter recurrence relation provides a way to determine the output samples in terms of the input samples and the preceding output. The following  pseudocode ...
  • 六阶巴特沃斯低通滤波算法,截止频率35Hz
  • 一阶低通滤波

    千次阅读 多人点赞 2019-09-24 16:16:45
    从硬件电路和软件算法上都能一定程度的减少噪声达到滤波的目的,本文主要讲解软件使用低通滤波算法来滤波ADC采样值的方法。 一阶低通滤波(又叫惯性滤波)算法 算法原理   滤波算法公式: Y(n) = a * X(n) + ...
  • 低通滤波

    千次阅读 2021-04-27 12:54:31
    低通滤波 1.硬件低通滤波 2.软件低通滤波
  • 参考模电RC滤波计算公式来计算截止频率 #define M_PI_FLOAT 3.14159265358979323846f typedef struct LpfFilter { float RC;//模电RC滤波的电阻和电容值的积 float dT;//数据更新时间隔(秒) float k;//...
  • 各种简单滤波算法,可以对数据进行优化处理
  • 1 理想低通滤波 %理想低通 I = imread('fig.png'); I=rgb2gray(I); figure(1); subplot(221),imshow(I); title('原图像'); I=imnoise(I,'gaussian');%%加入高斯白噪声 subplot(222),imshow(I); title('加入噪声后的...
  • 三轴加速计中一阶低通滤波算法

    千次阅读 2016-09-13 15:24:52
    文章出处:http://www.docin.com/p-745334438.html
  • 现代电子工业的趋势是集成更多的功能到尽可能小巧的外形中,这已经不是什么秘密。移动电话就是这样的实例。当今许多生产商将MP3播放器、数码相机甚至卫星电视功能集成在移动电话里。过去几年,该市场已经取得了巨大...
  • 通过代码来分析如何对图像进行高斯滤波 先放镇楼图: 1. 读取图像,转灰度图像 I = imread('lena.bmp'); %读取原图像 I = rgb2gray(I); %原图像转灰度图像 i_size = 512; %原图像大小 fillsize = 1024; %填充后...
  • 加速度传感器低通滤波实现数字滤波处理
  • 【简单滤波算法】常见的滤波算法讲解及例程

    千次阅读 多人点赞 2021-10-19 12:01:30
    限幅滤波法算法:优点:缺点代码:中位值滤波法算法:优点:缺点:代码:算术平均值滤波算法:优点:缺点:代码:滑动算术平均值滤波算法:优点:缺点:中位值平均滤波法算法:优点:缺点:代码一阶低通滤波方法:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,971
精华内容 6,788
关键字:

低通滤波算法