基于ROS的18届中航杯比赛流程实现

最新推荐文章于 2024-04-08 08:40:28 发布
最新推荐文章于 2024-04-08 08:40:28 发布
阅读量680 收藏 4
点赞数 2
分类专栏： ROS_PX4 仿真
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31736703/article/details/80147402
版权

用ROS写了个状态机，感觉流程上还可以改进，接下来优化一下

#include <ros/ros.h>
#include <geometry_msgs/PoseStamped.h>
#include <mavros_msgs/CommandBool.h>
#include <mavros_msgs/SetMode.h>
#include <mavros_msgs/State.h>
#include <geometry_msgs/TwistStamped.h>
#include <string>
#include <sstream>
#include <iostream>
#include <serial/serial.h>
#include <std_msgs/String.h>
#include <std_msgs/UInt32.h>

控制器实现

#define Err_Limit_Flag 0
#define Integrate_Separation_Flag 0
#define Integrate_Limit_Flag 0
typedef struct
{
    float Expect; 
    float FeedBack;
    float Err;
    float Last_Err; 
    float Err_Max;
    Integrate_Separation_Err; 
    float Integrate; 
    float Integrate_Max; 
    float Kp;
    float Ki;
    float Kd;
    float Control_OutPut; 
    float Last_Control_OutPut; 
    float Control_OutPut_Limit; 

    float Last_FeedBack; 
    float Dis_Err; 
    float Dis_Error_History[5]; 
}PID_Controler;

float PID_Control(PID_Controler *Controler)
{
     
    Controler->Last_Err = Controler->Err; 
    Controler->Err = Controler->Expect - Controler->FeedBack; 
    if(Err_Limit_Flag == 1) {        
    if(Controler->Err >= Controler->Err_Max)   Controler->Err = Controler->Err_Max;
        if(Controler->Err <= -Controler->Err_Max)  Controler->Err = -Controler->Err_Max;
    }
     
    if(Integrate_Separation_Flag==1) { 
        if(fabs(Controler->Err) <= Controler->Integrate_Separation_Err)//abs->int fabs->float
            Controler->Integrate += Controler->Ki * Controler->Err;
    }
    else {
        Controler->Integrate += Controler->Ki * Controler->Err;
    }
     
    if(Integrate_Limit_Flag==1) { 
        if(Controler->Integrate >= Controler->Integrate_Max)
            Controler->Integrate = Controler->Integrate_Max;
         if(Controler->Integrate <= -Controler->Integrate_Max)
            Controler->Integrate = -Controler->Integrate_Max ;
    }
    
    Controler->Last_Control_OutPut = Controler->Control_OutPut; 
    Controler->Control_OutPut = Controler->Kp * Controler->Err//P 
                              + Controler->Integrate//I
                              + Controler->Kd*(Controler->Err-Controler->Last_Err);//D
    
    if(Controler->Control_OutPut >= Controler->Control_OutPut_Limit)
        Controler->Control_OutPut = Controler->Control_OutPut_Limit;
    if(Controler->Control_OutPut <= -Controler->Control_OutPut_Limit)
        Controler->Control_OutPut = -Controler->Control_OutPut_Limit;
    
    return Controler->Control_OutPut;
}
PID_Controler pos_pid_x;
PID_Controler pos_pid_y;
PID_Controler pos_pid_z;

回调函数

mavros_msgs::State current_state;
void state_cb(const mavros_msgs::State::ConstPtr& msg){
    current_state = *msg;
}
geometry_msgs::PoseStamped current_local_pos;
void local_pos_cb(const geometry_msgs::PoseStamped::ConstPtr& msg){
    current_local_pos = *msg;
}

主函数

