ROS中EKF（扩展卡尔曼跟踪）的使用

最新推荐文章于 2024-05-22 12:00:41 发布
最新推荐文章于 2024-05-22 12:00:41 发布
阅读量2.3k 收藏 7
点赞数
分类专栏： ROS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/random_repick/article/details/104020187
版权

0.简版（更新于2020年最后一天）

#include <bfl/wrappers/matrix/matrix_wrapper.h>
#include <bfl/filter/extendedkalmanfilter.h>
#include <bfl/model/linearanalyticsystemmodel_gaussianuncertainty.h>
#include <bfl/model/linearanalyticmeasurementmodel_gaussianuncertainty.h>
#include <bfl/pdf/linearanalyticconditionalgaussian.h>
#include <fstream>
#include <iostream>

using namespace std;
using namespace BFL;
using namespace MatrixWrapper;

class MYEKF
{
public:
    BFL::Gaussian prior_;
    BFL::ExtendedKalmanFilter *filter_;
    BFL::LinearAnalyticConditionalGaussian *sys_pdf_;
    BFL::LinearAnalyticSystemModelGaussianUncertainty *sys_model_;
    BFL::LinearAnalyticConditionalGaussian *meas_pdf_;
    BFL::LinearAnalyticMeasurementModelGaussianUncertainty *meas_model_;
    MatrixWrapper::Matrix sys_matrix_;
    MatrixWrapper::SymmetricMatrix sys_sigma_;
    float time_;

    MYEKF() : filter_(NULL),
              sys_pdf_(NULL),
              sys_model_(NULL),
              meas_pdf_(NULL),
              meas_model_(NULL),
              sys_matrix_(6, 6) {}

    void Init(float x, float y, float t)
    {
        sys_matrix_ = 0;
        for (unsigned int i = 1; i <= 3; i++)
        {
            sys_matrix_(i, i) = 1;
            sys_matrix_(i + 3, i + 3) = 0.9;
        }
        // 噪声的u和sigma，sys_noise即Q
        ColumnVector sys_mu(6);
        sys_mu = 0;
        sys_sigma_ = SymmetricMatrix(6);
        sys_sigma_ = 0;
        for (unsigned int i = 0; i < 3; i++)
        {
            sys_sigma_(i + 1, i + 1) = pow(0.05, 2);
            sys_sigma_(i + 4, i + 4) = pow(1.0, 2);
        }
        Gaussian sys_noise(sys_mu, sys_sigma_);
        //
        sys_pdf_ = new LinearAnalyticConditionalGaussian(sys_matrix_, sys_noise);
        sys_model_ = new LinearAnalyticSystemModelGaussianUncertainty(sys_pdf_);

        // =============================create meas model
        // meas_matrix即H
        Matrix meas_matrix(3, 6);
        meas_matrix = 0;
        for (unsigned int i = 1; i <= 3; i++)
            meas_matrix(i, i) = 1;
        // 噪声的u和sigma，meas_noise即R
        ColumnVector meas_mu(3);
        meas_mu = 0;
        SymmetricMatrix meas_sigma(3);
        meas_sigma = 0;
        for (unsigned int i = 0; i < 3; i++)
            meas_sigma(i + 1, i + 1) = 0;
        Gaussian meas_noise(meas_mu, meas_sigma);
        //
        meas_pdf_ = new LinearAnalyticConditionalGaussian(meas_matrix, meas_noise);
        meas_model_ = new LinearAnalyticMeasurementModelGaussianUncertainty(meas_pdf_);
        // first point
        ColumnVector mu_vec(6);
        SymmetricMatrix sigma_vec(6);
        sigma_vec = 0;
        mu_vec(1) = x;
        mu_vec(2) = y;
        mu_vec(3) = 0;
        for (unsigned int i = 0; i < 3; i++)
        {
            // mu_vec(i + 1) = pos[i];
            mu_vec(i + 4) = 0.0;
            sigma_vec(i + 1, i + 1) = pow(0.1, 2);
            sigma_vec(i + 4, i + 4) = pow(0.0000001, 2);
        }
        prior_ = Gaussian(mu_vec, sigma_vec);
        filter_ = new ExtendedKalmanFilter(&prior_);
        time_ = t;
    }
    bool Predict(float t)
    {
        // set F
        for (unsigned int i = 1; i <= 3; i++)
            sys_matrix_(i, i + 3) = t - time_;
        sys_pdf_->MatrixSet(0, sys_matrix_);

        // scale system noise for dt
        sys_pdf_->AdditiveNoiseSigmaSet(sys_sigma_ * pow(t - time_, 2));
        time_ = t;
        // update filter
        return filter_->Update(sys_model_);
    }
    bool Update(float x, float y)
    {
        ColumnVector meas_vec(3);
        // for (unsigned int i = 0; i < 3; i++)
        //     meas_vec(i + 1) = p[i];
        meas_vec(1) = x;
        meas_vec(2) = y;
        meas_vec(3) = 0;
        SymmetricMatrix cov(3);
        cov = 0.0;
        cov(1, 1) = 0.0025;
        cov(2, 2) = 0.0025;
        cov(3, 3) = 0.0025;
        ((LinearAnalyticConditionalGaussian *)(meas_model_->MeasurementPdfGet()))->AdditiveNoiseSigmaSet(cov);
        
        // update filter
        return filter_->Update(meas_model_, meas_vec);
    }
    void getEstimate(float &x, float &y)
    {
        ColumnVector tmp = filter_->PostGet()->ExpectedValueGet();
        x = tmp(1);
        y = tmp(2);
    }
};

