非常好的滤波程序（卡尔曼滤波）

hemengde

////////////////////Kalman滤波
static float gyro,acceler,Vref=2.048,fangdabeishu=24.6;
static float acc,gg,acce;

static float angle, angle_dot;                
static const float Q_angle = 0.001, Q_gyro = 0.003, R_angle = 0.5, dt = 0.006;
static float PP[2][2] = {{1,0},{0,1}};
static float Pdot[4]  = {0,0,0,0};
static const char C_0 = 1;
static float q_bias, angle_err, PCt_0, PCt_1, E, K_0, K_1, t_0, t_1;
static float gyro,acceler;

void Kalman_Filter(float angle_m,float gyro_m)               
{
          angle += (gyro_m-q_bias)*dt;

          Pdot[0] = Q_angle-PP[0][1]-PP[1][0];
          Pdot[1] = -PP[1][1];
          Pdot[2] = -PP[1][1];
          Pdot[3] = Q_gyro;

          PP[0][0] += Pdot[0]*dt;
          PP[0][1] += Pdot[1]*dt;
          PP[1][0] += Pdot[2]*dt;
          PP[1][1] += Pdot[3]*dt;

          angle_err = angle_m-angle;

          PCt_0 = C_0*PP[0][0];
          PCt_1 = C_0*PP[1][0];

          E=R_angle+C_0*PCt_0;

          K_0 = PCt_0/E;
          K_1 = PCt_1/E;

          t_0 = PCt_0;
          t_1 = C_0*PP[0][1];

          PP[0][0] -= K_0*t_0;
          PP[0][1] -= K_0*t_1;
          PP[1][0] -= K_1*t_0;
          PP[1][1] -= K_1*t_1;

          angle += K_0*angle_err;
          q_bias += K_1*angle_err;
          angle_dot = (gyro_m-q_bias);
}

automaticdai

能否简单介绍一下使用方法？

扎希德

mark一下

snail_dongbin

非常难看懂的滤波程序！

hemengde

我发现是有点乱，发的时候没弄好，非常抱歉，你们可以去百度一下卡尔曼滤波 哪里讲的不错

高鼻子

顶了，谢谢分享

Garbage614

上个图才有说服力

hemengde

   最佳线性滤波理论起源于40年代美国科学家Wiener和前苏联科学家Ｋолмогоров等人的研究工作，后人统称为维纳滤波理论。从理论上说，维纳滤波的最大缺点是必须用到无限过去的数据，不适用于实时处理。为了克服这一缺点，60年代Kalman把状态空间模型引入滤波理论，并导出了一套递推估计算法，后人称之为卡尔曼滤波理论。卡尔曼滤波是以最小均方误差为估计的最佳准则，来寻求一套递推估计的算法，其基本思想是：采用信号与噪声的状态空间模型，利用前一时刻地估计值和现时刻的观测值来更新对状态变量的估计，求出现时刻的估计值。它适合于实时处理和计算机运算。



现设线性时变系统的离散状态防城和观测方程为：



X(k) = F(k,k-1)·X(k-1)+T(k,k-1)·U(k-1)



Y(k) = H(k)·X(k)+N(k)



其中



X(k)和Y(k)分别是k时刻的状态矢量和观测矢量



F(k,k-1)为状态转移矩阵



U(k)为k时刻动态噪声



T(k,k-1)为系统控制矩阵



H(k)为k时刻观测矩阵



N(k)为k时刻观测噪声



则卡尔曼滤波的算法流程为：





1.预估计X(k)^= F(k,k-1)·X(k-1)

2.计算预估计协方差矩阵
C(k)^=F(k,k-1)×C(k)×F(k,k-1)'+T(k,k-1)×Q(k)×T(k,k-1)'
Q(k) = U(k)×U(k)'

3.计算卡尔曼增益矩阵
K(k) = C(k)^×H(k)'×[H(k)×C(k)^×H(k)'+R(k)]^(-1)
R(k) = N(k)×N(k)'

4.更新估计
X(k)~=X(k)^+K(k)×[Y(k)-H(k)×X(k)^]

5.计算更新后估计协防差矩阵
C(k)~ = [I-K(k)×H(k)]×C(k)^×[I-K(k)×H(k)]'+K(k)×R(k)×K(k)'

