精华内容
下载资源
问答
  • 避障算法

    千次阅读 2019-09-26 10:29:23
    基于传感器信息的局部路径规划 全局路径规划- ... Bug算法 http://www.cnblogs.com/21207-iHome/p/5998635.html Bug2感觉很奇怪…… 就只按局部信息的话我以为会在...

    基于传感器信息的局部路径规划
    全局路径规划- http://blog.csdn.net/birdy_/article/details/77448861

    Bug算法

    http://www.cnblogs.com/21207-iHome/p/5998635.html
    Bug2感觉很奇怪……
    这里写图片描述
    就只按局部信息的话我以为会在qL1处变成一个循环。
    好像是要去记录已有的q点然后对于这些q点不处理。那这样的话临界状态会不会有问题(比如qH2和qL2距离过近)

    向量势直方图法

    这里写图片描述

    曲率速度法

    咦这一块居然没有找到很合适的资料- -
    如果定一个目的的点、结合现有的是方向和速度的话找一段圆弧?

    动态窗口法

    http://www.cnblogs.com/LittleTiger/p/4602191.html
    这一块详细的解释看参考的那个ppt吧

    大体就是确定 可行的 v&w -在可行的速度空间内选定最优的速度控制指令
    评价方法如下
    这里写图片描述

    参考

    https://wenku.baidu.com/view/9d108d860242a8956bece4b8.html?pn=51

    转载于:https://www.cnblogs.com/BirdCage/p/9974066.html

    展开全文
  • 编组避障算法

    2018-05-13 08:59:58
    三角形避障算法,有栅格和连续两种,编组在避障时自动分离,避障后没有障碍物后回复正确状态。
  • 移动机器人的超声模糊避障算法.pdf 介绍了关于移动机器人的超声模糊避障算法的详细说明,提供机器人知识的技术资料的下载。
  • 机器人避障算法

    2013-06-07 22:40:39
    避障算法,对于设计机器人移动避障很有用,来吧,赶紧下载
  • 把滚动规划和径向基函数神经网络(RBFNN)预测相结合,提出一种动态不确定环境下移动机器人局部路径规划过程中,针对动态障碍物的新的混合避障算法.利用摄像镜头采集动态障碍物的移动轨迹,提取形心序列,利用RBFNN建立...
  • 这是一个学习机器人避障算法的matlab仿真代码,直接下载运行就可以使用,备注非常详细,大家可以自定义避障地图,也可以更改参数实现不同的避障
  • 基于多传感器信息融合的AGV避障算法
  • 智能车辆自主避障算法研究.caj
  • 为提高足式移动机器人的避障能力和路径规划效率,提出一种凸优化与A*算法结合的路径避障算法.首先,基于半定规划的迭代区域膨胀方法IRI-SDP(iterative regional inflation by semi-definite programming),通过交替使用...
  • 这是机械臂智能避障算法,能够完美躲避障碍夹取物品,代码是M代码,运行main函数即可实现仿真使用,可以修改目的地参数、障碍参数。
  • 一种六自由度机械臂避障算法研究pdf,一种六自由度机械臂避障算法研究
  • 苹果采摘机器人机械手避障算法研究,姬伟,程风仪,针对非结构化环境下的采摘机器人机械手实时避障问题,提出一种改进人工势场法的路径规划算法。在保留传统人工势场法易于实现,结
  • 飞控APX.2避障算法

    2015-05-25 15:44:14
    飞控APX.2避障算法,源代码,能够用于APX.2飞控,大家来下载啊
  • 为解决现有机械臂避障算法计算量大且难以实现非结构环境下三维避障问题,对分解运动速度控制算法(RMRC)进行了改进,并将其应用到Motoman机械臂三雏避障中。通过对Motoman机械臂机构的合理简化和RMRC算法的进一步改进...
  • 苹果采摘机器人机械手避障算法研究 ;针对非结构化环境下的采摘机器人机械手实时避障问题提出一种改进人工势场法的路径规划算法节理裂隙岩体力学性质研究是非常复杂的课题物理模型试验由于存在制样难耗资大结果有限等...
  • 一个简单的开源代码,基于粒子群法的USV自主避障算法,界面用MFC制作。可自己设置起点终点,静态、动态障碍物,以及选择障碍物形态为圆或者矩形。
  • 针对移动机器人自主导航过程中由于过多寻求当前时刻最优路径或最优解而产生死锁或震荡现象,提出了一种动态变化权重的移动机器人行为融合避障算法.该算法利用多目标优化方法获得移动机器人最有效解,并把指定目标的...
  • 文件包里包含了多智能体最优一致性避障算法研究文章一篇及Matlab仿真源程序,使用一致性算法进行避障有利用多机器人快速到达目标位置
  • 水面无人艇局部危险避障算法研究 答辩PPT-包含动画。 将水面无人艇局部危险避障分为三层进行考虑:基于PSO的已知静态路径规划方法,基于PSO并融合海事规则的已知动态路径规划方法和基于滚动窗口的未知环境下的避障...
  • 多机器人编队人工势场法协同避障算法原理及实现

    千次阅读 多人点赞 2020-05-21 09:37:13
    ROS及SLAM进阶教程(十一)多机器人编队人工势场法协同避障算法原理及实现避障算法原理避障算法仿真 多机器人协同编队需要将理论和实践紧密地结合起来,其应用包括编队队形生成、保持、变换和路径规划与避障等等都是...

    多机器人编队(二)多机器人编队人工势场法协同避障算法原理及实现


    多机器人协同编队需要将理论和实践紧密地结合起来,其应用包括编队队形生成、保持、变换和路径规划与避障等等都是基于图论的理论基础完成的。

    详细请参考多机器人编队(一)多机器人协同编队算法原理及实现

    自主避障功能是机器人编队在各种环境中保持自身安全的重要功能,在编队的基础上加入避障的功能,机器人可扫描到一定范围内的障碍物(包括其他机器人),在即将与之发生冲突时提前规避冲突,以保证自身的安全性,同时需要在避障的同时尽可能地保持队形,选择最优的避障路线以使障碍物对编队稳定性的影响降至最低。

    避障算法原理

    机器人在实际运动过程中,会借助自身传感器(如激光雷达)对周围环境进行扫描检测,如下图所示
    人工势场法算法原理
    假设在k时刻机器人可扫描到一定范围内的障碍物坐标xobsx_{obs}(包括其他机器人),障碍物会对机器人jj的速度产生一个斥力影响RRRR满足:
    Rj(k)=l=1Mα(xj(k)xobsl)R_j(k)=\sum^M_{l=1}\alpha(x_j(k)-x_{obs}^l)
    其中MM为障碍物个数,α=1dj(k)1dMδd\alpha=\frac{\frac{1}{d_j(k)}-\frac{1}{d_M}}{\delta\cdot d},dj(k)=xRxj(k)d_j(k)=\|x_R-x_j(k)\|dMd_M为探测距离,δ\delta为一常数,在此时刻避障响应R(k)R(k)会对机器人的速度控制产生一个影响,此时编队中领航者控制模型如下uN(k)=m+kD(k)+iNiaNirNi(k)+βRN(k)u_N(k)=m+k\cdot D(k)+\sum_{i\in N_i}a_{Ni}r_{Ni}(k)+\beta\cdot R_N(k)其中β\beta为一常数,而跟随者的控制算法为ui(k)=εjNiaij(xj(k)xi(k)rij(k))+βRi(k)u_i(k)=\varepsilon\sum_{j\in N_i}a_{ij}(x_j(k)-x_i(k)-r_{ij}(k))+\beta\cdot R_i(k)这个影响使得机器人在最大限度保持原有编队的基础上能够有效躲避障碍物,并且会随着障碍物距离的变近而变大,从而保证机器人的安全。

    避障算法仿真

    在前文编队一致性算法的仿真上(ROS及SLAM进阶教程(八)多机器人协同编队算法原理及实现)加入上述避障算法,在编队的任务路径上设置障碍物,使障碍物干扰机器人的正常任务,观察机器人编队的运动结果,目的是使编队在躲避障碍物的同时尽可能保持编队稳定性。
    MATLAB仿真结果如下所示
    编队仿真
    从上图可以看出,障碍物(即图中叉号所在)对编队产生了影响,可以看出编队在安全范围内检测到了障碍物后进行避障运算躲开了障碍物,但很快又恢复稳定,编队能继续保持稳定地执行任务。这种避障方法对于编队协同算法的效果受其实时恢复的影响。

    MATLAB仿真源码详见多机器人编队及避障算法.zip
    ROS下python源码详见
    Ros-Formation-and-Obstacle-Avoidance

    以上是关于多机器协同编队的人工势场法算法原理讲解。
    码字不易,喜欢的话请点赞收藏关注哦,您的支持是博主最大的动力。

    博主有两年多ROS的使用经验,目前仍在不停研究中。本系列多机器人编队将结合论文讲解多机器人编队的算法原理、稳定性分析等研究领域,持续不断更新中。如果大家有相关问题或发现作者漏洞欢迎私戳,同时欢迎关注收藏。
    同时欢迎关注博主Git:
    https://github.com/redglassli

    展开全文
  • 针对室内有人复杂环境下的服务机器人避障问题,提出了一种基于函数模型调控离散PID控制器的避障算法。通过分析并简化室内有人环境的复杂情况,然后采用递减函数模型对机器人减速后,再采用人工增量法干预PID控制器...
  • 在具有复杂性与不确定性的水环境下,针对无法建立精确的水下机器人控制数学模型问题,提出基于模 糊控制的仿生机器鱼避障算法。将视线导航原理与模糊控制思想相结合,进行水下机器人路径规划。通过专家经验,设计一个...
  • 机器人局部动态避障算法dwa解析

    千次阅读 多人点赞 2019-04-30 08:55:53
    机器人局部动态避障算法dwa解析 简介   dwa算法全称叫动态窗口法(dynamic window approach),其算法过程主要分为仿真获取机器人的运动轨迹、对轨迹进行评价选择最优轨迹两个主要过程,动态窗口表达的是...

    机器人局部动态避障算法dwa解析

    简介

       dwa算法全称叫动态窗口法(dynamic window approach),其算法过程主要分为仿真获取机器人的运动轨迹、对轨迹进行评价选择最优轨迹两个主要过程,动态窗口表达的是仿真的运动轨迹数量有限,主要是因为机器人在较短的控制周期内只能达到一定的速度。

    一、机器人如何仿真获取运动轨迹

    1、获取机器人速度样本

        根据机器人当前速度以及运动特性,确定机器人可达的运动速度范围。由于运动的最终目的是到达目标点,因此,在到达目标点附近时,需要降低机器人运动速度,也就是进一步限制机器人的速度范围,以保证机器人能平稳的到达目标点。最后根据人为给定的样本数,在限制的速度范围内获得样本数个离散的速度样本,包括线速度和角速度。

    void SimpleTrajectoryGenerator::initialise(
        const Eigen::Vector3f& pos, //机器人的位置
        const Eigen::Vector3f& vel, //当前机器人速度
        const Eigen::Vector3f& goal, //目标点
        base_local_planner::LocalPlannerLimits* limits, //运动特性(加速度、最大最小速度......)
        const Eigen::Vector3f& vsamples, //样本
        bool discretize_by_time) {
        
       //给定机器人的最大最小运动速度
      double max_vel_th = limits->max_vel_theta;
      double min_vel_th = -1.0 * max_vel_th;
      discretize_by_time_ = discretize_by_time;
      Eigen::Vector3f acc_lim = limits->getAccLimits();
      pos_ = pos;
      vel_ = vel;
      limits_ = limits;
      next_sample_index_ = 0;
      sample_params_.clear();
    
      double min_vel_x = limits->min_vel_x;
      double max_vel_x = limits->max_vel_x;
      double min_vel_y = limits->min_vel_y;
      double max_vel_y = limits->max_vel_y;
    
      // if sampling number is zero in any dimension, we don't generate samples generically
      if (vsamples[0] * vsamples[1] * vsamples[2] > 0) {
        //compute the feasible velocity space based on the rate at which we run
        Eigen::Vector3f max_vel = Eigen::Vector3f::Zero();
        Eigen::Vector3f min_vel = Eigen::Vector3f::Zero();
    
        if ( ! use_dwa_) {
          //根据机器人位置到目标点的距离,限制机器人的最大运动速度
          double dist = hypot(goal[0] - pos[0], goal[1] - pos[1]);
          max_vel_x = std::max(std::min(max_vel_x, dist / sim_time_), min_vel_x);
          max_vel_y = std::max(std::min(max_vel_y, dist / sim_time_), min_vel_y);
    
          // 根据控制周期和加速度特性,确定机器人可达的最大最小速度
          // 此处用的是sim_time_仿真时间,确定的是接下来一段时间内机器人可达的运动速度范围,默认是1s
          max_vel[0] = std::min(max_vel_x, vel[0] + acc_lim[0] * sim_time_);
          max_vel[1] = std::min(max_vel_y, vel[1] + acc_lim[1] * sim_time_);
          max_vel[2] = std::min(max_vel_th, vel[2] + acc_lim[2] * sim_time_);
    
          min_vel[0] = std::max(min_vel_x, vel[0] - acc_lim[0] * sim_time_);
          min_vel[1] = std::max(min_vel_y, vel[1] - acc_lim[1] * sim_time_);
          min_vel[2] = std::max(min_vel_th, vel[2] - acc_lim[2] * sim_time_);
        } else {
          // 此处用的sim_period_是控制周期,也就是只确定下一个控制周期机器人的运动速度范围
          max_vel[0] = std::min(max_vel_x, vel[0] + acc_lim[0] * sim_period_);
          max_vel[1] = std::min(max_vel_y, vel[1] + acc_lim[1] * sim_period_);
          max_vel[2] = std::min(max_vel_th, vel[2] + acc_lim[2] * sim_period_);
    
          min_vel[0] = std::max(min_vel_x, vel[0] - acc_lim[0] * sim_period_);
          min_vel[1] = std::max(min_vel_y, vel[1] - acc_lim[1] * sim_period_);
          min_vel[2] = std::max(min_vel_th, vel[2] - acc_lim[2] * sim_period_);
        }
    
        //根据给定的速度样本数,在速度空间内等间距的获取速度样本
        Eigen::Vector3f vel_samp = Eigen::Vector3f::Zero();
        VelocityIterator x_it(min_vel[0], max_vel[0], vsamples[0]);
        VelocityIterator y_it(min_vel[1], max_vel[1], vsamples[1]);
        VelocityIterator th_it(min_vel[2], max_vel[2], vsamples[2]);
        for(; !x_it.isFinished(); x_it++) {
          vel_samp[0] = x_it.getVelocity();
          for(; !y_it.isFinished(); y_it++) {
            vel_samp[1] = y_it.getVelocity();
            for(; !th_it.isFinished(); th_it++) {
              vel_samp[2] = th_it.getVelocity();
              //ROS_DEBUG("Sample %f, %f, %f", vel_samp[0], vel_samp[1], vel_samp[2]);
              sample_params_.push_back(vel_samp);
            }
            th_it.reset();
          }
          y_it.reset();
        }
      }
    }
    

    2、生成运动轨迹

      根据速度样本确定运动轨迹,是简单运行学知识,主要注意的是用的仿真时间产生的样本还是仿真周期产生的样本,其中仿真时间指的是人为设定的一段仿真时间,默认1秒,而仿真周期指的是算法的实际控制周期,默认为0.1秒。

    bool SimpleTrajectoryGenerator::generateTrajectory(
          Eigen::Vector3f pos,  //机器人的位姿
          Eigen::Vector3f vel,  //运动速度
          Eigen::Vector3f sample_target_vel,  //样本速度
          base_local_planner::Trajectory& traj) {  //需要生成的轨迹
      double vmag = hypot(sample_target_vel[0], sample_target_vel[1]);
      double eps = 1e-4;
      traj.cost_   = -1.0; // placed here in case we return early
      //trajectory might be reused so we'll make sure to reset it
      traj.resetPoints();
    
      //确定样本是否超过设定的最大移动速度
      // make sure that the robot would at least be moving with one of
      // the required minimum velocities for translation and rotation (if set)
      if ((limits_->min_vel_trans >= 0 && vmag + eps < limits_->min_vel_trans) &&
          (limits_->min_vel_theta >= 0 && fabs(sample_target_vel[2]) + eps < limits_->min_vel_theta)) {
        return false;
      }
      // make sure we do not exceed max diagonal (x+y) translational velocity (if set)
      if (limits_->max_vel_trans >=0 && vmag - eps > limits_->max_vel_trans) {
        return false;
      }
    
      //确定仿真使用的控制周期数
      int num_steps;
      if (discretize_by_time_) {
        num_steps = ceil(sim_time_ / sim_granularity_);
      } else {
        //compute the number of steps we must take along this trajectory to be "safe"
        double sim_time_distance = vmag * sim_time_; // the distance the robot would travel in sim_time if it did not change velocity
        double sim_time_angle = fabs(sample_target_vel[2]) * sim_time_; // the angle the robot would rotate in sim_time
        num_steps =
            ceil(std::max(sim_time_distance / sim_granularity_,
                sim_time_angle    / angular_sim_granularity_));
      }
    
      if (num_steps == 0) {
        return false;
      }
    
      //确定生成轨迹的时间间隔(仅对利用仿真时间进行速度采样的情况)
      //compute a timestep
      double dt = sim_time_ / num_steps;
      traj.time_delta_ = dt;
      
      Eigen::Vector3f loop_vel;
      //连续加速意味着用的是仿真时间进行的速度采样,不是单个控制周期能达到的运动速度。因此,需要根据机器人的运动特性确定接下来的控制周期内机器人能达到的运动速度
      if (continued_acceleration_) {
        // assuming the velocity of the first cycle is the one we want to store in the trajectory object
        loop_vel = computeNewVelocities(sample_target_vel, vel, limits_->getAccLimits(), dt);
        traj.xv_     = loop_vel[0];
        traj.yv_     = loop_vel[1];
        traj.thetav_ = loop_vel[2];
      } else {
        //否则用的就是仿真周期进行的采样,直接将采样速度作为生成轨迹的速度
        // assuming sample_vel is our target velocity within acc limits for one timestep
        loop_vel = sample_target_vel;
        traj.xv_     = sample_target_vel[0];
        traj.yv_     = sample_target_vel[1];
        traj.thetav_ = sample_target_vel[2];
      }
    
      //根据仿真的周期数,生成仿真轨迹
      for (int i = 0; i < num_steps; ++i) {
    
        //add the point to the trajectory so we can draw it later if we want
        traj.addPoint(pos[0], pos[1], pos[2]);
    
        //如果用的是仿真时间进行的速度采样,在每个仿真控制周期内,速度需要根据加减速特性确定
        if (continued_acceleration_) {
          //calculate velocities
          loop_vel = computeNewVelocities(sample_target_vel, loop_vel, limits_->getAccLimits(), dt);
          //ROS_WARN_NAMED("Generator", "Flag: %d, Loop_Vel %f, %f, %f", continued_acceleration_, loop_vel[0], loop_vel[1], loop_vel[2]);
        }
    
        //根据速度和时间,确定运动轨迹上的下一个点
        //update the position of the robot using the velocities passed in
        pos = computeNewPositions(pos, loop_vel, dt);
    
      } // end for simulation steps
    
      return true; // trajectory has at least one point
    }
    

    二、如何对轨迹进行评价并选取最优轨迹

    1、代价函数

    oscillation_costs_ //振荡代价函数,一旦速度发生振荡,直接丢弃速度样本
    obstacle_costs_ //障碍物代价函数,当轨迹进入障碍物区,直接丢弃当前轨迹样本
    goal_costs_ //目标代价函数,优先选择距离局部目标点近的轨迹
    path_costs_ //路径代价函数,优先选择贴近全局路径的轨迹
    goal_front_costs_ //与goal_costs基本一致,不太理解注释中的nose是指什么?
    alignment_costs_ //与path_costs基本一致,不太理解注释中的nose是指什么?
      注:为了能适应不同场景的需求,可以对这些代价函数配置不同的权重,从而能实现不同场景对这些代价函数的重视程度

    2、主要评价函数的实现

    2.1、障碍物代价函数

        通过仿真轨迹将机器人轮廓映射到全局坐标系下,并对轮廓边上的代价值进行分析,选择最大的代价值作为障碍物代价,从而确定机器人是否会撞到障碍物

      double CostmapModel::footprintCost(const geometry_msgs::Point& position,   //机器人在全局坐标系下的位置
      const std::vector<geometry_msgs::Point>& footprint,    //机器人轮廓
       double inscribed_radius, double circumscribed_radius)   //内切圆、外接圆半径
       {
        //used to put things into grid coordinates
        unsigned int cell_x, cell_y;
    
        //get the cell coord of the center point of the robot
        //获得机器人在地图坐标系下的坐标
        if(!costmap_.worldToMap(position.x, position.y, cell_x, cell_y))
          return -1.0;
    
        //if number of points in the footprint is less than 3, we'll just assume a circular robot
        //当轮廓上的点数少于3时,认为机器人是个圆形机器人,并且只判断机器人中心是否在不可走区域
        if(footprint.size() < 3){
          unsigned char cost = costmap_.getCost(cell_x, cell_y);
          //if(cost == LETHAL_OBSTACLE || cost == INSCRIBED_INFLATED_OBSTACLE)
          if(cost == LETHAL_OBSTACLE || cost == INSCRIBED_INFLATED_OBSTACLE || cost == NO_INFORMATION)
            return -1.0;
          return cost;
        }
    
        //now we really have to lay down the footprint in the costmap grid
        unsigned int x0, x1, y0, y1;
        double line_cost = 0.0;
        double footprint_cost = 0.0;
    
        //footprint是一个多边形,判断该多边形是否与障碍物发生碰撞的方法是:计算多边形的所有边的最大代价值,从而确定是否与障碍物相撞
        //we need to rasterize each line in the footprint
        for(unsigned int i = 0; i < footprint.size() - 1; ++i){
          //get the cell coord of the first point
          //获得地图中机器人轮廓上的一个点的坐标
          if(!costmap_.worldToMap(footprint[i].x, footprint[i].y, x0, y0))
            return -1.0;
          
          //获得地图中相邻轮廓点的坐标
          //get the cell coord of the second point
          if(!costmap_.worldToMap(footprint[i + 1].x, footprint[i + 1].y, x1, y1))
            return -1.0;
    
          //确定当前轮廓点与相邻轮廓点构成的边的最大代价值
          line_cost = lineCost(x0, x1, y0, y1);
          //选取所有边的最大代价值
          footprint_cost = std::max(line_cost, footprint_cost);
    
          //if there is an obstacle that hits the line... we know that we can return false right away 
          if(line_cost < 0)
            return -1.0;
        }
    
        //获取第一个轮廓点与最后一个轮廓点构成的边的最大代价值
        //we also need to connect the first point in the footprint to the last point
        //get the cell coord of the last point
        if(!costmap_.worldToMap(footprint.back().x, footprint.back().y, x0, y0))
          return -1.0;
    
        //get the cell coord of the first point
        if(!costmap_.worldToMap(footprint.front().x, footprint.front().y, x1, y1))
          return -1.0;
    
        line_cost = lineCost(x0, x1, y0, y1);
        //确定所有边的最大代价值
        footprint_cost = std::max(line_cost, footprint_cost);
    
        if(line_cost < 0)
          return -1.0;
    
        //if all line costs are legal... then we can return that the footprint is legal
        return footprint_cost;
    
      }
    
    2.2、目标代价函数

      首先根据全局路径与局部代价地图的边界确定局部目标点,然后依据局部目标点生成栅格地图,每个栅格处的值代表当前栅格到目标点的距离,对于障碍物栅格,直接置为到目标点的距离无穷远。最后再根据轨迹末端点处栅格的位置,直接通过索引在地图中获取该位置距目标点的距离,作为距目标点的代价。因此,目标代价函数的主要任务是生成栅格地图。

    //mark the point of the costmap as local goal where global_plan first leaves the area (or its last point)
      void MapGrid::setLocalGoal(const costmap_2d::Costmap2D& costmap, //局部代价地图
          const std::vector<geometry_msgs::PoseStamped>& global_plan)  //全局路径
        {
        sizeCheck(costmap.getSizeInCellsX(), costmap.getSizeInCellsY());
    
        int local_goal_x = -1;
        int local_goal_y = -1;
        bool started_path = false;
    
        //调整全局路径分辨率与地图分辨率一致
        std::vector<geometry_msgs::PoseStamped> adjusted_global_plan;
        adjustPlanResolution(global_plan, adjusted_global_plan, costmap.getResolution());
    
        // 将全局路径与局部代价地图边界的交点作为局部目标点
        for (unsigned int i = 0; i < adjusted_global_plan.size(); ++i) {
          double g_x = adjusted_global_plan[i].pose.position.x;
          double g_y = adjusted_global_plan[i].pose.position.y;
          unsigned int map_x, map_y;
          if (costmap.worldToMap(g_x, g_y, map_x, map_y) && costmap.getCost(map_x, map_y) != costmap_2d::NO_INFORMATION) {
            local_goal_x = map_x;
            local_goal_y = map_y;
            started_path = true;
          } else {
            if (started_path) {
              break;
            }// else we might have a non pruned path, so we just continue
          }
        }
        if (!started_path) {
          ROS_ERROR("None of the points of the global plan were in the local costmap, global plan points too far from robot");
          return;
        }
    
       	//构建距离优先队列,并添加局部目标点作为队列的第一个点
        queue<MapCell*> path_dist_queue;
        if (local_goal_x >= 0 && local_goal_y >= 0) {
          MapCell& current = getCell(local_goal_x, local_goal_y);
          costmap.mapToWorld(local_goal_x, local_goal_y, goal_x_, goal_y_);
          current.target_dist = 0.0;
          current.target_mark = true;
          path_dist_queue.push(&current);
        }
    	
    	//按优先队列的顺序,从局部目标点开始以单个栅格为步长向外膨胀,从而直接确定出每个栅格距离局部目标点的距离
        computeTargetDistance(path_dist_queue, costmap);
      }
    
    2.3、路径代价函数

      该代价函数的实现原理与目标代价函数类似,只是该函数是以局部路径上的所有点作为起点向外膨胀来构建栅格地图,并且是以仿真轨迹上的所有点的距离值的和的平均值作为轨迹的代价值。

    展开全文
  • 谁有经典的集群避障算法,比如Reza Olfati-Saber ,或其他大牛的。 注意是多智能体-集群-避障,不是单个机器人的避障。 定重谢!
  • 机器人Bug避障算法的Matlab半实物仿真软件设计,黄培奎,赵祚喜,Bug算法是机器人在未知环境定目标避障导航的经典理论方法,核心是绕行障碍物边缘,在实际机器人上验证效率低且编程复杂。设计一种
  • 基于模糊控制的移动机器人超声波避障算法,曾增烽,张秀雷,本文给出了履带移动机器人整体的硬件和软件的设计,在此基础上利用超声波传感器得到距离信息,采用模糊控制的原理对机器人感知到

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 737
精华内容 294
关键字:

避障算法