int main()
{
    ifstream data("/home/lwd/data/track.txt");
    MYEKF *ekf = new MYEKF();
    float mt, mx, my;
    for (int i = 0; i < 74; ++i)
    {
        if (i == 0)
        {
            data >> mt >> mx >> my;
            ekf->Init(mx, my, mt);
            continue;
        }
        data >> mt >> mx >> my;
        ekf->Predict(mt);
        float tx, ty;
        ekf->getEstimate(tx, ty);
        cout << i + 1 << "\t" << tx - mx << "\t" << ty - my << endl;
        ekf->Update(mx, my);
    }
    return 0;
}
  • CMakeLists
cmake_minimum_required(VERSION 2.8.3)
project(ekf)

add_compile_options(-std=c++11)

find_package(catkin REQUIRED COMPONENTS
  roscpp
)

find_package(PkgConfig REQUIRED)
pkg_check_modules(BFL REQUIRED orocos-bfl)
include_directories(${BFL_INCLUDE_DIRS})
link_directories(${BFL_LIBRARY_DIRS})
message(${BFL_INCLUDE_DIRS})
message(${BFL_LIBRARY_DIRS})

catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES ekf
#  CATKIN_DEPENDS roscpp
#  DEPENDS system_lib
)

include_directories(
  include
  ${catkin_INCLUDE_DIRS}
)

add_executable(${PROJECT_NAME} src/ekf.cpp)
target_link_libraries(${PROJECT_NAME}
    ${catkin_LIBRARIES}
    ${BFL_LIBRARIES}
)

1.代码

  • 位置，速度类：state_pos_vel.h
#ifndef STATE_POS_VEL_H
#define STATE_POS_VEL_H

#include <tf/tf.h>

namespace BFL
{
/// Class representing state with pos and vel
class StatePosVel
{
public:
  tf::Vector3 pos_, vel_;
  /// Constructor
  StatePosVel(const tf::Vector3& pos = tf::Vector3(0, 0, 0),
              const tf::Vector3& vel = tf::Vector3(0, 0, 0)):  pos_(pos), vel_(vel) {};
  /// Destructor
  ~StatePosVel() {};
  /// operator +=
  StatePosVel& operator += (const StatePosVel& s)
  {
    this->pos_ += s.pos_;
    this->vel_ += s.vel_;
    return *this;
  }
  /// operator +
  StatePosVel operator + (const StatePosVel& s)
  {
    StatePosVel res;
    res.pos_ = this->pos_ + s.pos_;
    res.vel_ = this->vel_ + s.vel_;
    return res;
  }
  /// output stream for StatePosVel
  friend std::ostream& operator<< (std::ostream& os, const StatePosVel& s)
  {
    os << "(" << s.pos_[0] << ", " << s.pos_[1] << ", "  << s.pos_[2] << ")--("
       << "(" << s.vel_[0] << ", " << s.vel_[1] << ", "  << s.vel_[2] << ") ";
    return os;
  };
};
} // end namespace
#endif
  • 跟踪基类：tracker.h
#ifndef __TRACKER__
#define __TRACKER__