6.X(k+1) = X(k)~
C(k+1) = C(k)~
重复以上步骤
其c语言实现代码如下：


#include "stdlib.h"
  #include "rinv.c"
  int lman(n,m,k,f,q,r,h,y,x,p,g)
  int n,m,k;
  double f[],q[],r[],h[],y[],x[],p[],g[];
  { int i,j,kk,ii,l,jj,js;
    double *e,*a,*b;
    e=malloc(m*m*sizeof(double));
    l=m;
    if (l<n) l=n;
    a=malloc(l*l*sizeof(double));
    b=malloc(l*l*sizeof(double));
    for (i=0; i<=n-1; i++)
      for (j=0; j<=n-1; j++)
        { ii=i*l+j; a[ii]=0.0;
          for (kk=0; kk<=n-1; kk++)
            a[ii]=a[ii]+p[i*n+kk]*f[j*n+kk];
        }
    for (i=0; i<=n-1; i++)
      for (j=0; j<=n-1; j++)
        { ii=i*n+j; p[ii]=q[ii];
          for (kk=0; kk<=n-1; kk++)
            p[ii]=p[ii]+f[i*n+kk]*a[kk*l+j];
        }
    for (ii=2; ii<=k; ii++)
      { for (i=0; i<=n-1; i++)
        for (j=0; j<=m-1; j++)
          { jj=i*l+j; a[jj]=0.0;
            for (kk=0; kk<=n-1; kk++)
              a[jj]=a[jj]+p[i*n+kk]*h[j*n+kk];
          }
        for (i=0; i<=m-1; i++)
        for (j=0; j<=m-1; j++)
          { jj=i*m+j; e[jj]=r[jj];
            for (kk=0; kk<=n-1; kk++)
              e[jj]=e[jj]+h[i*n+kk]*a[kk*l+j];
          }
        js=rinv(e,m);
        if (js==0)
          { free(e); free(a); free(b); return(js);}
        for (i=0; i<=n-1; i++)
        for (j=0; j<=m-1; j++)
          { jj=i*m+j; g[jj]=0.0;
            for (kk=0; kk<=m-1; kk++)
              g[jj]=g[jj]+a[i*l+kk]*e[j*m+kk];
          }
        for (i=0; i<=n-1; i++)
          { jj=(ii-1)*n+i; x[jj]=0.0;
            for (j=0; j<=n-1; j++)
              x[jj]=x[jj]+f[i*n+j]*x[(ii-2)*n+j];
          }
        for (i=0; i<=m-1; i++)
          { jj=i*l; b[jj]=y[(ii-1)*m+i];
            for (j=0; j<=n-1; j++)
              b[jj]=b[jj]-h[i*n+j]*x[(ii-1)*n+j];
          }
        for (i=0; i<=n-1; i++)
          { jj=(ii-1)*n+i;
            for (j=0; j<=m-1; j++)
              x[jj]=x[jj]+g[i*m+j]*b[j*l];
          }
        if (ii<k)
          { for (i=0; i<=n-1; i++)
            for (j=0; j<=n-1; j++)
              { jj=i*l+j; a[jj]=0.0;
                for (kk=0; kk<=m-1; kk++)
                  a[jj]=a[jj]-g[i*m+kk]*h[kk*n+j];
                if (i==j) a[jj]=1.0+a[jj];
              }
            for (i=0; i<=n-1; i++)
            for (j=0; j<=n-1; j++)
              { jj=i*l+j; b[jj]=0.0;
                for (kk=0; kk<=n-1; kk++)
                  b[jj]=b[jj]+a[i*l+kk]*p[kk*n+j];
              }
            for (i=0; i<=n-1; i++)
            for (j=0; j<=n-1; j++)
              { jj=i*l+j; a[jj]=0.0;
                for (kk=0; kk<=n-1; kk++)
                  a[jj]=a[jj]+b[i*l+kk]*f[j*n+kk];
              }
            for (i=0; i<=n-1; i++)
            for (j=0; j<=n-1; j++)
              { jj=i*n+j; p[jj]=q[jj];
                for (kk=0; kk<=n-1; kk++)
                  p[jj]=p[jj]+f[i*n+kk]*a[j*l+kk];
              }
          }
      }
    free(e); free(a); free(b);
    return(js);
  }

