精华内容
下载资源
问答
  • 碰撞检测 步行机器人碰撞检测库 要求: Coldet库: : 的OpenGL 本征3.0
  • 机器人碰撞检测对比

    千次阅读 2018-08-08 10:38:56
    电流环式:但成本低,目前主要应用在小机器人上,比如YUMi机器人   柔性关节式:根据关节力矩传感器和双编码器的反馈估计外力矩,Kuka的iiwa机器人 双编码器式:ur 电子皮肤式:根据机械臂表面的压力传感器检测外力...

    https://www.aiimooc.com/article/show-htm-itemid-58.html

     

    电流环式:但成本低,目前主要应用在小机器人上,比如YUMi机器人

     

    柔性关节式:根据关节力矩传感器和双编码器的反馈估计外力矩,Kuka的iiwa机器人

    双编码器式:ur

    电子皮肤式:根据机械臂表面的压力传感器检测外力。这种方式检测灵敏,精度很高,但成本过高,装配复杂。今年工博会博世展示了基于电子皮肤的APAS人机协作智能系统。

     底座力矩传感器式:Fanuc的绿色协作机器人

     

    展开全文
  • 针对机器人易与进入其工作空间的人或物体发生碰撞的问题,提出一种基于广义动量偏差观测器的碰撞检测方法来提高机器人的安全性。根据机械手广义动量与外力矩之间具有解耦性的特点,该检测算法设计了动量偏差观测器来...
  • 描述机器人开环拖动示教、闭环拖动示教的基本方法和原理。
  • 碰撞检测机器人轨迹规划、计算机仿真等领域的重要问题之一 ,本文在前人的基础上提出一种工业机器人关节间碰撞检测算法。
  • 提出一种面向操作手装配系统的快速碰撞检测算法。该算法以机器人运动学和空间解析几何 为基础, 将判断机械手手臂与障碍物是否发生碰撞问题转化为直线段与有界平面是否存在公共点的简 单解析几何问题, 并以...
  • 利用压电薄膜(PVDF)的压敏特性,设计了一种用于移动机器人碰撞检测的传感器,并完成了传感器的电荷放大电路、数据采集和处理系统的设计.实验表明该传感器不但能快速、准确地感知移动机器人碰撞,而且还能准确感知碰撞...
  • 水下模块化自重构机器人模块碰撞快速检测算法,徐雪松,,USS机器人是一种水下模块化自重构机器人,该机器人系统在运动和自重构过程中需要快速的模块碰撞检测方法,以提高其运动效率。针对
  • 提出一种面向操作手装配系统的快速碰撞检测算法。该算法以机器人运动学和空间解析几何为基础,将判断机械手手臂与障碍物是否发生碰撞问题转化为直线段与有界平面是否存在公共点的简单解析几何问题,并以PUMA560操作...
  • UMS机器人是一种水下模块化自重构机器人,该机器人系统在运动和自重构过程中需要快速的模块碰撞检测方法,以提高其运动效率。针对这个问题,提出一种“自相似分割”的快速检测方法,其计算速度要比通常的模块碰撞算法快...
  • 此文档用于描述,多臂机器人碰撞研究,适用于工业或医疗机器人行业。
  • 足球机器人仿真中的快速碰撞检测,郭亿,薛方正,针对微型足球机器人比赛系统,提出了一套碰撞检测方案。在分析场上运动物体的几何特征和运动特点以及传感器特点的基础上,以关键
  • 基于碰撞检测机制的遥操作机器人避障研究*,倪涛,刘金锋,为提高遥操作机器人的操作安全性能,本文采用视景仿真引擎OSG及多体动力学仿真软件Vortex搭建遥操作机器人虚拟场景,设计了基于OBB层
  • 机器人运动控制与规划第六章碰撞检测算法(英文)pdf,机器人运动控制与规划第六章碰撞检测算法(英文)
  • 碰撞检测功能在机器人的运动规划技术中是必不可少的,毕竟机器人所处的真实环境是如此的复杂,而我们却要获取机器人无碰撞的运动轨迹。 运动规划算法通常比较流行的有两类:一类是基于采样的运动规划算法,如...

    碰撞检测功能在机器人的运动规划技术中是必不可少的,毕竟机器人所处的真实环境是如此的复杂,而我们却要获取机器人无碰撞的运动轨迹。
    运动规划算法通常比较流行的有两大类:一类是基于采样的运动规划算法,如大名鼎鼎的OMPL运动规划库,另外一类就是各种基于优化的运动规划算法,如伯克利开源的TrajOpt算法,根据其论文的描述,该算法使用了顺序凸优化技术。当然了,还有结合采样和优化的运动规划算法,但是通常我们主要把它归类为基于优化的运动规划算法。通过基于采样的运动规划算法获取一条比较粗糙的可行路径,然后以此为初始条件进行优化,从而得到比较理想的运动轨迹。

    提供碰撞检测功能的第三方库有很多,比如常用的有PQP、FCL、Bullet、YAOBI等等。
    如果你对碰撞检测相关的研究比较感兴趣,建议访问 awesome-collision-detection

    在本篇博客中,我们主要介绍如何基于RobWork框架编程实现对机器人当前状态的碰撞检测,这在机器人的路径规划中是必不可少的步骤。

    #include <iostream>
    #include <vector>
    #include <rw/loaders/WorkCellLoader.hpp>
    #include <rw/loaders/WorkCellFactory.hpp>
    #include <rw/models/WorkCell.hpp>
    #include <rw/models/Device.hpp>
    #include <rw/kinematics/State.hpp>
    #include <rw/common/Ptr.hpp>
    #include <rw/math.hpp>
    #include <rw/pathplanning/StateConstraint.hpp>
    #include <rw/proximity/CollisionDetector.hpp>
    #include <rwlibs/proximitystrategies/ProximityStrategyFactory.hpp>
    #include <rw/invkin/JacobianIKSolver.hpp>
    #include <rw/invkin/IKMetaSolver.hpp>
    
    
    using namespace rw::common;
    using namespace rw::models;
    using namespace rw::loaders;
    using namespace rw::kinematics;
    using namespace rw::math;
    using namespace rw::proximity;
    using namespace rwlibs::proximitystrategies;
    using namespace rw::pathplanning;
    using namespace rw::invkin;
    
    int main() {
        std::cout << std::boolalpha;
        std::string filename = "/home/liuqiang/UR3_2015/UR3.xml";
        WorkCell::Ptr workcell = WorkCellLoader::Factory::load(filename);
        std::cout << workcell->getFilename() << "\n";
        std::cout << workcell->getFilePath() << "\n";
        Device::Ptr device = workcell->findDevice("UR3_2015");
        State state = workcell->getDefaultState();
        //
        CollisionDetector::QueryResult result;
        CollisionDetector::Ptr detector = ownedPtr(new CollisionDetector(workcell, ProximityStrategyFactory::makeDefaultCollisionStrategy()));
        //
        StateConstraint::Ptr state_constraint = StateConstraint::make(detector);
        //Q[6]{1.568, -2.4, 1.825, -0.456, -1.571, 0}
        Q q1(6, 1.568, -2.4, 1.825, -0.456, -1.571, 0); //collision free
        device->setQ(q1, state);
        detector->inCollision(state, &result);
        std::cout << "collision free:\n";
        std::cout << "result.collidingFrames.size(): " << result.collidingFrames.size() << "\n";
        if (result.collidingFrames.size() > 0) {
            for(const FramePair &pair : result.collidingFrames) {
                std::cout << "Colliding: " << pair.first->getName() << " -- " << pair.second->getName() << std::endl;
                Log::infoLog() << "Colliding: " << pair.first->getName() << " -- " << pair.second->getName() << std::endl;
            }
        }
        //Q[6]{1.568, -2.331, 2.224, 0.204, -1.316, 0}
        Q q2(6, 1.568, -2.331, 2.224, 0.204, -1.316, 0); //in collision
        device->setQ(q2, state);
        Transform3D<> tcp_pose = device->baseTend(state);
        JacobianIKSolver::Ptr solver = ownedPtr(new JacobianIKSolver(device, state));
        solver->setSolverType(JacobianIKSolver::SVD);
        solver->setMaxIterations(50); //如果不设置,默认是迭代20次
    //    IKMetaSolver::Ptr meta_solver = ownedPtr(new IKMetaSolver(solver, device, detector));
    //    meta_solver->setMaxAttempts(50);
    //    auto solutions = meta_solver->solve(tcp_pose, state);
        auto solutions = solver->solve(tcp_pose, state);
        std::cout << "solutions.size(): " << solutions.size() << "\n";
        std::cout << solutions[0] << "\n";
        std::cout << device->getQ(state) << "\n";
        std::cout << "in collision:\n";
        std::cout << "state_constraint->inCollision(state): " << state_constraint->inCollision(state) << "\n";
        detector->inCollision(state, &result);
        std::cout << "result.collidingFrames.size(): " << result.collidingFrames.size() << "\n";
        if (result.collidingFrames.size() > 0) {
            for(const FramePair &pair : result.collidingFrames) {
                std::cout << "Colliding: " << pair.first->getName() << " -- " << pair.second->getName() << std::endl;
                Log::errorLog() << "Colliding: " << pair.first->getName() << " -- " << pair.second->getName() << std::endl;
            }
        }
        return 0;
    }
    

    运行输出的结果为:

    /home/liuqiang/UR3_2015/UR3.xml
    /home/liuqiang/UR3_2015/
    collision free:
    result.collidingFrames.size(): 0
    solutions.size(): 1
    Q[6]{1.568, -2.331, 2.224, 0.204, -1.316, 0}
    Q[6]{1.568, -2.331, 2.224, 0.204, -1.316, 0}
    in collision:
    state_constraint->inCollision(state): true
    result.collidingFrames.size(): 1
    Colliding: UR3_2015.Flange -- UR3_2015.Joint1
    Colliding: UR3_2015.Flange -- UR3_2015.Joint1
    

    测试的collision free状态如下截图:
    在这里插入图片描述而测试的in collision状态如下截图:
    在这里插入图片描述
    从我们运行输出的结果也可以看出,机器人在collision free状态下是没有碰撞,而在in collision状态下UR3_2015.Flange 和 UR3_2015.Joint1之间发生了碰撞。

    总结:本篇博客主要介绍如何通过代码实现机器人状态的碰撞检测功能。实现了碰撞检测功能之后,就可以进行机器人的运动规划了,比如自己实现一个基于采样的RRT算法来进行测试,不过需要说明的是基本的RRT算法速度很慢,改进版的双向RRT算法速度会快不少。

    展开全文
  • 工业机器人技术解密之动力学应用:碰撞检测 随着机器人应用范围增大,人们对机器人的要求也越来越高,尤其在机器人安全性能方面。最初研制的机器人只能完成一些简单的重复任务,不具备人机交互能力;随着技术的...
    工业机器人技术解密之动力学应用:碰撞检测
    			

    随着机器人应用范围增大,人们对机器人的要求也越来越高,尤其在机器人安全性能方面。最初研制的机器人只能完成一些简单的重复任务,不具备人机交互能力;随着技术的高速发展,机器人趋于智能化,能够完成更加复杂的任务,例如喷涂、装配、钻孔等。

    传统的工业机器人并未配备适当的安全和碰撞检测系统。因此,为保证机器的安全运行,往往要求配备防护栏,用于保证运行时与人隔离。

    但是随着技术发展,机器人开始承担越来越复杂的任务。这些任务往往要求工作人员即时介入,因而使得如何实现安全的人机交互成为至关重要的问题。为保证安全,控制器需要实时检测机器人与工作人员之间是否存在碰撞,并通过相应的控制策略保证碰撞不至于伤害工作人员。

     

    当前,大多数检测碰撞或碰撞力都是通过添加外部传感器实现的。

     

    1.采用腕力传感器来检测碰撞:该方法可以精确检测手抓末端的碰撞力,但无法检测机器人其它部位的碰撞,故而检测范围受限,一般应用于磨削力、装配力等手抓末端碰撞力的检测。

     

     

    2.采用感知皮肤来检测碰撞:该方法将感知皮肤覆盖在机器人全身,可检测到任意部位的碰撞。但缺点在于,布线比较复杂,抗干扰能力较差,且极大的增加了处理器的运算量。凡是使用外部传感器检测碰撞或碰撞力的方法,都不可避免的导致系统成本和复杂程度的大幅上升。

     

    3.采用电机的电流或者反馈的力矩来检测碰撞:这是一种能够广泛应用于各种工业机器人的方案,无需额外添加传感器,且检测范围能够覆盖机器人的整个表面。

     

    综上,前两种方法均在不同程度上具有局限性,第一种方法检测范围受限,第二种方法布线复杂,而第三种方法则完美解决了前两者的不足。三种方法,高下立判。

     

    考虑到工业机器人的实际工作情况和性能要求,广州启帆采用的正是上述第三种方法,即利用机器人自身传感器来检测碰撞。

     

    实现碰撞检测的流程为,通过驱动读取当前机器人各关节的位置、速度和加速度,再将对应的参数代入下式:

     

    公式中的是通过逆动力学算得的电机所需要的力矩,其计算公式包括惯性力项、 科里奥利力和离心力项 、重力项及摩擦力项。而当中的摩擦力项根据选择的摩擦力模型可分解为粘性摩擦力项、库仑摩擦力项以及补偿。

    咋看之下,该过程类似于拖动示教,但接下来对于理论力矩的使用就截然不同了。在碰撞检测中,此理论力矩值将与通过驱动读取的实际力矩值进行比对。如产生较大差值(即超出设定的临界值),则可判断为机器人遇到了障碍或发生了碰撞。

    通过利用电机的电流或反馈的力矩而实现的碰撞检测,启帆生产的工业机器人能够在不额外添加传感器的前提下实现机器人本体各部分的碰撞检测,这不但提高了人机交互的安全性和机器人本身的安全性,也从某种程度上提高了机器人的耐用度,同时延长其使用寿命。

    参考广州启帆机器人碰撞检测视频:

    链接:http://pan.baidu.com/s/1dEFfBdZ 密码:qcui

     

    展开全文
  • 避障机器人用于检测障碍物并避免碰撞。 这是一个自主机器人。 避障机器人的设计需要根据其任务集成许多传感器。 机器人通过机器人上安装的传感器从周围区域获取信息。 一些用于障碍物检测的传感设备,例如碰撞...
  • bullet:JVM Bullet Physics SDK:用于VR,游戏,视觉效果,机器人技术,机器学习等的实时碰撞检测和多物理场仿真
  • Bullet Physics SDK这是Bullet Physics SDK的官方C ++源代码存储库:用于VR,游戏,视觉效果,机器人,机器学习等的实时碰撞检测和多物理场仿真。Bullet Physics SDK这是C ++的官方源代码Bullet Physics SDK的代码...
  • 这是Bullet Physics SDK的官方C ++源代码存储库:针对VR,游戏,视觉效果,机器人技术,机器学习等的实时碰撞检测和多物理场仿真。 PyBullet Bullet 2.85中的新功能:pybullet Python绑定,改进了对机器人技术和VR...
  • 该代码用于研究随着机器人数量和尺寸的增加以及每次碰撞产生的延迟时间的变化,机器人碰撞的数量和频率。
  • 重点阐述了空间机器人仿真系统的体系结构、空间机器人运动分析与仿真建模、机器人避碰原则、空间机器人碰撞检测与避碰的实现、空间机器人仿真系统基于Java 3D的实现。
  • 此博文主要是用来记录ROS-Kinetic 中,用于机器人轨迹规划的MoveIt功能...引: Planning Scene这个教程主要是通过手工配置方式,检查机器人是否发生本体各连杆之间碰撞,是否与仿真环境内其他物品发生碰撞。这个教程..

    此博文主要是用来记录ROS-Kinetic 中,用于机器人轨迹规划的MoveIt功能包的学习记录。 

    英文原版教程见此链接:http://docs.ros.org/en/kinetic/api/moveit_tutorials/html/doc/move_group_interface/move_group_interface_tutorial.html

    引: Planning Scene这个教程主要是通过手工配置方式,检查机器人是否发生本体各连杆之间碰撞,是否与仿真环境内其他物品发生碰撞。这个教程是手工配置Planning Scene这个对象,在实际应用过程中,使用ROS自带的API进行碰撞检测的方法比较常用

    注:MoveIt教程基本上都是通过官方案例程序,展示具体实现的过程和代码信息,所以本博文采用在官方程序中,添加中文注解的方式,进行学习和记录。

    /*********************************************************************
     * Software License Agreement (BSD License)
     *
     *  Copyright (c) 2012, Willow Garage, Inc.
     *  All rights reserved.
     *
     *  Redistribution and use in source and binary forms, with or without
     *  modification, are permitted provided that the following conditions
     *  are met:
     *
     *   * Redistributions of source code must retain the above copyright
     *     notice, this list of conditions and the following disclaimer.
     *   * Redistributions in binary form must reproduce the above
     *     copyright notice, this list of conditions and the following
     *     disclaimer in the documentation and/or other materials provided
     *     with the distribution.
     *   * Neither the name of Willow Garage nor the names of its
     *     contributors may be used to endorse or promote products derived
     *     from this software without specific prior written permission.
     *
     *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
     *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
     *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
     *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
     *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
     *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
     *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
     *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     *  POSSIBILITY OF SUCH DAMAGE.
     *********************************************************************/
    
    /* Author: Sachin Chitta, Michael Lautman */
    
    #include <ros/ros.h>
    
    // MoveIt!
    #include <moveit/robot_model_loader/robot_model_loader.h>
    #include <moveit/planning_scene/planning_scene.h>
    
    #include <moveit/kinematic_constraints/utils.h>
    
    // BEGIN_SUB_TUTORIAL stateFeasibilityTestExample
    //
    // User defined constraints can also be specified to the PlanningScene
    // class. This is done by specifying a callback using the
    // setStateFeasibilityPredicate function. Here's a simple example of a
    // user-defined callback that checks whether the "panda_joint1" of
    // the Panda robot is at a positive or negative angle:
    bool stateFeasibilityTestExample(const robot_state::RobotState& kinematic_state, bool verbose)
    {
      const double* joint_values = kinematic_state.getJointPositions("panda_joint1");
      return (joint_values[0] > 0.0);
    }
    // END_SUB_TUTORIAL
    
    int main(int argc, char** argv)
    {
      ros::init(argc, argv, "panda_arm_kinematics");
      ros::AsyncSpinner spinner(1);
      spinner.start();
      std::size_t count = 0;
      // BEGIN_TUTORIAL
      //
      // Setup
      // ^^^^^
      //这个class主要功能是配置机器人运动时,显示碰撞检测 + 显示机器人当前约束条件
      // 这个教程仅仅是体现如何进行实例化,但是在最终使用的时候,还是推荐直接使用ROS的API来进行实例化
      robot_model_loader::RobotModelLoader robot_model_loader("robot_description");       //定义一个RobotModelLoader对象,并将当前服务器内的机器人数据输入其中(读取)
      robot_model::RobotModelPtr kinematic_model = robot_model_loader.getModel();         //kinematic_model对象,并将机器人的model数据输入其中(创建kinematic_model)
      planning_scene::PlanningScene planning_scene(kinematic_model);                      //定义一个planning_sense对象,将机器人动力学模型载入其中(创建planning_sense)
    
    
      // Part1 :本体碰撞检查
      // 碰撞检查的第一个主要功能:首先检查机器人是否存在自身碰撞情况(自身各link之间有无干涉)
      // 自身碰撞检测的方法为:
      // 创建一个CollisionRequest对象+一个CollisionResult对象,然后将这两个对象传入“Collision Checking”方法中
      // 是否碰撞的检测结果被存储在CollisionResult当中。
      // 注意: 碰撞检测是依赖于机器人URDF模型中,自身的mesh配置进行检测的,无其他检测对象。
      collision_detection::CollisionRequest collision_request;
      collision_detection::CollisionResult collision_result;
      planning_scene.checkSelfCollision(collision_request, collision_result);
      ROS_INFO_STREAM("Test 1: Current state is " << (collision_result.collision ? "in" : "not in") << " self collision");
    
      // Part2:修改机器人当前位姿,并再次进行碰撞检查
      // 创建一个current——state对象,并将机器人当前位姿传入其中(注意,对其修改会直接对其关联的对象进行修改)
      // 设定一个随机的位姿给机器人 
      // 首先将上一次检查的碰撞状态清除,然后再次使用planning_scene.checkSelfCollision进行碰撞检测
      robot_state::RobotState& current_state = planning_scene.getCurrentStateNonConst();
      current_state.setToRandomPositions();
      collision_result.clear();
      planning_scene.checkSelfCollision(collision_request, collision_result);
      ROS_INFO_STREAM("Test 2: Current state is " << (collision_result.collision ? "in" : "not in") << " self collision");
    
      // Part3:仅检测机器人末端是否与本体发生碰撞
      collision_request.group_name = "hand";
      current_state.setToRandomPositions();                             //同样,设置随机位姿
      collision_result.clear();                                          //清除当前碰撞状态
      planning_scene.checkSelfCollision(collision_request, collision_result);//检查碰撞
      ROS_INFO_STREAM("Test 3: Current state is " << (collision_result.collision ? "in" : "not in") << " self collision");
    
      // Getting Contact Information
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~
      // Part4:手动定义一个发生本体碰撞的姿态,然后进行检测,并输出碰撞发生位置
    
      std::vector<double> joint_values = { 0.0, 0.0, 0.0, -2.9, 0.0, 1.4, 0.0 };
      const robot_model::JointModelGroup* joint_model_group = current_state.getJointModelGroup("panda_arm");
      current_state.setJointGroupPositions(joint_model_group, joint_values);
      ROS_INFO_STREAM("Test 4: Current state is "
                      << (current_state.satisfiesBounds(joint_model_group) ? "valid" : "not valid"));
    
      // Now, we can get contact information for any collisions that might
      // have happened at a given configuration of the Panda arm. We can ask
      // for contact information by filling in the appropriate field in the
      // collision request and specifying the maximum number of contacts to
      // be returned as a large number.
    
      collision_request.contacts = true;    //设置检测碰撞时候的参数
      collision_request.max_contacts = 1000;
    
      //
    
      collision_result.clear();
      planning_scene.checkSelfCollision(collision_request, collision_result);
      ROS_INFO_STREAM("Test 5: Current state is " << (collision_result.collision ? "in" : "not in") << " self collision");
      collision_detection::CollisionResult::ContactMap::const_iterator it;
      for (it = collision_result.contacts.begin(); it != collision_result.contacts.end(); ++it)
      {
        ROS_INFO("Contact between: %s and %s", it->first.first.c_str(), it->first.second.c_str());
      }
    
      // Part5:手动指定在检查本体碰撞时的忽略link(就是哪些发生碰转了,检测时忽略它,也输出无碰撞)(ACM)
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      // Note also in this example how we are making copies of both the
      // allowed collision matrix and the current state and passing them in
      // to the collision checking function.
    
      collision_detection::AllowedCollisionMatrix acm = planning_scene.getAllowedCollisionMatrix();
      robot_state::RobotState copied_state = planning_scene.getCurrentState();
    
      collision_detection::CollisionResult::ContactMap::const_iterator it2;
      for (it2 = collision_result.contacts.begin(); it2 != collision_result.contacts.end(); ++it2)
      {
        acm.setEntry(it2->first.first, it2->first.second, true);//将当前发生碰撞的部分,存到acm中,然后后边再检测的时候会被忽略。
      }
      collision_result.clear();
      planning_scene.checkSelfCollision(collision_request, collision_result, copied_state, acm);
      ROS_INFO_STREAM("Test 6: Current state is " << (collision_result.collision ? "in" : "not in") << " self collision");
    
      // Part6!! 重要,同时检测机器人本体碰撞+机器人与环境发生碰撞情况!!!!常用!!
      //注意! 检查全部碰撞情况,使用 planning_scene.checkCollision
      collision_result.clear();
      planning_scene.checkCollision(collision_request, collision_result, copied_state, acm);
      ROS_INFO_STREAM("Test 7: Current state is " << (collision_result.collision ? "in" : "not in") << " self collision");
    
      // Part7 重要:检查当前机器人的约束情况(设定的约束条件)
      // ^^^^^^^^^^^^^^^^^^^
      //
      // The PlanningScene class also includes easy to use function calls
      // for checking constraints. The constraints can be of two types:
      // (a) constraints chosen from the
      // :kinematic_constraints:`KinematicConstraint` set:
      // i.e. :kinematic_constraints:`JointConstraint`,
      // :kinematic_constraints:`PositionConstraint`,
      // :kinematic_constraints:`OrientationConstraint` and
      // :kinematic_constraints:`VisibilityConstraint` and (b) user
      // defined constraints specified through a callback. We will first
      // look at an example with a simple KinematicConstraint.
      //
      // Checking Kinematic Constraints
      // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      //
      // We will first define a simple position and orientation constraint
      // on the end-effector of the panda_arm group of the Panda robot. Note the
      // use of convenience functions for filling up the constraints
      // (these functions are found in the :moveit_core_files:`utils.h<utils_8h>` file from the
      // kinematic_constraints directory in moveit_core).
    
      std::string end_effector_name = joint_model_group->getLinkModelNames().back();
    
      geometry_msgs::PoseStamped desired_pose;
      desired_pose.pose.orientation.w = 1.0;
      desired_pose.pose.position.x = 0.3;
      desired_pose.pose.position.y = -0.185;
      desired_pose.pose.position.z = 0.5;
      desired_pose.header.frame_id = "panda_link0";
      moveit_msgs::Constraints goal_constraint =
      //将被检查对象+目标点输入
      kinematic_constraints::constructGoalConstraints(end_effector_name, desired_pose);
    
      // Now, we can check a state against this constraint using the
      // isStateConstrained functions in the PlanningScene class.
    
      copied_state.setToRandomPositions();
      copied_state.update();
      bool constrained = planning_scene.isStateConstrained(copied_state, goal_constraint);
      ROS_INFO_STREAM("Test 8: Random state is " << (constrained ? "constrained" : "not constrained"));
    
      // There's a more efficient way of checking constraints (when you want
      // to check the same constraint over and over again, e.g. inside a
      // planner). We first construct a KinematicConstraintSet which
      // pre-processes the ROS Constraints messages and sets it up for quick
      // processing.
    
      kinematic_constraints::KinematicConstraintSet kinematic_constraint_set(kinematic_model);
      kinematic_constraint_set.add(goal_constraint, planning_scene.getTransforms());
      bool constrained_2 = planning_scene.isStateConstrained(copied_state, kinematic_constraint_set);
      ROS_INFO_STREAM("Test 9: Random state is " << (constrained_2 ? "constrained" : "not constrained"));
    
      // There's a direct way to do this using the KinematicConstraintSet
      // class.
    
      kinematic_constraints::ConstraintEvaluationResult constraint_eval_result =
          kinematic_constraint_set.decide(copied_state);
      ROS_INFO_STREAM("Test 10: Random state is "
                      << (constraint_eval_result.satisfied ? "constrained" : "not constrained"));
    
      // User-defined constraints
      // ~~~~~~~~~~~~~~~~~~~~~~~~
      //
      // CALL_SUB_TUTORIAL stateFeasibilityTestExample
    
      // Now, whenever isStateFeasible is called, this user-defined callback
      // will be called.
    
      planning_scene.setStateFeasibilityPredicate(stateFeasibilityTestExample);
      bool state_feasible = planning_scene.isStateFeasible(copied_state);
      ROS_INFO_STREAM("Test 11: Random state is " << (state_feasible ? "feasible" : "not feasible"));
    
      // Whenever isStateValid is called, three checks are conducted: (a)
      // collision checking (b) constraint checking and (c) feasibility
      // checking using the user-defined callback.
    
      bool state_valid = planning_scene.isStateValid(copied_state, kinematic_constraint_set, "panda_arm");
      ROS_INFO_STREAM("Test 12: Random state is " << (state_valid ? "valid" : "not valid"));
    
      // Note that all the planners available through MoveIt! and OMPL will
      // currently perform collision checking, constraint checking and
      // feasibility checking using user-defined callbacks.
      // END_TUTORIAL
    
      ros::shutdown();
      return 0;
    }
    

     

    展开全文
  • Java之碰撞检测

    2015-05-30 09:31:00
    碰撞检测是计算机图形学和虚拟现实中最基本且非常重要的组成部分。它主要应用于:虚拟制造、CAD/CAM、计算机动画、物理建模、三维游戏、飞机和汽车驾驭模拟、机器人、路径和运动规划、装配。 2.碰撞处理: 碰撞...
  • 碰撞检测是基于物理的动画,计算机辅助设计,计算机辅助制造,计算几何,虚拟现实,机器人等领域必须解决的关键 问题,目前仍是研究热点。非连续变形分析方法是一种较新的土木工程领域的数值模拟技术,可以分析不连续块体的...
  • 碰撞检测机器人生产线虚拟仿真过程中必不可少的一个步骤,通过碰撞检测,可以在机器人运动过程中动态检测与之发生碰撞干涉的设备,这样就可以对设计方案提出修改与优化建议,做到提前预知、规避设计风险。...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 222
精华内容 88
关键字:

机器人碰撞检测