#include "state_pos_vel.h"
#include <bfl/wrappers/matrix/matrix_wrapper.h>
#include <string>


namespace estimation
{
class Tracker
{
public:
  /// constructor
  Tracker(const std::string& name): name_(name) {};
  /// destructor
  virtual ~Tracker() {};
  /// return the name of the tracker
  const std::string& getName() const
  {
    return name_;
  };
  /// initialize tracker
  virtual void initialize(const BFL::StatePosVel& mu, const BFL::StatePosVel& sigma, const double time) = 0;
  /// return if tracker was initialized
  virtual bool isInitialized() const = 0;
  /// return measure for tracker quality: 0=bad 1=good
  virtual double getQuality() const = 0;
  /// return the lifetime of the tracker
  virtual double getLifetime() const = 0;
  /// return the time of the tracker
  virtual double getTime() const = 0;
  /// update tracker
  virtual bool updatePrediction(const double time) = 0;
  virtual bool updateCorrection(const tf::Vector3& meas,
                                const MatrixWrapper::SymmetricMatrix& cov) = 0;
  /// get filter posterior
  virtual void getEstimate(BFL::StatePosVel& est) const = 0;
private:
  std::string name_;
}; // class
}; // namespace

#endif
  • 卡尔曼跟踪类：tracker_kalman.h
#ifndef __TRACKER_KALMAN__
#define __TRACKER_KALMAN__

#include "tracker.h"
// bayesian filtering
#include <bfl/filter/extendedkalmanfilter.h>
#include <bfl/model/linearanalyticsystemmodel_gaussianuncertainty.h>
#include <bfl/model/linearanalyticmeasurementmodel_gaussianuncertainty.h>
#include <bfl/pdf/linearanalyticconditionalgaussian.h>
#include "state_pos_vel.h"
// TF
#include <tf/tf.h>
// log files
#include <fstream>

namespace estimation
{
class TrackerKalman: public Tracker
{
public:
  /// constructor
  TrackerKalman(const std::string& name, const BFL::StatePosVel& sysnoise);
  /// destructor
  virtual ~TrackerKalman();
  /// initialize tracker
  virtual void initialize(const BFL::StatePosVel& mu, const BFL::StatePosVel& sigma, const double time);
  /// return if tracker was initialized
  virtual bool isInitialized() const
  {
    return tracker_initialized_;
  };
  /// return measure for tracker quality: 0=bad 1=good
  virtual double getQuality() const
  {
    return quality_;
  };
  /// return the lifetime of the tracker
  virtual double getLifetime() const;
  /// return the time of the tracker
  virtual double getTime() const;
  /// update tracker
  virtual bool updatePrediction(const double time);
  virtual bool updateCorrection(const tf::Vector3& meas,
                                const MatrixWrapper::SymmetricMatrix& cov);
  /// get filter posterior
  virtual void getEstimate(BFL::StatePosVel& est) const;
private:
  // pdf / model / filter
  BFL::Gaussian                                           prior_;
  BFL::ExtendedKalmanFilter*                              filter_;
  BFL::LinearAnalyticConditionalGaussian*                 sys_pdf_;
  BFL::LinearAnalyticSystemModelGaussianUncertainty*      sys_model_;
  BFL::LinearAnalyticConditionalGaussian*                 meas_pdf_;
  BFL::LinearAnalyticMeasurementModelGaussianUncertainty* meas_model_;
  MatrixWrapper::Matrix                                   sys_matrix_;
  MatrixWrapper::SymmetricMatrix                          sys_sigma_;
  double calculateQuality();
  // vars
  bool tracker_initialized_;
  double init_time_, filter_time_, quality_;
}; // class
}; // namespace
#endif

tracker_kalman.cpp

#include "tracker_kalman.h"
#include <iostream>

using namespace MatrixWrapper;
using namespace BFL;
using namespace tf;
using namespace std;
using namespace ros;


const static double damping_velocity = 0.9;