int main(int argc, char **argv)
{
    ros::init(argc, argv, "holdheight");
    ros::NodeHandle nh;
    
    ros::Subscriber state_sub = nh.subscribe<mavros_msgs::State>
            ("mavros/state", 10, state_cb);
    
    ros::Publisher set_local_pos_pub = nh.advertise<geometry_msgs::PoseStamped>
            ("mavros/setpoint_position/local", 10);
    
    ros::Subscriber local_pos_pub = nh.subscribe<geometry_msgs::PoseStamped>
            ("mavros/local_position/pose", 10, local_pos_cb);
    ros::ServiceClient arming_client = nh.serviceClient<mavros_msgs::CommandBool>
            ("mavros/cmd/arming");
    
    ros::ServiceClient set_mode_client = nh.serviceClient<mavros_msgs::SetMode>
            ("mavros/set_mode");
    
    ros::Publisher velocity_pub = nh.advertise<geometry_msgs::TwistStamped>
            ("mavros/setpoint_velocity/cmd_vel", 10);
    
    ros::Publisher dis_pub = nh.advertise<std_msgs::UInt32>("absorb_cmd", 1);

    std::string cmd_port_name("/dev/ttyACM0");
    try
    {
        absorb_cmd.setPort(cmd_port_name);/* code for Try */
        absorb_cmd.setBaudrate(115200);
        serial::Timeout to = serial::Timeout::simpleTimeout(1000);
        absorb_cmd.setTimeout(to);
        absorb_cmd.open();
    }
    catch (serial::IOException& e)
    {
       ROS_ERROR_STREAM("Unable to open port "); 
       return -1;  /* code for Catch */
    }

    ros::Rate rate(20.0);
    // wait for FCU connection
    while(ros::ok() && current_state.connected){
        ros::spinOnce();
        rate.sleep();
    }

    /******x_pid参数(float)******/
    pos_pid_x.Kp = 1.0;
    pos_pid_x.Kd = 0.0;
    pos_pid_x.Ki = 0.0;
    pos_pid_x.Err_Max = 50.0;
    pos_pid_x.Integrate_Max = 10.0;
    pos_pid_x.Integrate_Separation_Err = 100.0;
    pos_pid_x.Control_OutPut_Limit = 2;

    /******y_pid参数(float)******/
    pos_pid_y.Kp = 1.0;
    pos_pid_y.Kd = 0.0;
    pos_pid_y.Ki = 0.0;
    pos_pid_y.Err_Max = 50.0;
    pos_pid_y.Integrate_Max = 10.0;
    pos_pid_y.Integrate_Separation_Err = 100.0;
    pos_pid_y.Control_OutPut_Limit = 2;

    /******z_pid参数(float)******/
    pos_pid_z.Kp = 0.5;
    pos_pid_z.Kd = 0.0;
    pos_pid_z.Ki = 0.0;
    pos_pid_z.Err_Max = 50.0;
    pos_pid_z.Integrate_Max = 10.0;
    pos_pid_z.Integrate_Separation_Err = 100.0;
    pos_pid_z.Control_OutPut_Limit = 0.6;
  


    //设置起飞点，抓箱点，放箱点
    geometry_msgs::PoseStamped pose;
    geometry_msgs::PoseStamped takeoff_pos;
    geometry_msgs::PoseStamped target1;
    geometry_msgs::PoseStamped target2;
    takeoff_pos.pose.position.x = 0.0;
    takeoff_pos.pose.position.y = 0.0;
    takeoff_pos.pose.position.z = 2.5;
    target1.pose.position.x = 10.0;
    target1.pose.position.y = 0.0;
    target1.pose.position.z = 2.5;
    target2.pose.position.x = 10.0;
    target2.pose.position.y = 10.0;
    target2.pose.position.z = 2.5;

    mavros_msgs::SetMode offb_set_mode;
    offb_set_mode.request.custom_mode = "OFFBOARD";
    mavros_msgs::CommandBool arm_cmd;
    arm_cmd.request.value = true;
    int state = 1;
    int cnt = 3;//搬运次数
    //注：把自动解锁自动切外部控制放在循环外可避免切不回手动
    
    ros::Time last_request = ros::Time::now();
    //状态机
     while(ros::ok() && state == 1) {
    //自动解锁切offb
     /*       if( !current_state.armed ) {
        if( arming_client.call(arm_cmd) &&
              arm_cmd.response.success) {
            ROS_INFO("Vehicle armed");
        }
    }
    if( current_state.mode != "OFFBOARD") {
        if( set_mode_client.call(offb_set_mode) &&
                offb_set_mode.response.success) {
            ROS_INFO("Offboard enabled");
        }
    } */
        ROS_INFO_STREAM("state = " << state);

        pos_pid_x.Expect = takeoff_pos.pose.position.x;
        pos_pid_y.Expect = takeoff_pos.pose.position.y;
        pos_pid_z.Expect = takeoff_pos.pose.position.z;
        pos_pid_x.FeedBack = current_local_pos.pose.position.x;
        pos_pid_y.FeedBack = current_local_pos.pose.position.y;
        pos_pid_z.FeedBack = current_local_pos.pose.position.z;
        geometry_msgs::TwistStamped velocity_tw;
        velocity_tw.twist.linear.x = PID_Control(&pos_pid_x);
        velocity_tw.twist.linear.y = PID_Control(&pos_pid_y);
        velocity_tw.twist.linear.z = PID_Control(&pos_pid_z);
        ROS_INFO("%f %f %f" ,pos_pid_x.Expect ,pos_pid_y.Expect ,pos_pid_z.Expect);
        ROS_INFO("%f %f %f" ,current_local_pos.pose.position.x ,current_local_pos.pose.position.y ,current_local_pos.pose.position.z);
        ROS_INFO("%f %f %f" ,pos_pid_x.FeedBack ,pos_pid_y.FeedBack ,pos_pid_z.FeedBack);
        ROS_INFO("%f %f %f" ,pos_pid_x.Err ,pos_pid_y.Err ,pos_pid_z.Err);
        ROS_INFO("%f %f %f" ,PID_Control(&pos_pid_x) ,PID_Control(&pos_pid_y) ,PID_Control(&pos_pid_z));
        velocity_pub.publish(velocity_tw);
        if(pos_pid_z.Err < 0.15) {
           state++;
        }
        ros::spinOnce();
        rate.sleep();
    }
    while(cnt--) {
        //到搬运点
        last_request = ros::Time::now();
        while(ros::ok() && state == 2) {
            ROS_INFO_STREAM("state = " << state);
            pos_pid_x.Expect = target1.pose.position.x;
            pos_pid_y.Expect = target1.pose.position.y;
            pos_pid_z.Expect = target1.pose.position.z;
            pos_pid_x.FeedBack = current_local_pos.pose.position.x;
            pos_pid_y.FeedBack = current_local_pos.pose.position.y;
            pos_pid_z.FeedBack = current_local_pos.pose.position.z;
            geometry_msgs::TwistStamped velocity_tw;
            velocity_tw.twist.linear.x = PID_Control(&pos_pid_x);
            velocity_tw.twist.linear.y = PID_Control(&pos_pid_y);
            velocity_tw.twist.linear.z = PID_Control(&pos_pid_z);
            ROS_INFO("%f %f %f" ,pos_pid_x.Expect ,pos_pid_y.Expect ,pos_pid_z.Expect);
            ROS_INFO("%f %f %f" ,current_local_pos.pose.position.x ,current_local_pos.pose.position.y ,current_local_pos.pose.position.z);
            ROS_INFO("%f %f %f" ,pos_pid_x.FeedBack ,pos_pid_y.FeedBack ,pos_pid_z.FeedBack);
            ROS_INFO("%f %f %f" ,pos_pid_x.Err ,pos_pid_y.Err ,pos_pid_z.Err);
            ROS_INFO("%f %f %f" ,PID_Control(&pos_pid_x) ,PID_Control(&pos_pid_y) ,PID_Control(&pos_pid_z));
            velocity_pub.publish(velocity_tw);
            if((pos_pid_x.Err < 0.15) && (pos_pid_y.Err < 0.15) && (pos_pid_z.Err < 0.15) && (ros::Time::now() - last_request > ros::Duration(5.0))) {
                state++;
            }
                
            ros::spinOnce();
            rate.sleep();
        }
        //搬运点降落
        last_request = ros::Time::now();
        while(ros::ok() && state == 3){
            ROS_INFO_STREAM("state = " << state);
            pos_pid_x.Expect = target1.pose.position.x;
            pos_pid_y.Expect = target1.pose.position.y;
            pos_pid_z.Expect = 0;
            pos_pid_x.FeedBack = current_local_pos.pose.position.x;
            pos_pid_y.FeedBack = current_local_pos.pose.position.y;
            pos_pid_z.FeedBack = current_local_pos.pose.position.z;
            geometry_msgs::TwistStamped velocity_tw;
            velocity_tw.twist.linear.x = PID_Control(&pos_pid_x);
            velocity_tw.twist.linear.y = PID_Control(&pos_pid_y);
            velocity_tw.twist.linear.z = PID_Control(&pos_pid_z);
            ROS_INFO("%f %f %f" ,pos_pid_x.Expect ,pos_pid_y.Expect ,pos_pid_z.Expect);
            ROS_INFO("%f %f %f" ,current_local_pos.pose.position.x ,current_local_pos.pose.position.y ,current_local_pos.pose.position.z);
            ROS_INFO("%f %f %f" ,pos_pid_x.FeedBack ,pos_pid_y.FeedBack ,pos_pid_z.FeedBack);
            ROS_INFO("%f %f %f" ,pos_pid_x.Err ,pos_pid_y.Err ,pos_pid_z.Err);
            ROS_INFO("%f %f %f" ,PID_Control(&pos_pid_x) ,PID_Control(&pos_pid_y) ,PID_Control(&pos_pid_z));
            velocity_pub.publish(velocity_tw);
            if(ros::Time::now() - last_request > ros::Duration(10.0)) {
                state++;
            }
            ros::spinOnce();
            rate.sleep();
        }
        last_request = ros::Time::now();
        //搬运点起飞
        while(ros::ok() && state == 4) {
            ROS_INFO_STREAM("state = " << state);
            pos_pid_x.Expect = target1.pose.position.x;
            pos_pid_y.Expect = target1.pose.position.y;
            pos_pid_z.Expect = target1.pose.position.z;
            pos_pid_x.FeedBack = current_local_pos.pose.position.x;
            pos_pid_y.FeedBack = current_local_pos.pose.position.y;
            pos_pid_z.FeedBack = current_local_pos.pose.position.z;
            geometry_msgs::TwistStamped velocity_tw;
            velocity_tw.twist.linear.x = PID_Control(&pos_pid_x);
            velocity_tw.twist.linear.y = PID_Control(&pos_pid_y);
            velocity_tw.twist.linear.z = PID_Control(&pos_pid_z);
            ROS_INFO("%f %f %f" ,pos_pid_x.Expect ,pos_pid_y.Expect ,pos_pid_z.Expect);
            ROS_INFO("%f %f %f" ,current_local_pos.pose.position.x ,current_local_pos.pose.position.y ,current_local_pos.pose.position.z);
            ROS_INFO("%f %f %f" ,pos_pid_x.FeedBack ,pos_pid_y.FeedBack ,pos_pid_z.FeedBack);
            ROS_INFO("%f %f %f" ,pos_pid_x.Err ,pos_pid_y.Err ,pos_pid_z.Err);
            ROS_INFO("%f %f %f" ,PID_Control(&pos_pid_x) ,PID_Control(&pos_pid_y) ,PID_Control(&pos_pid_z));
            velocity_pub.publish(velocity_tw);
            if(ros::Time::now() - last_request > ros::Duration(7.0)) {
                state++;
            }
            ros::spinOnce();
            rate.sleep();
        }
        //到投递点
        while(ros::ok() && state == 5) {
            ROS_INFO_STREAM("state = " << state);
            pos_pid_x.Expect = target2.pose.position.x;
            pos_pid_y.Expect = target2.pose.position.y;
            pos_pid_z.Expect = target2.pose.position.z;
            pos_pid_x.FeedBack = current_local_pos.pose.position.x;
            pos_pid_y.FeedBack = current_local_pos.pose.position.y;
            pos_pid_z.FeedBack = current_local_pos.pose.position.z;
            geometry_msgs::TwistStamped velocity_tw;
            velocity_tw.twist.linear.x = PID_Control(&pos_pid_x);
            velocity_tw.twist.linear.y = PID_Control(&pos_pid_y);
            velocity_tw.twist.linear.z = PID_Control(&pos_pid_z);
            ROS_INFO("%f %f %f" ,pos_pid_x.Expect ,pos_pid_y.Expect ,pos_pid_z.Expect);
            ROS_INFO("%f %f %f" ,current_local_pos.pose.position.x ,current_local_pos.pose.position.y ,current_local_pos.pose.position.z);
            ROS_INFO("%f %f %f" ,pos_pid_x.FeedBack ,pos_pid_y.FeedBack ,pos_pid_z.FeedBack);
            ROS_INFO("%f %f %f" ,pos_pid_x.Err ,pos_pid_y.Err ,pos_pid_z.Err);
            ROS_INFO("%f %f %f" ,PID_Control(&pos_pid_x) ,PID_Control(&pos_pid_y) ,PID_Control(&pos_pid_z));
            velocity_pub.publish(velocity_tw);
            if((pos_pid_x.Err < 0.15) && (pos_pid_y.Err < 0.15)) {
                state++;
            }
            ros::spinOnce();
            rate.sleep();
        }
        //投递点降落
        last_request = ros::Time::now();
      /*  while(ros::ok() && state == 6){
            ROS_INFO_STREAM("state = " << state);
            pos_pid_x.Expect = target2.pose.position.x;
            pos_pid_y.Expect = target2.pose.position.y;
            pos_pid_z.Expect = 0;
            pos_pid_x.FeedBack = current_local_pos.pose.position.x;
            pos_pid_y.FeedBack = current_local_pos.pose.position.y;
            pos_pid_z.FeedBack = current_local_pos.pose.position.z;
            geometry_msgs::TwistStamped velocity_tw;
            velocity_tw.twist.linear.x = PID_Control(&pos_pid_x);
            velocity_tw.twist.linear.y = PID_Control(&pos_pid_y);
            velocity_tw.twist.linear.z = PID_Control(&pos_pid_z);
            ROS_INFO("%f %f %f" ,pos_pid_x.Expect ,pos_pid_y.Expect ,pos_pid_z.Expect);
            ROS_INFO("%f %f %f" ,current_local_pos.pose.position.x ,current_local_pos.pose.position.y ,current_local_pos.pose.position.z);
            ROS_INFO("%f %f %f" ,pos_pid_x.FeedBack ,pos_pid_y.FeedBack ,pos_pid_z.FeedBack);
            ROS_INFO("%f %f %f" ,pos_pid_x.Err ,pos_pid_y.Err ,pos_pid_z.Err);
            ROS_INFO("%f %f %f" ,PID_Control(&pos_pid_x) ,PID_Control(&pos_pid_y) ,PID_Control(&pos_pid_z));
            velocity_pub.publish(velocity_tw);
            if(ros::Time::now() - last_request > ros::Duration(10.0)) {
                state++;
            }
            ros::spinOnce();
            rate.sleep();
        }
        */
            last_request = ros::Time::now();
        //投递点发送投递指令
        while(ros::ok() && state == 6) {
            ROS_INFO_STREAM("state = " << state);
            std::string send_buf;
            send_buf[0] = 'F';
            send_buf[1] = 'F';
            send_buf[2] = 'A';
            send_buf[3] = 'B';
            absorb_cmd.write(send_buf);                      
            if(ros::Time::now() - last_request > ros::Duration(4.0)) {
                state=2;
            }
            ros::spinOnce();
            rate.sleep();
        }
    }

    return 0;
}