C++实现代码如下：

============================kalman.h================================

// kalman.h: interface for the kalman class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C0__INCLUDED_)
#define AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C0__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <math.h>
#include "cv.h"



class kalman  
{
public:
void init_kalman(int x,int xv,int y,int yv);
CvKalman* cvkalman;
CvMat* state;
CvMat* process_noise;
CvMat* measurement;
const CvMat* prediction;
CvPoint2D32f get_predict(float x, float y);
kalman(int x=0,int xv=0,int y=0,int yv=0);
//virtual ~kalman();


};

#endif // !defined(AFX_KALMAN_H__ED3D740F_01D2_4616_8B74_8BF57636F2C0__INCLUDED_)


============================kalman.cpp================================

#include "kalman.h"
#include <stdio.h>


/* tester de printer toutes les valeurs des vecteurs*/
/* tester de changer les matrices du noises */
/* replace state by cvkalman->state_post ??? */


CvRandState rng;
const double T = 0.1;
kalman::kalman(int x,int xv,int y,int yv)
{     
    cvkalman = cvCreateKalman( 4, 4, 0 );
    state = cvCreateMat( 4, 1, CV_32FC1 );
    process_noise = cvCreateMat( 4, 1, CV_32FC1 );
    measurement = cvCreateMat( 4, 1, CV_32FC1 );
    int code = -1;
   
    /* create matrix data */
     const float A[] = {
   1, T, 0, 0,
   0, 1, 0, 0,
   0, 0, 1, T,
   0, 0, 0, 1
  };
     
     const float H[] = {
    1, 0, 0, 0,
    0, 0, 0, 0,
   0, 0, 1, 0,
   0, 0, 0, 0
  };
      
     const float P[] = {
    pow(320,2), pow(320,2)/T, 0, 0,
   pow(320,2)/T, pow(320,2)/pow(T,2), 0, 0,
   0, 0, pow(240,2), pow(240,2)/T,
   0, 0, pow(240,2)/T, pow(240,2)/pow(T,2)
    };

     const float Q[] = {
   pow(T,3)/3, pow(T,2)/2, 0, 0,
   pow(T,2)/2, T, 0, 0,
   0, 0, pow(T,3)/3, pow(T,2)/2,
   0, 0, pow(T,2)/2, T
   };
   
     const float R[] = {
   1, 0, 0, 0,
   0, 0, 0, 0,
   0, 0, 1, 0,
   0, 0, 0, 0
   };
   
   
    cvRandInit( &rng, 0, 1, -1, CV_RAND_UNI );

    cvZero( measurement );
   
    cvRandSetRange( &rng, 0, 0.1, 0 );
    rng.disttype = CV_RAND_NORMAL;

    cvRand( &rng, state );

    memcpy( cvkalman->transition_matrix->data.fl, A, sizeof(A));
    memcpy( cvkalman->measurement_matrix->data.fl, H, sizeof(H));
    memcpy( cvkalman->process_noise_cov->data.fl, Q, sizeof(Q));
    memcpy( cvkalman->error_cov_post->data.fl, P, sizeof(P));
    memcpy( cvkalman->measurement_noise_cov->data.fl, R, sizeof(R));
    //cvSetIdentity( cvkalman->process_noise_cov, cvRealScalar(1e-5) );   
    //cvSetIdentity( cvkalman->error_cov_post, cvRealScalar(1));
//cvSetIdentity( cvkalman->measurement_noise_cov, cvRealScalar(1e-1) );

    /* choose initial state */

    state->data.fl[0]=x;
    state->data.fl[1]=xv;
    state->data.fl[2]=y;
    state->data.fl[3]=yv;
    cvkalman->state_post->data.fl[0]=x;
    cvkalman->state_post->data.fl[1]=xv;
    cvkalman->state_post->data.fl[2]=y;
    cvkalman->state_post->data.fl[3]=yv;

cvRandSetRange( &rng, 0, sqrt(cvkalman->process_noise_cov->data.fl[0]), 0 );
    cvRand( &rng, process_noise );


    }

     