namespace estimation
{
// constructor
TrackerKalman::TrackerKalman(const string& name, const StatePosVel& sysnoise):
  Tracker(name),
  filter_(NULL),
  sys_pdf_(NULL),
  sys_model_(NULL),
  meas_pdf_(NULL),
  meas_model_(NULL),
  sys_matrix_(6, 6),
  tracker_initialized_(false)
{
  // create sys model
  sys_matrix_ = 0; // F
  for (unsigned int i = 1; i <= 3; i++)
  {
    sys_matrix_(i, i) = 1;
    sys_matrix_(i + 3, i + 3) = damping_velocity;
  }
  // Q
  ColumnVector sys_mu(6);
  sys_mu = 0;
  sys_sigma_ = SymmetricMatrix(6);
  sys_sigma_ = 0;
  for (unsigned int i = 0; i < 3; i++)
  {
    sys_sigma_(i + 1, i + 1) = pow(sysnoise.pos_[i], 2);
    sys_sigma_(i + 4, i + 4) = pow(sysnoise.vel_[i], 2);
  }
  Gaussian sys_noise(sys_mu, sys_sigma_);
  sys_pdf_   = new LinearAnalyticConditionalGaussian(sys_matrix_, sys_noise);
  sys_model_ = new LinearAnalyticSystemModelGaussianUncertainty(sys_pdf_);

  // create meas model
  // H
  Matrix meas_matrix(3, 6);
  meas_matrix = 0;
  for (unsigned int i = 1; i <= 3; i++)
    meas_matrix(i, i) = 1;
  // R
  ColumnVector meas_mu(3);
  meas_mu = 0;
  SymmetricMatrix meas_sigma(3);
  meas_sigma = 0;
  for (unsigned int i = 0; i < 3; i++)
    meas_sigma(i + 1, i + 1) = 0;
  Gaussian meas_noise(meas_mu, meas_sigma);
  meas_pdf_   = new LinearAnalyticConditionalGaussian(meas_matrix, meas_noise);
  meas_model_ = new LinearAnalyticMeasurementModelGaussianUncertainty(meas_pdf_);
};

// destructor
TrackerKalman::~TrackerKalman()
{
  if (filter_)      delete filter_;
  if (sys_pdf_)     delete sys_pdf_;
  if (sys_model_)   delete sys_model_;
  if (meas_pdf_)    delete meas_pdf_;
  if (meas_model_)  delete meas_model_;
};

// initialize prior density of filter
void TrackerKalman::initialize(const StatePosVel& mu, const StatePosVel& sigma, const double time)
{
  ColumnVector mu_vec(6);
  SymmetricMatrix sigma_vec(6);
  sigma_vec = 0;
  for (unsigned int i = 0; i < 3; i++)
  {
    mu_vec(i + 1) = mu.pos_[i];
    mu_vec(i + 4) = mu.vel_[i];
    sigma_vec(i + 1, i + 1) = pow(sigma.pos_[i], 2);
    sigma_vec(i + 4, i + 4) = pow(sigma.vel_[i], 2);
  }
  prior_ = Gaussian(mu_vec, sigma_vec);
  filter_ = new ExtendedKalmanFilter(&prior_);

  // tracker initialized
  tracker_initialized_ = true;
  quality_ = 1;
  filter_time_ = time;
  init_time_ = time;
}

// update filter prediction
bool TrackerKalman::updatePrediction(const double time)
{
  bool res = true;
  if (time > filter_time_)
  {
    // set dt in sys model
    for (unsigned int i = 1; i <= 3; i++)
      sys_matrix_(i, i + 3) = time - filter_time_;
    sys_pdf_->MatrixSet(0, sys_matrix_);

    // scale system noise for dt
    sys_pdf_->AdditiveNoiseSigmaSet(sys_sigma_ * pow(time - filter_time_, 2));
    filter_time_ = time;

    // update filter
    res = filter_->Update(sys_model_);
    if (!res) quality_ = 0;
    else quality_ = calculateQuality();
  }
  return res;
};

// update filter correction
bool TrackerKalman::updateCorrection(const tf::Vector3&  meas, const MatrixWrapper::SymmetricMatrix& cov)
{
  assert(cov.columns() == 3);

  // copy measurement
  ColumnVector meas_vec(3);
  for (unsigned int i = 0; i < 3; i++)
    meas_vec(i + 1) = meas[i];

  // set covariance
  ((LinearAnalyticConditionalGaussian*)(meas_model_->MeasurementPdfGet()))->AdditiveNoiseSigmaSet(cov);

  // update filter
  bool res = filter_->Update(meas_model_, meas_vec);
  if (!res) quality_ = 0;
  else quality_ = calculateQuality();

  return res;
};

void TrackerKalman::getEstimate(StatePosVel& est) const
{
  ColumnVector tmp = filter_->PostGet()->ExpectedValueGet();
  for (unsigned int i = 0; i < 3; i++)
  {
    est.pos_[i] = tmp(i + 1);
    est.vel_[i] = tmp(i + 4);
  }
};

double TrackerKalman::calculateQuality()
{
  double sigma_max = 0;
  SymmetricMatrix cov = filter_->PostGet()->CovarianceGet();
  for (unsigned int i = 1; i <= 2; i++)
    sigma_max = max(sigma_max, sqrt(cov(i, i)));

  return 1.0 - min(1.0, sigma_max / 1.5);
}

double TrackerKalman::getLifetime() const
{
  if (tracker_initialized_)
    return filter_time_ - init_time_;
  else
    return 0;
}

double TrackerKalman::getTime() const
{
  if (tracker_initialized_)
    return filter_time_;
  else
    return 0;
}

}; // namespace
  • 主文件：main.cpp
