MTC完成右臂抓取放置任务\\放置姿态设置

最新推荐文章于 2024-10-14 16:07:40 发布
最新推荐文章于 2024-10-14 16:07:40 发布
阅读量321 收藏
点赞数 2
分类专栏： 双臂 moveit2 文章标签： 机器人
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45762996/article/details/142304564
版权

MT

#include "mtc_tutorial/mtc_glass_bottle.hpp"
static const rclcpp::Logger LOGGER = rclcpp::get_logger("mtc_glass_right"); 

// 获取节点基础接口的实现
rclcpp::node_interfaces::NodeBaseInterface::SharedPtr MTCTaskNode_Right::getNodeBaseInterface()
{
  return node_->get_node_base_interface();
}

// 构造函数的实现，创建节点对象
MTCTaskNode_Right::MTCTaskNode_Right(const rclcpp::NodeOptions& options)
  : node_{ std::make_shared<rclcpp::Node>("mtc_right_node", options) }  // 初始化节点名称为 "mtc_node"
{
}

// 设置规划场景的实现
void MTCTaskNode_Right::setupPlanningScene()
{
  const double table_height = 1.02;
  std::string frame_id = "world";

  geometry_msgs::msg::PoseStamped bottlePose;
  bottlePose.header.frame_id = frame_id;
  bottlePose.pose.position.x = 0.3;
  bottlePose.pose.position.y = -0.5;
  bottlePose.pose.position.z = table_height;
  bottlePose.pose.orientation.w = 1.0;

  geometry_msgs::msg::PoseStamped glassPose;
  glassPose.header.frame_id = frame_id;
  glassPose.pose.position.x = -0.6;
  glassPose.pose.position.y = -0.5;
  glassPose.pose.position.z = table_height;
  glassPose.pose.orientation.w = 1.0;

  // center of table surface 
  geometry_msgs::msg::PoseStamped tabletopPose;
  tabletopPose.header.frame_id = frame_id;
  tabletopPose.pose.position.x = 0;
  tabletopPose.pose.position.y = -0.25;
  tabletopPose.pose.position.z = table_height;
  tabletopPose.pose.orientation.w = 1.0;
  

  // 创建规划场景接口并将碰撞对象添加到场景中
  mtc_pour::cleanup();
  moveit::planning_interface::PlanningSceneInterface psi;
  std::vector<moveit_msgs::msg::CollisionObject> objs;
  mtc_pour::setupTable(objs, tabletopPose);
  mtc_pour::setupObjects(objs, bottlePose, glassPose,
                          "package://mtc_pour/meshes/small_bottle.stl");
  psi.applyCollisionObjects(objs);
}

// 执行任务的实现
void MTCTaskNode_Right::doTask()
{
  task_ = createTask();  // 创建任务

  // 尝试初始化任务
  try
  {
    task_.init();  // 初始化任务
  }
  catch (mtc::InitStageException& e)  // 捕获初始化失败的异常
  {
    RCLCPP_ERROR_STREAM(LOGGER, e);  // 打印错误信息
    return;
  }

  // 规划任务路径，最大规划尝试次数为 5
  if (!task_.plan(10))
  {
    RCLCPP_ERROR_STREAM(LOGGER, "Task planning failed");  // 打印任务规划失败的日志
    return;
  }
  
  // 发布任务解决方案以供检查
  task_.introspection().publishSolution(*task_.solutions().front());

  // 执行规划的解决方案
  auto result = task_.execute(*task_.solutions().front());
  if (result.val != moveit_msgs::msg::MoveItErrorCodes::SUCCESS)
  {
    RCLCPP_ERROR_STREAM(LOGGER, "Task execution failed");  // 执行失败的错误日志
    return;
  }

  return;
}