CvPoint2D32f kalman::get_predict(float x, float y){
   

    /* update state with current position */
    state->data.fl[0]=x;
    state->data.fl[2]=y;

   
    /* predict point position */
    /* x'k=A鈥k+B鈥k
       P'k=A鈥k-1*AT + Q */
    cvRandSetRange( &rng, 0, sqrt(cvkalman->measurement_noise_cov->data.fl[0]), 0 );
    cvRand( &rng, measurement );
   
     /* xk=A?xk-1+B?uk+wk */
    cvMatMulAdd( cvkalman->transition_matrix, state, process_noise, cvkalman->state_post );
   
    /* zk=H?xk+vk */
    cvMatMulAdd( cvkalman->measurement_matrix, cvkalman->state_post, measurement, measurement );
   
    /* adjust Kalman filter state */
    /* Kk=P'k鈥T鈥?H鈥'k鈥T+R)-1
       xk=x'k+Kk鈥?zk-H鈥'k)
       Pk=(I-Kk鈥)鈥'k */
    cvKalmanCorrect( cvkalman, measurement );
    float measured_value_x = measurement->data.fl[0];
    float measured_value_y = measurement->data.fl[2];

   
const CvMat* prediction = cvKalmanPredict( cvkalman, 0 );
    float predict_value_x = prediction->data.fl[0];
    float predict_value_y = prediction->data.fl[2];

    return(cvPoint2D32f(predict_value_x,predict_value_y));
}

void kalman::init_kalman(int x,int xv,int y,int yv)
{
state->data.fl[0]=x;
    state->data.fl[1]=xv;
    state->data.fl[2]=y;
    state->data.fl[3]=yv;
    cvkalman->state_post->data.fl[0]=x;
    cvkalman->state_post->data.fl[1]=xv;
    cvkalman->state_post->data.fl[2]=y;
    cvkalman->state_post->data.fl[3]=yv;
}

hemengde

有乱码  不影响阅读的 打包好的 想看的慢慢看  

number007cool

kan bu dong  ,a

luchen66

真强啊，学习了

tonyzhh

谢谢分享

彼岸花开

今年做二轮平衡车的时候用来卡尔曼，正是此程序。好像是外国人写的

shiyanshi118

mark

sz_works

留个记号

bgod1986414

太棒了 謝謝

sunshulin

hengzecheng

顶                                 

shiyongxie1987

看不懂，有点介绍就好

wqhzhy5858

做个记号先，有时间仔细研究下，感谢楼主的分享

黄瓜

mark

2k_man

马克下

yanse1214

先记着。这个高级，以后慢慢消化

EysTech

MARK                       

iop

算法还是最难的

小小怪

实验过，回应速度慢....

偏执的Y调小孩

水平有限只能先收藏以后学习了

wangle315065

先mark         

J8688

必须mark

gotofly100

谢谢无私贡献，mark

笑傲江湖

看不大懂！            

济南电子爱好者

A practical approach to Kalman filter and how to implement it   这是一篇英文方面介绍这个算法的文章.

xl1736

搜藏下，不过请问这个程序和论坛里Zlstone大大程序里用的滤波函数是一样的么？

lrbdh

xl1736 发表于 2013-11-17 10:55
搜藏下，不过请问这个程序和论坛里Zlstone大大程序里用的滤波函数是一样的么？ ...

原理一样的吧，只是zlstone是浓缩版的好像。

残忆视觉

MARK有用

jiespring

马克，学习

lisgo

先mark存下来

just-tone

高深东西，收藏下便于以后用到时再看

ping624

先mark存下来,好难懂

xuxiang10

不错啊。。。

duanyz

晦涩难懂啊，不过先mark。留有日后在用

successliufei

谢谢 分享。。。

tangwq

谢谢楼主。

hanbing333444

楼主加点中文注释就完美了

lans0625

技术含量很高的原码，谢谢楼主分享。

jorry

mark！！

xxzzhy

还是没有特么理解

b_snow

先MARK一下。

bolizhicheng204

多谢楼主

luybpotter

MARK！不过水平有限只能先收藏以后学习了

qq451982051

标记    收藏 以后要用

sjh306

多谢楼主分享！mark一下

redchina

高端的算法，马克

lufcn

谢谢楼主！留痕学习