#include <iostream>
#include "tracker_kalman.h"

using namespace MatrixWrapper;
using namespace estimation;
using namespace BFL;
using namespace tf;
using namespace std;

int main() {
  // system noise
  BFL::StatePosVel sys_sigma_(Vector3(0.05, 0.05, 0.05),
                              Vector3(1.0, 1.0, 1.0));
  TrackerKalman filter("tracker_name", sys_sigma_);
  // EKF prior density
  StatePosVel prior_sigma(Vector3(0.1, 0.1, 0.1),
                          Vector3(0.0000001, 0.0000001, 0.0000001));
  StatePosVel mu(Vector3(0, 0, 0), Vector3(0.5, 0.5, 0));
  filter.initialize(mu, prior_sigma, 0);
  SymmetricMatrix cov(3);
  cov = 0.0;
  cov(1, 1) = 0.0025;
  cov(2, 2) = 0.0025;
  cov(3, 3) = 0.0025;
  for (int i = 1; i < 10; ++i) {
    filter.updatePrediction(1 * i);
    filter.updateCorrection(Vector3(0.22*i, 0.09*i, 0), cov);
    StatePosVel est;
    filter.getEstimate(est);
    cout << est << endl;
  }

  return 0;
}

2.当TrackerKalman作为类的成员变量时

#include <iostream>
#include <list>
#include "tracker_kalman.h"

using namespace MatrixWrapper;
using namespace estimation;
using namespace BFL;
using namespace tf;
using namespace std;

class Test {
 public:
  TrackerKalman filter;
  StatePosVel sys_sigma_;
  int test;
  Test(int test)
      : sys_sigma_(Vector3(0.05, 0.05, 0.05), Vector3(1.0, 1.0, 1.0)),
        filter("tracker_name", sys_sigma_) {
    StatePosVel prior_sigma(Vector3(0.1, 0.1, 0.1),
                            Vector3(0.0000001, 0.0000001, 0.0000001));
    StatePosVel mu(Vector3(0, 0, 0), Vector3(0.5, 0.5, 0));
    filter.initialize(mu, prior_sigma, 0);
    this->test = test;
  }
  ~Test() {}
  void Propagate(float time) {
    filter.updatePrediction(time);
  }
  void update(Vector3 meas, SymmetricMatrix cov) {
    filter.updateCorrection(meas, cov);
  }
  void getState(StatePosVel &est) {
    filter.getEstimate(est);
  }
};

int main() {               
  list<Test> l;
  l.push_back(Test(1));
  list<Test>::iterator i = l.begin();
  cout << i->test << endl;
  // i->Propagate(1);
  Test tt(6);
  tt.Propagate(0.6);
  Test *t = new Test(6);
  SymmetricMatrix cov(3);
  cov = 0.0;
  cov(1, 1) = 0.0025;
  cov(2, 2) = 0.0025;
  cov(3, 3) = 0.0025;
  for (int i = 1; i < 10; ++i) {
    t->Propagate(1 * i);
    t->update(Vector3(0.22 * i, 0.09 * i, 0), cov);
    StatePosVel est;
    t->getState(est);
    cout << est << endl;
  }

  return 0;
}
  • main函数中i->Propagate(1);不注释，会有段错误，注释则会在循环之后出现段错误。所以要使用指针，即list<Test*> l;，原因不明。