调试问题：

最开始起飞和降落直接用的是mavros中的模式指令，但是发现takeoff以后，不再可以做速度控制，同样，land以后也不能在takeoff了，即便是自动解锁切offb也不行，暂时还没弄懂是为啥，接下来再测试一下

loyuve922
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于欧几里德聚类的障碍物检测ROS实现
04-24
"基于欧几里德聚类的障碍物检测ROS实现"是一种使用点云处理技术来识别和定位周围障碍物的方法。在这个项目中，我们主要依赖于Point Cloud Library（PCL）和Robot Operating System (ROS) 这两个强大的工具。 首先，...
基于YOLOv5以及ROS的Kobuki小车防撞报警算法实现
04-03
在本文中，我们将深入探讨如何将YOLOv5对象检测模型与ROS（Robot Operating System）系统结合，应用于Kobuki小车的避障报警算法实现。这个项目旨在为无人小车提供实时的障碍物检测能力，确保其在环境中安全运行。 ...
基于ROS的导航框架
lovely_yoshino的博客
07-22 6784
https://blog.csdn.net/zz123456zzss/article/details/87904762 http://wiki.ros.org/move_base_flex http://wiki.ros.org/move_base/
一起读论文11：基于ROS的溯源机器人系统
weixin_44208404的博客
09-03 451
基于ROS的溯源机器人系统1 系统框架2 系统软件设计2.1 感知层的设计2.2 网关程序设计2.3 SALM自动溯源2.4 物体识别 1 系统框架 基于ROS的溯源机器人系统的功能主要有：感知层、数据采集、基于感知数据的溯源服务、语音控制、物体识别、机器人物体追踪和Web端等及部分组成。 （1）感知层数据采集：通过传感器获取所处环境的物理状态，然后将数据发送至ROS网络； （2）基于感知数据的溯源服务：对数据分析后，控制机器人进行相应动作； （3）Web端：实时显示感知层获取的数据，并对执行节点进行控制、
基于ROS搭建简易软件框架实现ROV水下目标跟踪（补3）--ROS2.0
cabinx的博客
11-17 2547
ROS从诞生到现在已经发展了很多年了，虽然功能强大，但底层架构的局限性使得缺陷也不少，修修补补越来越难满足时代发展的需求。针对这些缺陷，在下一代的机器人操作系统ROS2.0引入新概念新技术，重新进行架构设计，使得更符合时代发展的需要。官方已经声明neotic将是ROS的最后一个版本，而ROS2.0的发展也日益成熟，未来开发趋势应该是逐步迁移至ROS2.0。鉴于种种，因为原软件框架是基于ROS的，我选择只实现一些基本功能不再进行更多模块的开发。迁移至ROS2.0后，再进行开发。这个我在第一篇博客里也有...
基于ROS的自动驾驶仿真平台开发记录-路径规划
NEO's NOTEBOOK
06-07 2636
初步搭建路径规划模块，实现了几种规划算法，测试结果如下： 1 Dijkstra 节点访问情况如下（广度优先）： 2 A Star 节点访问情况如下（深度优先）： 3 RRT（快速搜索随机树） 两次的结果如下，由于搜索树随机生长，故每次规划结果会不同 4 PFM（人工势场法） 目前暂时还有bug，深受Local Minima其害…比如当起点就在一个局部极小时，就永远无法找到目标。 ...
基于C++实现的基于ROS的多无人机编队仿真
06-07
【作品名称】：基于C++实现的基于ROS的多无人机编队仿真 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：基于C++实现...
基于ROS实现多差速无人车编队控制源码+详细注释.zip
04-10
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料...基于ROS实现多差速无人车编队控制源码+详细注释.zip
标定-基于ROS的手眼标定实现-附项目源码+流程教程-优质项目实战.zip
最新发布
06-30
标定_基于ROS的手眼标定实现_附项目源码+流程教程_优质项目实战
基于ROS机器人项目开发从零开始 - 01
weixin_43904073的博客
04-22 5374
其实基于机器人机械臂，计算机视觉算法的内容已经写了很多了。但是如何把离散化的知识和零件有机的平凑在一起，需要硬件连接，需要软甲通讯，需要系统的集成 --- 呼之欲出的就是，我们需要一个操作系统呀！这个操作系统可以在硬件搭建前期帮助软件做仿真优化，也能很好的集成系统，减少开发时间。这就是ROS系统。 1. 什么是ROS ROS - Robot Operating System; 机器人操作系统。但是它和传统window，linux，unix系统有些区别，我个人理解是ROS其实是对Linux......
第三届中国高校智能机器人创意大赛ROS挑战赛-迷宫夺宝机器人
w1050321758的博客
01-02 2144
全国高校智能机器人大赛之ROS挑战赛-迷宫夺宝机器人 一、作品简介 比赛规则：http://www.annisen.com/details.aspx?id=163 参赛作品： 获奖： 二、硬件架构 系统硬件列表： 系统硬件框图： 系统的硬件框图如图所示。上层控制器树莓派4B通过WIFI与下位机进行分布式网络通信，使用USB连接激光雷达获取障碍物距离信息，通过PWM引脚连接接收机与舵机，接收遥控器信号控制舵机转动，使用开发的通信协议通过串口发送速度指令与底层控制器STM32进行通信，底层控制器接收到
第十五届全国大学生智能汽车竞赛ROS组车模线上比赛
TSINGHUAJOKING
08-04 3796
作者:卓晴博士，清华大学自动化系 更新时间：2020-08-04 Tuesday     ROS车模线上比赛 1.成功的示例 (1) 示例1：浙江工业大学参赛队伍 (2) 示例2：北京科技大学参赛队伍 (3) 示例3：上海交通大学参赛队伍 2.失败的示例 (1) 示例1 (2) 示例2   公众号留言 卓大大这样是允许的吧？ 这是允许的。在比赛之后进行电机检查的时候，只需要将铜箔打开即可。 卓老师，请问下，磁标可以伸出去10cm蛮，我们在我们车上做.
ROS工业机器人和工业自动化竞赛Agile Robotics for Industrial Automation Competition (ARIAC)
zhangrelay的专栏
05-09 4440
----机器翻译--------本页概述了敏捷机器人工业自动化大赛（ARIAC）的规范。本文档中经常使用以下术语订单：托盘上的零件列表和目标位置。部分：订单的一个元素。托盘：保持零件的表面。套件：构成订单的托盘和一组零件。竞争情景ARIAC要求参与者完成以工业场景为中心的一系列测试，这些测试基于由特定部件组成的建筑工具。机器人系统将在“工作环境”部分指定的环境中工作。有三种不同的测试场景都涉及将零
ROS仿真中国机器人及人工智能大赛
weixin_63812613的博客
03-12 985
ros仿真
自己看的笔记（ROS开发者大赛demo代码之一）
qq_42145185的博客
12-18 384
#include &lt;ros/ros.h&gt; #include "ros/console.h" #include &lt;tf/transform_listener.h&gt; #include &lt;nav_msgs/Odometry.h&gt; #include &lt;string.h&gt; #include &lt;move_base_msgs/MoveBaseAction.h...
ROS机器人系列竞赛之工业自动化（侧重机器人敏捷开发）Agile Robotics for Industrial Automation Competition ariac 2022
zhangrelay的专栏
03-29 2903
ARIAC 2022 是在带有 Gazebo 9.15 的 ROS Melodic 上开发的，并在 Ubuntu 18.04 上运行。 与 Gazebo 一起，通信基础设施将使用机器人操作系统 (ROS)。 鼓励在有时间的时候熟悉 ROS。 已经举办过2届啦！2020+2021 重要网址： www.nist.gov/el/intelligent-systems-division-73500/agile-robotics-industrial-automation-competitio
ROS机器人竞赛Navigation导航包参数调试及程序修改经验
慕羽★的博客
04-08 1596
ROS机器人竞赛Navigation导航包参数调试及程序修改经验
ROS机器人系列竞赛之地下挑战赛 The DARPA Subterranean (SubT) Challenge Competition
zhangrelay的专栏
03-29 3500
这个挑战赛有完整的教程： github.com/osrf/subt_hello_world 谷歌翻译截图如下： 仿真是基础，仿真不过瘾的话嘛，真实场景更加酷炫！！！ 参考：www.openrobotics.org/blog/2021/9/27/darpa-subt-final-competition 入口 洞穴实景 场景一应俱全啊，全景图如下： 主角，酷炫的机器人！ DARPA SubT 总决赛（谷歌翻译） DARPA 地下 (SubT)...
第十七届恩智浦杯室外ROS无人车竞速赛仿真
m0_66712565的博客
03-03 2272
学长说让以考促学，用做过的比赛来检验ROS的学习效果，看我们能不能灵活运用。（′д｀）ゞ才做了一个开头车还不会动，恩智浦杯的实物车出了点问题，我要去解决了。等我以后有时间了会继续做的，这是我脱离视频完成仿真，检验我学习成果的最好方式了。
基于ros2实现yolov5
07-28
对于基于ROS2实现Yolov5，你可以按照以下步骤进行操作： 1. 首先，确保你已经安装了ROS2，并准备好了你的工作空间。 2. 下载Yolov5的代码库。你可以从GitHub上的yolov5仓库中获取代码，使用该代码库可以实现物体...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值