TEB teb_local_planner 构建超图过程error cost分析

最新推荐文章于 2024-04-19 11:43:02 发布
最新推荐文章于 2024-04-19 11:43:02 发布
阅读量849 收藏 27
点赞数 12
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010918541/article/details/120289428
版权

G2O 背景

G20 边和顶点的定义
https://blog.csdn.net/weixin_43013761/category_11647404.html
使用G20优化器 优化 路径
https://blog.csdn.net/qq_29598161/article/details/115414732
https://zhuanlan.zhihu.com/p/121628349

buildGraph

TebOptimalPlanner::buildGraph 位于　optimal_planner.cpp 文件内，是整个teb planner 的核心

1. 添加顶点 AddTEBVertices

主要是添加位姿顶点和时间间隔顶点
顶点分姿态顶点和时间顶点
1.1.
姿态顶点 VertexPose 内部需要优化的变量主要有三个 x,y,theta
1.2
时间顶点 TimeDiffVertex 内部需要优化的变量主要有1个 dt

void TebOptimalPlanner::AddTEBVertices()
{
  // add vertices to graph
  ROS_DEBUG_COND(cfg_->optim.optimization_verbose, "Adding TEB vertices ...");
  unsigned int id_counter = 0; // used for vertices ids
  for (int i=0; i<teb_.sizePoses(); ++i)
  {
    //基本状态　x,y,theta
    teb_.PoseVertex(i)->setId(id_counter++);//先赋值 再自行+1
    optimizer_->addVertex(teb_.PoseVertex(i));
    if (teb_.sizeTimeDiffs()!=0 && i<teb_.sizeTimeDiffs())
    {
      //基本状态　dt
      teb_.TimeDiffVertex(i)->setId(id_counter++);//先赋值 再自行+1 id 累积增加
      optimizer_->addVertex(teb_.TimeDiffVertex(i));
    }
  } 
}

2 Edge 的边的定义与Cost误差函数定义