// 创建任务的实现
mtc::Task MTCTaskNode_Right::createTask()
{
  mtc::Task task;  // 创建一个 MTC 任务对象
  task.stages()->setName("grabbing the glass on the right");  // 为任务命名
  task.loadRobotModel(node_);  // 加载机器人模型

  // 定义机器人操作相关的参数
  // const auto& left_arm_group_name = "left_ur_manipulator";  // 机械臂的操作组名称
  // const auto& left_hand_group_name = "left_robotiq_2f_85_gripper";  // 手部操作组名称
  // const auto& left_hand_frame = "left_robotiq_85_base_link";  // 机械手的坐标系

  const auto& right_arm_group_name = "right_ur_manipulator";  // 机械臂的操作组名称
  const auto& right_hand_group_name = "right_robotiq_2f_85_gripper";  // 手部操作组名称
  const auto& right_hand_frame = "right_grasp_point";  // 机械手的坐标系

  // 设置任务的属性
  task.setProperty("group", right_arm_group_name);
  task.setProperty("eef", "right_robotiq_2f_85_gripper_ee");
  task.setProperty("ik_frame", right_hand_frame);

  // 忽略未使用变量的编译器警告
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
  mtc::Stage* current_state_ptr = nullptr;  // 将current_stage传递给grasp pose generator
#pragma GCC diagnostic pop

  // 创建并添加获取当前状态的阶段
  auto stage_state_current = std::make_unique<mtc::stages::CurrentState>("right-current");
  current_state_ptr = stage_state_current.get();
  task.add(std::move(stage_state_current));  // 添加当前状态阶段到任务中

  // 创建不同的规划器
  auto sampling_planner = std::make_shared<mtc::solvers::PipelinePlanner>(node_);  // 创建采样规划器
  auto interpolation_planner = std::make_shared<mtc::solvers::JointInterpolationPlanner>();  // 创建插值规划器

  // 创建笛卡尔路径规划器，并设置最大速度和加速度
  auto cartesian_planner = std::make_shared<mtc::solvers::CartesianPath>();
  cartesian_planner->setMaxVelocityScalingFactor(1.0);  // 设置最大速度缩放因子为 1.0
  cartesian_planner->setMaxAccelerationScalingFactor(1.0);  // 设置最大加速度缩放因子为 1.0
  cartesian_planner->setStepSize(.01);  // 设置步长为 0.01

  // 创建并添加手部动作的阶段（打开手）
  auto stage_open_right_hand =
      std::make_unique<mtc::stages::MoveTo>("open right_hand", interpolation_planner);  // 创建移动到目标状态的阶段
  stage_open_right_hand->setGroup(right_hand_group_name);  // 设置操作组为手部
  stage_open_right_hand->setGoal("right_open");  // 设置手部打开的目标状态
  task.add(std::move(stage_open_right_hand));  // 将阶段添加到任务中
  
  // Add the next lines of codes to define more stages here
  auto stage_move_to_pick_right = std::make_unique<mtc::stages::Connect>(
    "move to pick-right",
    mtc::stages::Connect::GroupPlannerVector{{right_arm_group_name,sampling_planner}});
  stage_move_to_pick_right->setTimeout(5.0);
  stage_move_to_pick_right->properties().configureInitFrom(mtc::Stage::PARENT);
  task.add(std::move(stage_move_to_pick_right));

  mtc::Stage* attach_object_stage_right = nullptr;// Forward attach_object_stage  to place pose generator
  {
    auto grasp_right = std::make_unique<mtc::SerialContainer>("pick glass-right");
    task.properties().exposeTo(grasp_right->properties(),{"eef","group","ik_frame"});
    grasp_right->properties().configureInitFrom(mtc::Stage::PARENT,{"eef","group","ik_frame"});

    {
      auto stage = std::make_unique<mtc::stages::MoveRelative>("approach glass-right",cartesian_planner);
      stage->properties().set("marker_ns","approach_glass-right");
      stage->properties().set("link",right_hand_frame);// TODO:猜测这是与物体发生接触的link
      stage->properties().configureInitFrom(mtc::Stage::PARENT,{"group"});
      stage->setMinMaxDistance(0.05,0.15);
      // Set hand forward direction
      geometry_msgs::msg::Vector3Stamped vec;
      vec.header.frame_id = right_hand_frame;
      vec.vector.z =1.0;
      stage->setDirection(vec);
      grasp_right->insert(std::move(stage));
    }

    {
      //Sample grasp pose
      auto stage = std::make_unique<mtc::stages::GenerateGraspPose>("generate grasp pose -right");
      stage->properties().configureInitFrom(mtc::Stage::PARENT);
      stage->properties().set("marker_ns","grasp_pose-right");
      stage->setPreGraspPose("right_open");
      stage->setObject("glass");
      stage->setAngleDelta(M_PI / 12);
      stage->setMonitoredStage(current_state_ptr);//Hook into current state

      Eigen::Isometry3d grasp_frame_transform_right;
      
      //末端执行器坐标系的Z轴朝向杯子的X轴，末端执行器坐标系的X轴朝向杯子的Y轴，末端执行器坐标系的Y轴朝向杯子的Z轴
      Eigen::Quaterniond q = Eigen:: AngleAxisd(-M_PI/2,Eigen::Vector3d::UnitY())*
                            Eigen::AngleAxisd(-M_PI/2,Eigen::Vector3d::UnitX());
      
      // //末端执行器坐标系的Y轴朝向杯子的X轴，末端执行器坐标系的X轴朝向杯子的Y轴,末端执行器坐标系的Z轴朝向杯子的-Z轴
      // Eigen::Quaterniond q = Eigen:: AngleAxisd(M_PI/2,Eigen::Vector3d::UnitZ())*
      //                       Eigen::AngleAxisd(-M_PI,Eigen::Vector3d::UnitX());

      grasp_frame_transform_right.linear() = q.matrix();
      grasp_frame_transform_right.translation().z()=0;


      // Compute IK
      // 将stage对象的所有权转移给wrapper_right
      // wrapper 通常指的是一层封装，用于将某个功能或一组功能封装起来，
      auto wrapper = std::make_unique<mtc::stages::ComputeIK>("grasp pose IK - right",std::move(stage));
      wrapper->setMaxIKSolutions(8);
      wrapper->setMinSolutionDistance(1.0);
      wrapper->setIKFrame(grasp_frame_transform_right,right_hand_frame);
      wrapper->properties().configureInitFrom(mtc::Stage::PARENT,{"eef","group"});
      wrapper->properties().configureInitFrom(mtc::Stage::INTERFACE,{"target_pose"});
      grasp_right->insert(std::move(wrapper));
    }

    {
      auto stage = 
          std::make_unique<mtc::stages::ModifyPlanningScene>("allow collision (hand,object) - right");
      stage->allowCollisions("glass",
                              task.getRobotModel()
                              ->getJointModelGroup(right_hand_group_name)
                              ->getLinkModelNamesWithCollisionGeometry(),
                              true);
      grasp_right->insert(std::move(stage));
    }

    {
      auto stage = std::make_unique<mtc::stages::MoveTo>("close hand-right",interpolation_planner);
      stage->setGroup(right_hand_group_name);
      stage->setGoal("right_close");
      grasp_right->insert(std::move(stage));
    }

    {
      auto stage = std::make_unique<mtc::stages::ModifyPlanningScene>("attcah object - right");
      stage->attachObject("glass",right_hand_frame);
      attach_object_stage_right = stage.get();
      grasp_right->insert(std::move(stage));
    }

    {
      auto stage = std::make_unique<mtc::stages::MoveRelative>("lift object - right",cartesian_planner);
      stage->properties().configureInitFrom(mtc::Stage::PARENT,{"group"});
      stage->setMinMaxDistance(0.1,0.3);
      stage->setIKFrame(right_hand_frame);
      stage->properties().set("marker_ns","lift_object_right");

      // Set upward direction
      geometry_msgs::msg::Vector3Stamped vec;
      vec.header.frame_id = "dual_base";
      vec.vector.y = 1.0;
      stage->setDirection(vec);
      grasp_right->insert(std::move(stage));
    }

    task.add(std::move(grasp_right));  
  }

  {
    auto stage_move_to_place_right = std::make_unique<mtc::stages::Connect>(
      "move to place -right",
      mtc::stages::Connect::GroupPlannerVector{{right_arm_group_name,sampling_planner},
                                              {right_hand_group_name,sampling_planner} });
    stage_move_to_place_right->setTimeout(5.0);
    stage_move_to_place_right->properties().configureInitFrom(mtc::Stage::PARENT);
    task.add(std::move(stage_move_to_place_right));
  }

  {
    auto place_right = std::make_unique<mtc::SerialContainer>("place object -right");
    task.properties().exposeTo(place_right->properties(),{"eef","group","ik_frame"});
    place_right->properties().configureInitFrom(mtc::Stage::PARENT,
                                              {"eef","group","ik_frame"});

    // {
    //   //Sample place pose
    //   auto stage = std::make_unique<mtc::stages::GeneratePlacePose>("generate place pose");
    //   stage->properties().configureInitFrom(mtc::Stage::PARENT);
    //   stage->properties().set("marker_ns","place_pose_right");
    //   stage->setObject("glass");

    //   geometry_msgs::msg::PoseStamped target_pose_msg_right;
    //   target_pose_msg_right.header.frame_id = "dual_base";
    //   target_pose_msg_right.pose.position.x = -0.5;
    //   target_pose_msg_right.pose.position.y = -0.5;
    //   target_pose_msg_right.pose.position.z = 0.55;
    //   tf2::Quaternion qtn;
    //   qtn.setRPY(0.0,0.0,-1.57);
    //   target_pose_msg_right.pose.orientation.x = qtn.x();
    //   target_pose_msg_right.pose.orientation.y = qtn.y();
    //   target_pose_msg_right.pose.orientation.z = qtn.z();
    //   target_pose_msg_right.pose.orientation.w = qtn.w();
    //   stage->setPose(target_pose_msg_right);
    //   stage->setMonitoredStage(attach_object_stage_right); //Hook into attach_object_stage

    //   // Compute IK
    //   auto wrapper = std::make_unique<mtc::stages::ComputeIK>("place pose IK",std::move(stage));
    //   wrapper->setMaxIKSolutions(2);
    //   wrapper->setMinSolutionDistance(1.0);
    //   wrapper->setIKFrame("glass");
    //   wrapper->properties().configureInitFrom(mtc::Stage::PARENT,{"eef","group"});
    //   wrapper->properties().configureInitFrom(mtc::Stage::INTERFACE,{"target_pose"});
    //   place_right->insert(std::move(wrapper));

    //  }

    //  {
    //     //Sample place pose
    //     auto stage = std::make_unique<mtc::stages::GeneratePlacePose>("generate place pose -right");
    //     stage->properties().configureInitFrom(mtc::Stage::PARENT);
    //     stage->properties().set("marker_ns","place_pose_right");
    //     stage->setObject("glass");

    //     // 定义放置位姿
    //     geometry_msgs::msg::PoseStamped target_pose_msg_right;
    //     target_pose_msg_right.header.frame_id = "dual_base";
    //     target_pose_msg_right.pose.position.x = -0.5;
    //     target_pose_msg_right.pose.position.y = 0.5;
    //     target_pose_msg_right.pose.position.z = 0.2;
    //     tf2::Quaternion qtn;
    //     qtn.setRPY(0.0, 0.0, -M_PI );  // 将RPY角度转换成四元数
    //     target_pose_msg_right.pose.orientation.x = qtn.x();
    //     target_pose_msg_right.pose.orientation.y = qtn.y();
    //     target_pose_msg_right.pose.orientation.z = qtn.z();
    //     target_pose_msg_right.pose.orientation.w = qtn.w();
    //     stage->setPose(target_pose_msg_right);

    //     stage->setMonitoredStage(attach_object_stage_right); //Hook into attach_object_stage

    //     // 定义放置时的末端执行器坐标系变换
    //     Eigen::Isometry3d place_frame_transform_right;
    //     Eigen::Quaterniond q = Eigen::AngleAxisd(-M_PI / 2, Eigen::Vector3d::UnitY()) *
    //                           Eigen::AngleAxisd(-M_PI / 2, Eigen::Vector3d::UnitX());
    //     place_frame_transform_right.linear() = q.matrix();
    //     place_frame_transform_right.translation().z() = 0;

    //     // 计算IK
    //     auto wrapper = std::make_unique<mtc::stages::ComputeIK>("place pose IK - right", std::move(stage));
    //     wrapper->setMaxIKSolutions(8); // 设置最大解的数量
    //     wrapper->setMinSolutionDistance(1.0);
    //     wrapper->setIKFrame(place_frame_transform_right, right_hand_frame);
    //     wrapper->properties().configureInitFrom(mtc::Stage::PARENT, {"eef", "group"});
    //     wrapper->properties().configureInitFrom(mtc::Stage::INTERFACE, {"target_pose"});
    //     place_right->insert(std::move(wrapper));
    // }

      {
      // Sample place pose
      auto stage = std::make_unique<mtc::stages::GeneratePlacePose>("generate place pose -right");
      stage->properties().configureInitFrom(mtc::Stage::PARENT);
      stage->properties().set("marker_ns", "place_pose_right");
      stage->setObject("glass");

      // 定义放置位姿
      geometry_msgs::msg::PoseStamped target_pose_msg_right;
      target_pose_msg_right.header.frame_id = "dual_base";
      target_pose_msg_right.pose.position.x = -0.3;
      target_pose_msg_right.pose.position.y = -0.5;
      target_pose_msg_right.pose.position.z = 0.3;

      // 计算放置位姿的正确姿态
      Eigen::Quaterniond q_place = Eigen::AngleAxisd(-M_PI / 2, Eigen::Vector3d::UnitZ())*
                                  Eigen::AngleAxisd(0, Eigen::Vector3d::UnitX());
      Eigen::Quaterniond q_object = q_place.inverse();

      tf2::Quaternion qtn(q_object.x(), q_object.y(), q_object.z(), q_object.w());
      target_pose_msg_right.pose.orientation = tf2::toMsg(qtn);

      stage->setPose(target_pose_msg_right);
      stage->setMonitoredStage(attach_object_stage_right); // Hook into attach_object_stage

      // 设置 IK 框架，与抓取阶段一致
      Eigen::Isometry3d place_frame_transform_right;
      place_frame_transform_right.linear() = q_place.toRotationMatrix();
      place_frame_transform_right.translation().z() = 0;

      // 计算 IK
      auto wrapper = std::make_unique<mtc::stages::ComputeIK>("place pose IK - right", std::move(stage));
      wrapper->setMaxIKSolutions(8); // 设置最大解的数量
      wrapper->setMinSolutionDistance(1.0);
      wrapper->setIKFrame(place_frame_transform_right, right_hand_frame);
      wrapper->properties().configureInitFrom(mtc::Stage::PARENT, { "eef", "group" });
      wrapper->properties().configureInitFrom(mtc::Stage::INTERFACE, { "target_pose" });
      place_right->insert(std::move(wrapper));
  }

    


    {
      auto stage = std::make_unique<mtc::stages::MoveTo>("open hand-right",interpolation_planner);
      stage->setGroup(right_hand_group_name);
      stage->setGoal("right_open");
      place_right->insert(std::move(stage));
    }

    {
    auto stage = std::make_unique<mtc::stages::ModifyPlanningScene>("forbid collision (hand,object)-right");
    stage->allowCollisions("glass",
                            task.getRobotModel()
                                 ->getJointModelGroup(right_hand_group_name)
                                 ->getLinkModelNamesWithCollisionGeometry(),
                                 false);
    place_right->insert(std::move(stage));
    }

    {
      auto stage = std::make_unique<mtc::stages::ModifyPlanningScene>("detach object-right");
      stage->detachObject("glass",right_hand_frame);
      place_right->insert(std::move(stage));
    }

    {
      auto stage = std::make_unique<mtc::stages::MoveRelative>("retreat -right",cartesian_planner);
      stage->properties().configureInitFrom(mtc::Stage::PARENT,{"group"});
      stage->setMinMaxDistance(0.1,0.3);
      stage->setIKFrame(right_hand_frame);
      stage->properties().set("marker_ns","retreat-right");

      // Set retreat direction
      geometry_msgs::msg::Vector3Stamped vec;
      vec.header.frame_id = "world";
      vec.vector.z=0.5;
      stage->setDirection(vec);
      place_right->insert(std::move(stage));
    }

    task.add(std::move(place_right));
  }

  {
    auto stage = std::make_unique<mtc::stages::MoveTo>("return home -right",interpolation_planner);
    stage->properties().configureInitFrom(mtc::Stage::PARENT,{"group"});
    stage->setGoal("right_home");
    task.add(std::move(stage));
  }

  // Stages all added to the task above this line
  return task;  // 返回创建的任务
}
课堂随想
关注
专栏目录
python抓取网站访客手机号_电商 生意参谋 抓取 访客数据 Python版
weixin_39536728的博客
12-08 1117
import requestsimport jsonimport pandas as pdimport time# getRtVisitor.jsonsession = requests.Session() # 创建一个session对象headers = {'accept':'*/*','accept-encoding':'gzip, deflate, br','accept-language...
秘鲁MTC认证
EU15302623341的博客
12-08 927
秘鲁MTC认证 MTC转证 秘鲁无线认证
三、使用MoveIt Task Constructor完成机械臂拾取与放置
weixin_56773716的博客
08-13 1276
定义MTCTaskNode类，并在类中声明成员函数包括构造函数public:private:成员函数实现，定义 getter 函数来获取节点基础接口使用指定的选项初始化节点此类方法用于设置规划场景，创建一个圆柱体，并设置尺寸和位置。如果放置在工作空间外，规划将失败doTask函数与MTC对象交互。首先创建一个任务，包括设置属性和添加阶段。接下来初始化任务并生成规划，找到5个成功的解后规划停止。
SPL MTC MK2新一代监听控制器已发布
PrettySound的博客
06-01 223
这款经典产品如今也迎来了更新换代，使其更加迎合现代音乐制作环境的需求。 信号源和扬声器选择、多种监听模式、优质对讲系统和带有SPL独家的Phonitor Matrix（模拟音箱声场）的耳机放大器，使成为监听控制器中新的“演播室标准“。 点击阅读全文：https://www.prettysound.net/blog/spl-mtc-mk2-xin-yi-dai-jian-ting-kong-zhi-qi-yi-fa-bu.html
mtc系统数据服务器,一种MTC系统的机器业务数据上传方法和系统
weixin_42640271的博客
08-12 499
具体实施方式下面结合附图和具体实施例对本发明的技术方案进一步详细阐述。本发明MTC系统的机器业务数据上传方案的主要思想是：网络侧设备向机器终端发送单向无应答信令，机器终端接收到该单向无应答信令后，无须向网络侧设备返回针对该信令的上行应答，也无须建立RRC连接，直接向网络侧设备上传机器业务数据。如图1所示，本发明MTC系统的机器业务数据上传方法的流程包括以下步骤：步骤101，网络侧设备向特定的机器终...
#96_MTC enhancement
withzhumin的博客
03-11 507
一、相关通信知识 1. 锚载波： Anchor carrier用以发送NPSS/NSSS/NPBCH/SIB-NB， 另外寻呼消息和随机接入过程也只能在AnchorCarrier上进行。 2. 寻呼过程 寻呼过程：网络侧在特定的时刻向UE发送寻呼消息，通知UE执行相应的操作或者更新相关的参数。寻呼可以让eNB控制UE监听P-RNTI加扰的PDCCH子帧。寻呼过程适用于RRC空闲态的UE和RRC连接...
【Moveit2官方教程】使用 MoveIt Task Constructor (MTC) 框架来定义和执行一个机器人任务
qq_45762996的博客
09-07 1126
定义一个用于输出日志的 ROS 2 日志器，名称为。
【MTC拾取放置示例】将Connect中的最大目标偏差检查增加到1e-2,实现move to pick/move to place
qq_45762996的博客
09-10 407
在运行Moveit2使用MTC构建拾取放置示例的时候出现报错。
mtu设置失败_为什么华为路由器修改MTU值失败
weixin_35843812的博客
12-31 1694
MTU是MaximumTransmissionUnit的缩写，它是网络上传输的最大数据包. 大多数网络设备的MTU为1500，MTU的单位为字节. 如果本机的MTU大于网关的MTU，则会分解较大的数据包以进行传输，这将生成大量的数据包碎片，增加数据包丢失率，并降低网络速度.将本机的MTU设置为小于或等于网关的MTU，以减少数据包丢失. MTU是指可以通过通信协议的特定层的最大数据包大小和最大传输...
MTC.zip_MTc
09-14
**MTC技术详解与湖南高速公路一体化费显功能测试** MTC，全称为Manual Toll Collection，中文译为“人工收费系统”，是高速公路收费的一种传统方式。它主要依赖于人工操作，驾驶员在收费站停车，由收费员完成收费...
mtc.rar_MTc
09-14
MTc描述中的“操作容易”表明它可能有直观的用户界面，简单的设置步骤，以及良好的兼容性，使其能在不同环境下快速部署。 总的来说，MTc远程屏幕监视程序是软件开发领域的优秀实践案例，它集成了网络通信、图像处理...
mtc.rar_mtc.jsp_mtc.jsp页面_mtc程序_如何查找mtc.jsp
09-24
　远程连接建立成功后，这个程序 可以完成文件的增、删、改名等以及打包下载；可以使用Win下的"命令提示符"终端命令进行服务器重启等操作；可以远程桌面、查看运行的程序的状态，并终止已停止响应的程序、启动、停止...
mtc.rar_MTc_jsp_jsp 文件管理_mtc.jsp_文件管理
09-23
"mtc.rar_MTc_jsp_jsp 文件管理_mtc.jsp_文件管理" 这个标题提到了几个关键元素。首先，“mtc.rar”是一个压缩文件，通常包含了一个项目或软件的源代码和其他相关文件。接着，“MTc_jsp”可能指的是一个基于JSP...
mtc.zip_mtc.jsp
09-24
1.跨平台,基本WEB服务,无论防火强怎么封端口,只要打开80,就可以远程管理服务器. 2.客户端无论安装任何插件. 3.只有一个JSP文件,文件名可以随意...4.任务管理: 可以查看正在运行的程序的状态，并终止已停止响应的程序
从MDM、RobotMDM到UCSD的Exbody——人体运动扩散模型：赋能机器人的训练
结构之法 算法之道
10-11 1703
22年9月，来自TAU的研究者们通过此篇论文《》提出了运动扩散模型MDM，在该文中，作者通过在无分类器的方式下对CLIP进行条件化来实现文本到动作的转换，类似于文本到图像如下图所示「运动扩散模型（MDM）通过在给定文本提示的情况下生成多样化的动作，反映了文本到动作映射的多对多特性，其中，较深的颜色表示序列中的较晚帧，即最后生成的帧。
安装基于ROS2的机器人仿真和控制所需的ROS2软件包
qq_45762996的博客
10-14 298
【代码】安装基于ROS2的机器人仿真和控制所需的ROS2软件包。
智能巡检机器人与智慧运维系统的结合应用
配电房综合监控
10-12 982
传统配电运维面临诸多难题。首先，劳动强度大，运维人员需要手持终端设备对配电站室内环境、电气设备上的各个仪器仪表参量等进行定时巡视，工作繁琐且易疲劳。其次，效率低下，巡查间隔时间较长，不能及时发现设备运行的所有潜在威胁。再者，人员短缺问题突出，配电运维一方面需要工程师具备一定的专业资质和技能，同时由于非生产部门编制又常常面临不足的情况，很多管理措施难以落实。而且人员培训困难，人员流动频繁，导致配电室信息随着人员的变更与交替，越来越模糊。
基于STM32的智能运输机器人设计
2401_84204806的博客
10-12 1308
通过本项目，我们成功设计了一个基于 STM32 的智能运输机器人，实现了避障、路径跟踪、远程控制和状态显示等功能。本项目设计了一个基于STM32的智能运输机器人，能够自动识别路径、避开障碍物，并根据用户的指令将物品运输到指定地点。该机器人集成了超声波传感器、红外传感器、无线通信模块等，通过STM32对电机的控制，实现平稳、智能的运输功能。在生成的项目基础上，编写避障逻辑、路径跟踪、无线控制、电机控制以及状态显示的代码。问题讨论，stm32的资料领取可以私信！⬇帮大家整理了单片机的资料。
双足机器人远程操作与动态运动同步研究
最新发布
CubeMars的博客
10-14 285
操作员的动作通过传感器捕捉并转化为机器人可理解的指令。这一研究成果展示了将人类运动智能与机器人控制相结合的潜力，为双足机器人在实际应用中的能力提升提供了新的思路。随着技术的进步，研究者们致力于开发能够与人类操作员实现高效同步的双足机器人，特别是在应对自然灾害或人为危险等紧急情况下的应用。2.反馈力控制：在机器人执行动作时，通过提供反馈力，使操作员能够感知机器人与自身运动的同步程度。1.实时运动数据映射：将操作员的运动数据实时缩放至机器人所需的比例，以确保机器人能够按照操作员的动作进行适当的反应。
74VHC125MTC逻辑门集成电路详尽指南
不同封装类型的74VHC125MTC在物理尺寸上会有所不同，手册中通常会提供封装外形图和尺寸表，这样用户在设计印刷电路板（PCB）时可以准确地放置和布线。 9. 替代型号 数据手册也可能列出一些功能相似的替代型号供用户...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值