刀么克瑟拉莫
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ROS下robot_pose_ekf扩展卡尔曼融合包的使用
shenghuaijing3314的博客
10-12 2万+
最近在使用imu进行数据融合，使用的是robot_pose_ekf的融合包，发现网上的教程太不详细，折腾了1个月，终于搞定了。于是乎，想写一个关于ekf包的使用教程。里程计和惯导模块imu的数据融合来得到一个不易丢失的机器人姿态。首先，你得有一个imu，而且得校准好，我使用的是razor 9dof的imu，通过ros包pub一个Imu的data类型。 这是我google的比较有用的一个e
使用扩展卡尔曼滤波（EKF）融合激光雷达和雷达数据（Matlab代码实现）
Ke_Yan_She的博客
07-17 199
然而，这两者的输出是不同的，激光雷达的输出是笛卡尔坐标中物体的位置，而雷达给出物体在极坐标中的位置和速度。使用扩展卡尔曼滤波器是因为它可以融合非线性数据，在这种情况下是来自笛卡尔坐标和极坐标的数据。为了估计非线性测量，引入了雅可比矩阵。[1]杨春玲,倪晋麟,刘国岁,郑全战.转换坐标卡尔曼滤波器的雷达目标跟踪[J].电子学报,1999(03):121-123.博客内容尽量做到思维缜密，逻辑清晰，为了方便读者。部分理论引用网络文献，若有侵权联系博主删除。行百里者，半于九十。
【滤波跟踪】基于扩展卡尔曼滤波（EKF）、无迹卡尔曼滤波（UKF）及改进无迹卡尔曼滤波（MAUKF）算法实现滤波跟踪附matlab代码
最新发布
Matlab_dashi的博客
05-22 262
1. 引言滤波跟踪作为目标跟踪领域的重要组成部分，旨在利用传感器获取的噪声数据对目标状态进行估计，并对目标轨迹进行预测。近年来，随着非线性系统的广泛应用，传统的线性滤波方法已无法满足实际需求，因此非线性滤波方法的研究成为热点。扩展卡尔曼滤波（EKF）和无迹卡尔曼滤波（UKF）是两种常用的非线性滤波方法，它们在目标跟踪领域得到了广泛应用。然而，EKF 算法的精度依赖于系统的线性化，而 UKF 算法在高维状态空间中可能会出现滤波精度下降的问题。
开源飞控OpenPilot的扩展卡尔曼滤波EKF学习笔记（五）
romepop1的专栏
11-18 4189
出差归来，接着说，上回书说到
PX4_ECL_EKF代码分析1
qq_34994476的博客
03-07 2271
写在前面 源码版本：1.6.0rc1 源码位置1：Firmware-1.6.0rc1\src\modules\ekf2_main.cpp 源码位置2：Firmware-1.6.0rc1\src\lib\ecl\EKF\
关于MSF——EKF框架源代码的下载与使用
sinat_37147389的博客
09-17 1011
下载 新建一个工作空间：mkdir /haha/src cd /haha/src catkin_init_workspace cd .. catkin_make cd haha/src/ 下载glog：git clone https://github.com/ethz-asl/glog_catkin.git 下载 catkin_simple：git clone http...
ros ekf融合odom imu ov信息
天才樱木
10-16 8186
1.这里是ros_ekf_pose包的简单介绍: 这个包用于评估机器人的3D位姿，使用了来自不同源的位姿测量信息，它使用带有6D（3D position and 3D orientation）模型信息的扩展卡尔曼滤波器来整合来自轮子里程计，IMU传感器和视觉里程计的数据信息。 基本思路就是用松耦合方式融合不同传感器信息实现位姿估计。   1 如何使用EKF 1.1 配置       E...
ROS下robot_pose_ekf扩展卡尔曼融合包的使用.zip_数值算法/人工智能_matlab_
08-10
ROS下robot_pose_ekf扩展卡尔曼融合包的使用，robot_pose_ekf的融合包
EKF扩展的卡尔曼滤波器源码(C++和python两个版本)+项目说明.zip
01-11
先介绍ROS系统下的robot_pose_ekf 扩展卡尔曼滤波算法包这个包用于评估机器人的 3D 位姿，使用了来自不同源的位姿测量信息，它使用带有 6D（3D position and 3D orientation）模型信息的扩展卡尔曼滤波器来整合来自...
魔改卡尔曼扩展滤波器 robot_pose_ekf，topic名称对上就可以使用，滤波器中不需要改任何代码
08-29
魔改卡尔曼扩展滤波器 robot_pose_ekf，我用的系统环境ros-noetic，其它环境可以自己测一下，应该没问题；里面有readme详细说明，b站视频中有简要说明 https://b23.tv/WWQRJGF
matlab偏差代码-Contact-Aided-Invariant-EKF:接触辅助不变式扩展卡尔曼滤波的示例代码
05-27
该存储库包含接触式不变扩展卡尔曼滤波器的Matlab / Simulink实现示例。 该过滤器是为在Cassie系列两足动物机器人上使用而设计的，但是可以很容易地将其修改为其他系统。 所包括的测量数据集是通过模拟Cassie行走...
robot_localization_localization_雷达定位ekf_环境建图_ROS_ros小车建图_
10-04
在ros环境下，通过单线雷达实现小车室内建图并定位
ekf_slam：EKF-SLAM高级项目的ROS节点
02-04
ekf_slam：EKF-SLAM高级项目的ROS节点
robot_pose_ekf:用于ROS Melodic及更高版本的robot_pose_ekf软件包
05-07
robot_pose_ekf
扩展卡尔曼滤波器：将在凉亭环境中模拟的Turtlebot的位置与已滤波（扩展卡尔曼滤波器）和无场轨迹进行比较
02-04
扩展卡尔曼滤波器 使用Gazabo，Rviz和ROS 设置环境： 对于此项目，使用了以下设置： Ubuntu 16.04 LTS操作系统 罗斯动力学 凉亭7.0.0 Rviz 1.12.17 安装步骤： 将此存储库克隆到您的主目录： $ git clone ...
ROS EKF 机器人位姿估计功能包：robot_pose_ekf 详解
月照银海似蛟龙的博客
06-08 3931
假定机器人上次更新位姿滤波器在t_0时刻， 该node只有在收到每个传感器测量值（时间戳>t_0）之后才会进行下一次的滤波器更新。例如，在odom topic收到一条消息时间戳（t_1 > t_0）, 且在imu_data topic上也收到一条消息（ 其时间戳t_2 > t_1 > t_0）, 滤波器将被更新到所有传感器信息可用的最新时刻，这个时刻是t_1。红色线是robot_pose_ekf的输出, robot_pose_ekf整合了轮式里程计和IMU的信息，给出了红色的结束位置点。
22.IMU和里程计融合
热门推荐
PIBOT导航机器人
06-22 4万+
1.概述 实际使用中会出现轮子打滑和累计误差的情况，这里单单使用编码器得到里程计会出现一定的偏差，虽然激光雷达会纠正，但一个准确的里程对这个系统还是较为重要 2.IMU数据获取 IMU即为 惯性测量单元，一般包含了三个单轴的加速度计和三个单轴的陀螺仪，简单理解通过加速度二次积分就可以得到位移信息、通过角速度积分就可以得到三个角度，实时要比这个复杂许多 2.1 PIBOT IMU ...
matlab toolbox kalman same name,EKF.m · jayvee/robotics-toolbox-matlab - Gitee.com
weixin_33142377的博客
03-18 289
%EKF Extended Kalman Filter for navigation%% Extended Kalman filter for optimal estimation of state from noisy% measurments given a non-linear dynamic model. This class is specific to% the problem of...
搭建ROS小车编写启动功能包
「小白学移动机器人」一个专注分享移动机器人相关知识的公众号！
09-07 1万+
3.6 ROS小车启动功能包编写 3.6.1 前言 本篇内容应该是大家期待已久的内容，从我自身的开发经验和小伙伴的疑问来看，STM32和ROS通信、以及ROS小车启动功能包的编写是搭建ROS小车比较核心且不容易实现的技术点。多数小伙伴都是在这两个问题上，浪费了很多时间。之前的文章已经完美解决STM32和ROS通信问题。本篇文章就是结合之前内容的铺垫解决ROS小车启动功能包的编写问题。适合各种类型的ROS小车、ROS机器人平台的开发者参考。 3.6.2 明确ROS小车完成SLAM和导航的必备条件是什么？ 这里
扩展卡尔曼滤波c++ROS
07-28
在C++和ROS中实现扩展卡尔曼滤波（Extended Kalman Filter，EKF）可以使用以下步骤： 1. 首先，确保你已经安装了ROS和C++的开发环境。 2. 创建一个ROS package，并在`src`文件夹下创建一个新的C++源文件。 3. 在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

刀么克瑟拉莫

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值