使用到的惩罚函数
double penaltyBoundFromBelow(const double& var, const double& a,const double& epsilon)
函数定义如下
f ( x ) = { 0.0 , if  v a r > = a + e p s i l o n − v a r + ( a + e p s i l o n ) , if  v a r < ( a + e p s i l o n ) f(x) = \begin{cases} 0.0, & \text{if } var >= a+epsilon \\ -var + (a + epsilon), & \text{if } var < (a+epsilon) \\ \end{cases} f(x)={0.0,−var+(a+epsilon),​if var>=a+epsilonif var<(a+epsilon)​

2.1 EdgeObstacle

误差函数计算代码

  void computeError()
  {
    获取顶点姿态
    const VertexPose* bandpt = static_cast<const VertexPose*>(_vertices[0]);

    double dist = robot_model_->calculateDistance(bandpt->pose(), _measurement);

    // Original obstacle cost.
    _error[0] = penaltyBoundFromBelow(dist, cfg_->obstacles.min_obstacle_dist, cfg_->optim.penalty_epsilon);

    if (cfg_->optim.obstacle_cost_exponent != 1.0 && cfg_->obstacles.min_obstacle_dist > 0.0)
    {
      // Optional non-linear cost. 
      _error[0] = cfg_->obstacles.min_obstacle_dist * std::pow(_error[0] / cfg_->obstacles.min_obstacle_dist, cfg_->optim.obstacle_cost_exponent);
    }

    ROS_ASSERT_MSG(std::isfinite(_error[0]), "EdgeObstacle::computeError() _error[0]=%f\n",_error[0]);
  }

如果配置文件 obstacle_cost_exponent == 1.0 那么error为线性函数公式整理如下
e r r o r [ 0 ] = { 0.0 , if  d i s t > = o b s . m i n _ d i s t + o p t i m . p e n a l t y _ e p s i l o n − d i s t + ( o b s . m i n _ d i s t + o p t i m . p e n a l t y _ e p s i l o n ) , else  error[0] = \begin{cases} 0.0, & \text{if } dist >= obs.min\_dist+optim.penalty\_epsilon \\ -dist + (obs.min\_dist+optim.penalty\_epsilon), & \text{else }\\ \end{cases} error[0]={0.0,−dist+(obs.min_dist+optim.penalty_epsilon),​if dist>=obs.min_dist+optim.penalty_epsilonelse ​
如果配置文件 obstacle_cost_exponent != 1.0 那么error[0]继续更新为非线性函数公式整理如下
e r r o r [ 0 ] = o b s . m i n _ d i s t ∗ e r r o r [ 0 ] o b s . m i n _ d i s t c o s t _ e x p o e n t error[0] = obs.min\_dist * \frac{error[0] }{obs.min\_dist}^{cost\_expoent} error[0]=obs.min_dist∗obs.min_disterror[0]​cost_expoent

2.2 EdgeInflatedObstacle

  • EdgeInflatedObstacle 是一个一元边 继承于 public BaseTebUnaryEdge<2, const Obstacle*, VertexPose>
  • 观测类型是const Obstacle*
  • 连接的顶点是VertexPose
  void computeError()
  {
    const VertexPose* bandpt = static_cast<const VertexPose*>(_vertices[0]);
    double dist = robot_model_->calculateDistance(bandpt->pose(), _measurement);
    _error[0] = penaltyBoundFromBelow(dist, cfg_->obstacles.min_obstacle_dist, cfg_->optim.penalty_epsilon);
    if (cfg_->optim.obstacle_cost_exponent != 1.0 && cfg_->obstacles.min_obstacle_dist > 0.0)
    {
      // Optional non-linear cost. 
      _error[0] = cfg_->obstacles.min_obstacle_dist * std::pow(_error[0] / cfg_->obstacles.min_obstacle_dist, cfg_->optim.obstacle_cost_exponent);
    }
    // Additional linear inflation cost
    _error[1] = penaltyBoundFromBelow(dist, cfg_->obstacles.inflation_dist, 0.0);
  }

error[0]的计算和EdgeObstacle 类型一样，额外增加一个error[1]
e r r o r [ 1 ] = { 0.0 , if  d i s t > = o b s . i n f l a t i o n _ d i s t − d i s t + ( o b s . i n f l a t i o n _ d i s t ) , else  error[1] = \begin{cases} 0.0, & \text{if } dist >= obs.inflation\_dist \\ -dist + (obs.inflation\_dist), & \text{else }\\ \end{cases} error[1]={0.0,−dist+(obs.inflation_dist),​if dist>=obs.inflation_distelse ​

2.3 EdgeDynamicObstacle

  • EdgeDynamicObstacle 继承于 BaseTebUnaryEdge<2, const Obstacle*, VertexPose> 是一个一元边
  void computeError()
  {
    const VertexPose* bandpt = static_cast<const VertexPose*>(_vertices[0]);
    double dist = robot_model_->estimateSpatioTemporalDistance(bandpt->pose(), _measurement, t_);
    _error[0] = penaltyBoundFromBelow(dist, cfg_->obstacles.min_obstacle_dist, cfg_->optim.penalty_epsilon);
    _error[1] = penaltyBoundFromBelow(dist, cfg_->obstacles.dynamic_obstacle_inflation_dist, 0.0);
  }
  • 该函数dist主要是预测障碍物在t秒后的位置和姿态顶点的距离
    robot_model_->estimateSpatioTemporalDistance
  • error[0] 计算和EdgeInflatedObstacle EdgeObstacle相同
  • error[1] 主要使用dynamic_obstacle_inflation_dist来判断

2.4 EdgeViaPoint

  • class EdgeViaPoint 继承 BaseTebUnaryEdge<1, const Eigen::Vector2d*, VertexPose> 一元边
  • 误差向量维度1
  • 观测为Eigen::Vector2d*
  void computeError()
  {
    const VertexPose* bandpt = static_cast<const VertexPose*>(_vertices[0]);
    _error[0] = (bandpt->position() - *_measurement).norm();
  }

总结

  • EdgeViaPoint 主要是评判机器人贴合原始路径的error cost 离原始点位越远 则 error cost 越大

2.5 EdgeVelocity

  • EdgeVelocity 继承 public BaseTebMultiEdge<2, double> 三元边
  • 连接了3个顶点 2个姿态顶点 1个时间顶点
  void computeError()
  {
    const VertexPose* conf1 = static_cast<const VertexPose*>(_vertices[0]);
    const VertexPose* conf2 = static_cast<const VertexPose*>(_vertices[1]);
    const VertexTimeDiff* deltaT = static_cast<const VertexTimeDiff*>(_vertices[2]);
    
    const Eigen::Vector2d deltaS = conf2->estimate().position() - conf1->estimate().position();
    
    double dist = deltaS.norm();
    const double angle_diff = g2o::normalize_theta(conf2->theta() - conf1->theta());
    if (cfg_->trajectory.exact_arc_length && angle_diff != 0)
    {
        double radius =  dist/(2*sin(angle_diff/2));
        dist = fabs( angle_diff * radius ); // actual arg length!
    }
    double vel = dist / deltaT->estimate();
    
//     vel *= g2o::sign(deltaS[0]*cos(conf1->theta()) + deltaS[1]*sin(conf1->theta())); // consider direction
    vel *= fast_sigmoid( 100 * (deltaS.x()*cos(conf1->theta()) + deltaS.y()*sin(conf1->theta())) ); // consider direction
    
    const double omega = angle_diff / deltaT->estimate();
  
    _error[0] = penaltyBoundToInterval(vel, -cfg_->robot.max_vel_x_backwards, cfg_->robot.max_vel_x,cfg_->optim.penalty_epsilon);
    _error[1] = penaltyBoundToInterval(omega, cfg_->robot.max_vel_theta,cfg_->optim.penalty_epsilon);
  }

penaltyBoundToInterval 函数如下

inline double penaltyBoundToInterval(const double& var,const double& a, const double& b, const double& epsilon)
{
  if (var < a+epsilon)
  {
    return (-var + (a + epsilon));
  }
  if (var <= b-epsilon)
  {
    return 0.;
  }
  else
  {
    return (var - (b - epsilon));
  }
}

总结

  • EdgeVelocity 主要是控制了路径的最大最小速度进行的error cost评判 使得机器人速度 以及角速度在合理的范围之内

2.6 EdgeAcceleration

  • class EdgeAcceleration 继承 public BaseTebMultiEdge<2, double> 多元边
  void computeError()
  {
    ROS_ASSERT_MSG(cfg_, "You must call setTebConfig on EdgeAcceleration()");
    const VertexPose* pose1 = static_cast<const VertexPose*>(_vertices[0]);
    const VertexPose* pose2 = static_cast<const VertexPose*>(_vertices[1]);
    const VertexPose* pose3 = static_cast<const VertexPose*>(_vertices[2]);
    const VertexTimeDiff* dt1 = static_cast<const VertexTimeDiff*>(_vertices[3]);
    const VertexTimeDiff* dt2 = static_cast<const VertexTimeDiff*>(_vertices[4]);

    // VELOCITY & ACCELERATION
    const Eigen::Vector2d diff1 = pose2->position() - pose1->position();
    const Eigen::Vector2d diff2 = pose3->position() - pose2->position();
        
    double dist1 = diff1.norm();
    double dist2 = diff2.norm();
    const double angle_diff1 = g2o::normalize_theta(pose2->theta() - pose1->theta());
    const double angle_diff2 = g2o::normalize_theta(pose3->theta() - pose2->theta());
    
    if (cfg_->trajectory.exact_arc_length) // use exact arc length instead of Euclidean approximation
    {
        if (angle_diff1 != 0)
        {
            const double radius =  dist1/(2*sin(angle_diff1/2));
            dist1 = fabs( angle_diff1 * radius ); // actual arg length!
        }
        if (angle_diff2 != 0)
        {
            const double radius =  dist2/(2*sin(angle_diff2/2));
            dist2 = fabs( angle_diff2 * radius ); // actual arg length!
        }
    }
    
    double vel1 = dist1 / dt1->dt();
    double vel2 = dist2 / dt2->dt();
    
    
    // consider directions
//     vel1 *= g2o::sign(diff1[0]*cos(pose1->theta()) + diff1[1]*sin(pose1->theta())); 
//     vel2 *= g2o::sign(diff2[0]*cos(pose2->theta()) + diff2[1]*sin(pose2->theta())); 
    vel1 *= fast_sigmoid( 100*(diff1.x()*cos(pose1->theta()) + diff1.y()*sin(pose1->theta())) ); 
    vel2 *= fast_sigmoid( 100*(diff2.x()*cos(pose2->theta()) + diff2.y()*sin(pose2->theta())) ); 
    
    const double acc_lin  = (vel2 - vel1)*2 / ( dt1->dt() + dt2->dt() );
   

    _error[0] = penaltyBoundToInterval(acc_lin,cfg_->robot.acc_lim_x,cfg_->optim.penalty_epsilon);
    
    // ANGULAR ACCELERATION
    const double omega1 = angle_diff1 / dt1->dt();
    const double omega2 = angle_diff2 / dt2->dt();
    const double acc_rot  = (omega2 - omega1)*2 / ( dt1->dt() + dt2->dt() );
      
    _error[1] = penaltyBoundToInterval(acc_rot,cfg_->robot.acc_lim_theta,cfg_->optim.penalty_epsilon);

    
    ROS_ASSERT_MSG(std::isfinite(_error[0]), "EdgeAcceleration::computeError() translational: _error[0]=%f\n",_error[0]);
    ROS_ASSERT_MSG(std::isfinite(_error[1]), "EdgeAcceleration::computeError() rotational: _error[1]=%f\n",_error[1]);
  }

总结

  • 主要限制了最大角速度和角加速度

2.7 EdgeTimeOptimal

  • EdgeTimeOptimal 继承 public BaseTebUnaryEdge<1, double, VertexTimeDiff> 一元边
  • 误差向量维度为1
  void computeError()
  {
    const VertexTimeDiff* timediff = static_cast<const VertexTimeDiff*>(_vertices[0]);
   _error[0] = timediff->dt();
  }

总结

  • 时间越小越好， 这样子机器人会向最大速度去调整

2.8 EdgeShortestPath

  • EdgeShortestPath : public BaseTebBinaryEdge<1, double, VertexPose, VertexPose> 二元边
  • 误差向量维度为1
  void computeError() {
    const VertexPose *pose1 = static_cast<const VertexPose*>(_vertices[0]);
    const VertexPose *pose2 = static_cast<const VertexPose*>(_vertices[1]);
    _error[0] = (pose2->position() - pose1->position()).norm();
  }

总结

  • 两个姿态顶点之间的距离越小cost 越低

2.9 EdgeKinematicsDiffDrive

  • EdgeKinematicsDiffDrive : public BaseTebBinaryEdge<2, double, VertexPose, VertexPose> 二元边
  • 误差维度为2
    nage
  void computeError()
  {
    const VertexPose* conf1 = static_cast<const VertexPose*>(_vertices[0]);
    const VertexPose* conf2 = static_cast<const VertexPose*>(_vertices[1]);
    
    Eigen::Vector2d deltaS = conf2->position() - conf1->position();

    // non holonomic constraint
    _error[0] = fabs( ( cos(conf1->theta())+cos(conf2->theta()) ) * deltaS[1] - ( sin(conf1->theta())+sin(conf2->theta()) ) * deltaS[0] );

    // positive-drive-direction constraint
    Eigen::Vector2d angle_vec ( cos(conf1->theta()), sin(conf1->theta()) );	   
    _error[1] = penaltyBoundFromBelow(deltaS.dot(angle_vec), 0,0);
    // epsilon=0, otherwise it pushes the first bandpoints away from start
  }

总结

  • 不允许反方向
  • 不允许 超越动力学范围

2.10 EdgePreferRotDir

  • EdgePreferRotDir : public BaseTebBinaryEdge<1, double, VertexPose, VertexPose> 二元边
  • 误差维度为1
  void computeError()
  {
    const VertexPose* conf1 = static_cast<const VertexPose*>(_vertices[0]);
    const VertexPose* conf2 = static_cast<const VertexPose*>(_vertices[1]);    
    _error[0] = penaltyBoundFromBelow( _measurement*g2o::normalize_theta(conf2->theta()-conf1->theta()) , 0, 0);
  }

总结

  • 主要是前3个姿态点 更偏向偏向朝哪个个方向旋转
csdn_Flying
关注
  • 12
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
teb_local_planner安装及使用
weixin_30617737的博客
08-24 2138
teb_local_planner的详尽资料（包括安装及导航，参数调节等）请参考其ros官方文档：http://wiki.ros.org/teb_local_planner和http://wiki.ros.org/teb_local_planner/Tutorials。 teb_local_planner的github源码：https://github.com/rst-tu-dortm...
【Navigation】teb_local_planner 源码解析
17902的博客
01-07 609
ROS局部路径规划器插件teb_local_planner流程梳理（上） ROS局部路径规划器插件teb_local_planner流程梳理（下）主要文件：
对于阿克曼底盘的teb local planner 的参数如何进行优化
最新发布
qq2650326396的博客
04-19 562
的参数优化需要考虑到阿克曼转向机构的限制，例如最小转弯半径和前轮转向角度限制。以下是一些针对阿克曼底盘机器人的。对于阿克曼（Ackermann）底盘的机器人，
局部路径规划器teb_local_planner详解6：关于动态障碍物与常见问题
miya的博客
02-02 6789
前言 在局部路径规划器teb_local_planner详解5：关于car-like robots中，我们介绍了与car-like机器人模型相关的参数，说明了在对接底盘的时候需要注意底盘接收的控制指令格式。我们还介绍了holonomic robot应该配置的参数。 本章主要描述teb中处理动态障碍物的方法 一、相关参数 重要参数： ~<name>/include_dynamic_obstacles: 是否考虑动态障碍物 ~<name>/dynamic_obstacle_inflati
ROS局部路径规划器插件teb_local_planner流程梳理（上）
慕羽★的博客
08-18 2721
在我之前的文章《ROS导航包Navigation中的 Movebase节点路径规划相关流程梳理》中已经介绍过Move_base节点调用局部路径规划器插件的接口函数是computeVelocityCommands，接下来，我们就从这个函数入手梳理一下teb_local_planner功能包的工作流程。
TEB算法详解（TebLocalPlannerROS::computeVelocityCommands（1））
热门推荐
YiYeZhiNian的博客
04-04 1万+
TebLocalPlannerROS::computeVelocityCommands作为teb算法与move_base算法的接口函数，是作为teb算法的重点部分去分析的，这一节先看该算法的前半部分，也就是局部路径规划前的数据处理部分，这部分算法的基本思路如下：
teb_localplanner源码学习
qq_41986495的博客
12-23 1万+
概述 teb_localplanner是以优化的方法进行局部导航的软件包。基于timed elastic band 方法进行轨迹生成。考虑了运动时的轨迹执行时间、避障、动力学的界约束等条件。此笔记是对teb包的源代码进行学习的一个记录。 teb包的类继承图 1、teb中的g2o类型 利用doxywizard+graphiz对包进行解析，查看类继承图 teb的优化问题的解决利用了开源软件包g2o，先...
teb_local_planner_tutorials-kinetic_teb完整机器人_ROS_TEB路径_
09-29
在"teb_local_planner_tutorials-kinetic_teb"这个包中，包含了针对ROS Kinetic版本的Teb Local Planner的教程和示例。Kinetic是ROS的一个发行版，提供了稳定且广泛支持的软件库，适合作为开发平台。 1. **基本概念...
teb_local_planner.zip
07-18
"teb_local_planner"就是这样一个ROS本地规划器，专门针对具有Ackermann转向结构的车辆设计。 Ackermann转向系统常见于汽车，它的前轮和后轮转向角度不同，能够提供更好的直线行驶稳定性和转向灵活性。在ROS中，...
teb_local_planner:考虑基于时间弹性带（ROS软件包）的移动机器人独特拓扑的最优轨迹规划器
04-28
teb_local_planner ROS软件包teb_local_planner软件包为2D导航堆栈的base_local_planner实现了一个插件。 称为“定时弹性带”的基础方法可以在轨迹执行时间，与障碍物的分离以及在运行时遵守运动动力学约束的方面...
teb_local_planner-melodic-devel.zip
04-01
在ROS Melodic中，TebLocalPlanner的开发包"teb_local_planner-melodic-devel"包含了所有必要的源代码、配置文件以及文档，使得用户可以轻松集成和自定义这个路径规划器。这个zip文件解压后，你将找到包含C++源码、...
TB_Day_Planner
03-17
每日计划描述：作为一个忙碌的人，有一个我可以查看的时间表非常有用，这样我就能知道我每天的工作情况。... 该应用程序的时间段是典型工作日的上午9点至下午5点。 我可以在列中输入内容，然后使用侧面的保存按钮将数据...
ROS导航小车1 teb_local_planner参数(仅作记录/收集)
lx的博客
12-02 4319
teb
ROS局部路径规划器插件teb_local_planner规划流程概括总结
慕羽★的博客
08-18 1905
本部分文章主要用于对ROS局部路径规划器插件teb_local_planner的规划流程进行梳理，并概括总结，本部分计划包含5~6篇文章
局部路径规划----Teb
gezongbo的博客
03-12 2867
Teb参数 teb_local_planner软件包允许用户设置参数以自定义行为。这些参数分为几类：机器人配置，目标公差，轨迹配置，障碍，优化，独特拓扑中的规划以及其他参数。选择其中一些以符合base_local_planner的要求。可以在运行时使用rqt_reconfigure修改许多（但不是全部）参数。 配置参数 ?<名称> / acc_lim_x（double，默认值：0.5） 机器人的最大平移加速度，单位为米/秒^ 2 ?<名称> / acc_lim_theta（doubl
ROS-melodic：源码安裝teb_local_planner算法、替换DWA算法
weixin_44190648的博客
06-14 5014
ROS-melodic：源码安裝teb_local_planner算法、替换DWA算法
ROS teb_local_planner使用
weixin_62456310的博客
03-09 6230
teb_local_planner则是2D导航堆栈的base_local_planner的插件。实现了一个在线优化的本地轨迹规划器，用于导航和控制移动机器人，作为ROS 导航包的插件。全局规划器生成的初始轨迹在运行时期间进行优化，最小化轨迹执行时间（时间最优目标）， 与障碍物分离并符合动力学约束，例如满足最大速度和加速度。当前的实施符合非完整机器人（差动驱动和类似汽车的机器人）的运动学。自Kinetic以来，包括对完整机器人的支持。 一.teb_local_planner配置方法 安装步骤 源码安装.
ROS——Teb算法的优化
ArtoriaLili的博客
04-21 5985
一、简介“TEB”全称Time Elastic Band（时间弹性带）Local Planner，该方法针对全局路径规划器生成的初始轨迹进行后续修正(modification)，从而优化机器人的运动轨迹，属于局部路径规划。关于eletic band（橡皮筋）的定义：连接起始、目标点，并让这个路径可以变形，变形的条件就是将。二、说明。
ROS teb_local_planner安装及使用
qq_45252077的博客
11-22 1300
多机器人编队在狭窄环境中避障能力较差，领航机器人有时规划不出一条可达路径，故希望采用TEB算法来进行领航者机器人的局部路径规划。以提高机器人编队整体的避障能力。虽然整体上机器人编队的避障效果有所改善，但仍未能达到预期的效果，后面打算通过调参来进一步改进，且目前跟随机器人在移动时在地图中留下了障碍物痕迹，对导航效果产生了消极的影响，后面想办法消除他们。
teb_local_planner如何使用
05-11
teb_local_planner是ROS中的一个局部路径规划器，用于生成机器人在环境中的局部路径。以下是使用teb_local_planner的基本步骤： 1. 安装teb_local_planner: ``` sudo apt-get install ros-<distro>-teb-local-planner ``` 2. 在机器人的工作空间中创建一个catkin包，并在package.xml中添加如下依赖项： ``` <build_depend>teb_local_planner</build_depend> <run_depend>teb_local_planner</run_depend> ``` 3. 创建一个launch文件，将teb_local_planner配置为全局规划器的子规划器： ```xml <launch> <node name="move_base" pkg="move_base" type="move_base" respawn="false" output="screen"> <rosparam file="$(find your_robot_config)/base_local_planner_params.yaml" command="load" /> <rosparam file="$(find your_robot_config)/global_planner_params.yaml" command="load" /> <param name="base_global_planner" value="navfn/NavfnROS" /> <param name="base_local_planner" value="teb_local_planner/TebLocalPlannerROS" /> </node> </launch> ``` 4. 在机器人配置文件夹下创建一个base_local_planner_params.yaml文件，并在其中添加TebLocalPlannerROS的参数设置。这里提供一个示例： ```yaml # TEB Local Planner parameters TrajectoryPlannerROS: max_vel_x: 0.5 max_rotational_vel: 1.0 min_in_place_rotational_vel: 0.1 escape_vel: -0.1 acc_lim_x: 1.0 acc_lim_th: 1.0 holonomic_robot: false max_vel_theta: 1.0 min_turning_radius: 0.2 footprint_model: consavable_laser_scan footprint_padding: 0.1 teb_autosize: true dt_ref: 0.3 dt_hysteresis: 0.1 min_samples: 3 global_plan_overwrite_orientation: true allow_init_with_backwards_motion: false max_global_plan_lookahead_dist: 3.0 force_reinit_new_goal_dist: 1.0 force_reinit_new_goal_angular: 0.2 inscribed_radius: 0.25 circumscribed_radius: 0.3 costmap_converter_plugin: "" costmap_converter_spin_thread: true visualize_subsampled_path: false visualize_voronoi_path: false visualize_infeasible_points: false visualize_dynamic_obstacles: false delete_detours_backwards: false detours_orientation_tolerance: 0.1 weight_viapoint: 1.0 weight_optimaltime: 1.0 weight_shortest_path: 0.0 viapoints_all_candidates: false max_number_classes: 0 selection_cost_hysteresis: 0.1 selection_prefer_initial_plan: false selection_obst_cost_scale: 10.0 selection_viapoint_cost_scale: 1.0 selection_alternative_time_cost: true selection_dropping_probability: 0.0 selection_dropping_memory: 2 ``` 5. 启动机器人并运行局部路径规划器： ``` roslaunch your_robot_name teb_local_planner.launch ``` 以上是使用teb_local_planner的基本步骤，你需要根据你的机器人配置和任务需求进行相应的参数配置。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值