精华内容
下载资源
问答
  • 在window下,建立与ubuntu系统中ROS通信,实现将window中的字符发个ubuntu中ROS系统
  • 是一组开源软件库和工具,用于与来自的通信。 应用程序,尤其是 。 是一些展示,展示了使用ROS#可以完成的工作。 社区提供了ROS#的各种其他应用示例。 请不要犹豫,发布您的! 内容 : , 和.NET解决方案 : ...
  • ROS通信-小例子

    2021-04-20 10:55:35
    ROS通信-小例子 1、环境 ​ ubuntu20.04 + ROS Noetic Ninjemys(http://wiki.ros.org/noetic/Installation) 2、例子(目的是建立talker1和listener1的通信,talker1为发布者,listener1为订阅者) 2.1 cd ~ # 进入...

    ROS通信-小例子

    1、环境

    ​ ubuntu20.04 + ROS Noetic Ninjemys(http://wiki.ros.org/noetic/Installation)

    2、例子(目的是建立talker1和listener1的通信,talker1为发布者,listener1为订阅者)

    2.1 cd ~ # 进入用户目录。
    2.2 mkdir -p ~/catkin_ws/src # 创建工作空间。
    2.3 catkin_create_pkg message std_msgs roscpp # 创建message功能包,message依赖于std_msg,roscpp等package。运行该命令后会生成CMakeLists.txt、include、package.xml、src等文件。如下图所示
    

    在这里插入图片描述

    2.4 cd ~/catkin_ws/src/message/src # 进入cpp节点创建路径。
    2.5 touch talker1.cpp和touch listener1.cpp # 创建两个cpp节点。如下图所示。
    

    在这里插入图片描述
    talk1.cpp代码(代码有不懂的可以去看《ROS机器人上程序设计》的P35页):

    #include "ros/ros.h"
    #include "std_msgs/String.h"
    
    #include <sstream>
    
    int main(int argc, char **argv)
    {
      ros::init(argc, argv, "talker");
      ros::NodeHandle n;
    
      ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);
    
      ros::Rate loop_rate(10);
    
      int count = 0;
      while (ros::ok())
      {
    
        std_msgs::String msg;
    
        std::stringstream ss;
        ss << "hello world " << count;
        msg.data = ss.str();
    
        ROS_INFO("%s", msg.data.c_str());
    
        chatter_pub.publish(msg);
    
        ros::spinOnce();
    
        loop_rate.sleep();
        ++count;
      }
    
    
      return 0;
    }
    

    listener1.cpp代码:

    #include "ros/ros.h"
    #include "std_msgs/String.h"
    
    void chatterCallback(const std_msgs::String::ConstPtr& msg)
    {
      ROS_INFO("I heard: [%s]", msg->data.c_str());
    }
    
    int main(int argc, char **argv)
    {
      ros::init(argc, argv, "listener");
      ros::NodeHandle n;
      ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
      ros::spin();
      return 0;
    }
    

    ​ 2.6 修改~/catkin_ws/src目录下的CMakelist.txt文件,加入

    add_executable(talker1 src/talker1cpp)
    target_link_libraries(talker1 ${catkin_LIBRARIES})
    add_executable(listener1 src/listener1.cpp)
    target_link_libraries(listener1  ${catkin_LIBRARIES})
    

    四行代码即可。如下图所示。
    在这里插入图片描述
    2.7 cd ~/catkin_ws,然后运行catkin_make进行编译。如下图所示为编译成功。
    在这里插入图片描述
    ​ 2.8 编译成功后,会在~/catkin_ws/devel/lib/messager目录下生成talker1和listener1两个可执行文件。
    在这里插入图片描述
    ​ 2.9 另起一个终端,运行roscore
    ​ 2.10 再另起两个终端运行,先运行./talker1发布节点到topic,再运行./listener1订阅该节点。至此即完成ROS通信过程。如下图所示。
    在这里插入图片描述

    展开全文
  • 自从window系统顺利安装ROS系统之后,小海龟顺利跑起来,就面临Ubuntu系统和windows系统上的ROS通信问题。这个问题卡了很久,就在今天上午,在实验室强哥的帮助下,这个问题终于解决。 查了很多博客,对这个问题,并...

    各位博友,好久不见。自从window系统顺利安装ROS系统之后,小海龟顺利跑起来,就面临Ubuntu系统和windows系统上的ROS通信问题。这个问题卡了很久,就在今天上午,在实验室强哥的帮助下,这个问题终于解决。

    查了很多博客,对这个问题,并没有一个系统性的解决方案。今天将这一过程梳理一二,整理如下:

    想要实现Windows中ros和Ubuntu系统中的ros进行通信,按照两个Ubuntu系统中ROS通信的思路,这里参考该链接先对ubuntu的配置过程进行阐述:

    一、Ubuntu系统ros和Ubuntu系统ros的通信过程

    1、配置IP地址

    首先需要确定ROS多机系统中的所有计算机处于同一网络,然后分别在计算机ubuntu、shibopi-desktop上使用ifconfig命令查看计算机的局域网IP地址 为了防止每次开机分配的IP地址变化,这里建议为俩机分配固定IP,一劳永逸,下面我使用的这两个IP是我分配好的。

    主机ubuntu192.168.8.88
    从机shibopi-desktop192.168.8.197

    分别在两台计算机系统的/etc/hosts文件中加入对方的IP地址和对应的计算机名

    在Ubuntu主机上运行以下指令

    sudo gedit /etc/hosts
    

    将指令加入到该文件中192.168.8.197 shibopi-desktop

    在shibopi-desktop从机上运行以下指令

    sudo gedit /etc/hosts
    

    将指令加入到该文件中192.168.8.88 ubuntu

    设置完毕后,分别在两台计算机上使用ping命令测试网络是否连通
    在这里插入图片描述

    2、设置ROS_MASTER_URI

    因为系统中只能存在一个Master,所以从机shibopi-desktop需要知道Master的位置。ROS Master的位置可以使用环境变量ROS_MASTER_URI进行定义,在从机shibopi-desktop上使用如下命令设置ROS_MASTER_URI:

    $ export ROS_MASTER_URI=http:/ubuntu:11311
    

    但是以上设置只能在输入的终端中生效,为了让所有打开的终端都能识别,最好使用如下命令将环境变量的设置加入终端的配置文件中。

    $ echo "export ROS_MASTER_URI=http://ubuntu:11311" >> ~/.bzshrc
    

    这样,两个Ubuntu系统中的ROS就能通讯了。

    二、windows系统中的ROS和Ubuntu系统的ROS进行通信

    这里准备的硬件条件为

    Windowsmelodic10.42.0.100从机
    Ubuntukinetic10.42.0.1主机

    1、配置IP地址

    将Windows系统和Ubuntu系统放置在同一个局域网下,分别在Ubuntu系统和windows系统中固定IP地址。这里默认各位博友天生就会固定Ubuntu下的IP地址。windows的IP地址固定的过程用一张图说清楚:
    在这里插入图片描述
    这里固定Windows端的IP地址为10.42.0.100
    Ubuntu端的IP地址为10.42.0.1

    与上述两个Ubuntu系统中ROS通讯不同的是,这次就不在/etc/hosts文件进行任何操作

    直接在windows上的命令行窗口去ping 10.42.0.1和在Ubuntu系统的终端去ping 10.42.0.100

    这里不出意外的话,会遇到一个问题。就是在Windows下去ping通Ubuntu是可以ping通的,但是从Ubuntu去ping通Windows就ping不同。这里需要设置一下防火墙,这里以一张图片和一个链接阐述这一操作过程:
    在这里插入图片描述
    设置完成了!!!
    发现可以ping通了,走到这里,相信大部分博友开始暗自高兴,因为大佬总会对问题解决的程度有一个敏锐感觉,问题已经解决大半了。

    2、设置ROS_MASTER_URI

    因为系统中只能存在一个Master,所以从机Windows需要知道Master的位置。但是Windows下没有.bashrc文件呀,这如何设置呢?
    这里主要参考这个链接,给我们的进展打开了新的思路。
    在Windows系统中安装ROS的过程中,都会在桌面生成一个ROS的快捷命令窗口,双击这个ROS快捷命令窗口,并在其中执行以下两条指令:

    set ROS_MASTER_URI=http://主机IP:11311
    
    set ROS_IP=从机IP
    

    对应于之前的设定,本电脑执行如下命令:
    在这里插入图片描述
    这两条语句对应于Ubuntu系统写入.bashrc文件中的两条:

    export ROS_MASTER_URI=http://主机IP:11311  #要和主机的roscore终端中的ROS_MASTER_URI的port一致,默认为11311。http不可省略
    
    export ROS_IP=从机IP              #本机的ip地址
    

    注意
    Windows作为从机,在每次启动的时候都要单独在命令行中执行这两条语句,如果嫌麻烦的话,可以将其写到一个脚本文件中。

    三、小海龟测试

    在Ubuntu系统的终端执行以下指令

    roscore
    rosrun turtlesim turtlesim_node
    

    把小海龟的节点跑起来
    在这里插入图片描述

    在Windows系统中,通过ROS命令行快捷方式输入以下指令

    set ROS_MASTER_URI=http://10.42.0.1:11311
    set ROS_IP=10.42.0.100
    rosrun turtlesim turtle_teleop_key.exe
    

    键盘控制的节点跑起来:
    在这里插入图片描述

    最后
    Windows上的ros和Ubuntu系统ros通信成功!!!

    附一张照片
    在这里插入图片描述

    在此,向以下链接提供的帮助表示诚挚的谢意!
    https://www.codenong.com/cs106025874/
    https://www.guyuehome.com/25106

    展开全文
  • 本文主要介绍怎么编写代码实现在上层修改底层参数的相关知识...ros下使用rosserial和STM32F1/STM32F4系列进行通信(MDK5工程):https://blog.csdn.net/qq_36349536/article/details/82773064 STM32(MDK)中如何使用ROS
  • ROS通信架构及其弊端

    千次阅读 2019-06-29 11:27:45
    ROS通信架构及其弊端 严格来讲ROS并非是一种操作系统,它只是一种通信框架,一种基于消息传递通信的分布式多进程框架。ROS的主要组成包括ROS Mastar 、 ROS Node、ROS Service等。不同的功能可以由不同的节点实现,...

    ROS通信架构及其弊端

    严格来讲ROS并非是一种操作系统,它只是一种通信框架,一种基于消息传递通信的分布式多进程框架。ROS的主要组成包括ROS Mastar 、 ROS Node、ROS Service等。不同的功能可以由不同的节点实现,节点之间可以通过发布和订阅话题来传递消息,它的本质是基于TCP/IP的Socket通信机制。不同的模块可以被单独设计,在运行时松散耦合,它执行若干种类型的通信,比如基于服务的同步RPC通信、基于话题的异步数据流通信以及基于参数服务器的数据存储等。

    ROS具备丰富的机器人功能库,比如用于坐标变换的 Tf、用于导航的SLAM功能库、用于视觉的OPenCV功能库、用于运动的MoveIt、用于激光雷达的PCL点云库等等,这些丰富的功能库可以使得开发人员快速开发并验证自己的机器人原型;ROS还具备非常便利的数据分析、仿真、调试、可视化工具,比如RVIZ、Gazebo等,还有rosbag、rqt等可以提供数据记录功能等,这些工具可以方便的进行调试开发、验证、仿真自己的机器人,从而提高开发速度。
    当然正是由于ROS的这种架构使得它存在一些弊端:

    1 Master 与 Node 之间并不关心对方的存在,Master 作为网络拓扑的中心,一旦Master崩溃,整个系统将会崩溃;
    2 当 Master 或 Node 崩溃后ROS没有应对策略,ROS不具备动态发现、生存检测、访问控制等机制,因此对系统是一种灾难;
    3 系统存在大量的话题和数据时,一个节点与多个节点通信时,一个消息会拷贝多次,因此对系统资源也是一种极大的浪费,并降低系统通信效率,严重时会丢包;
    4 ROS通信的消息数据是开放的未加密的,如果通信过程中Master或Node任何一个或多个被劫持,那系统将无法继续有效的运作下去,如果是安全性要求比较高的系统比如无人驾驶中,那么所带来的灾难是不可估量的;

    可尝试的改进

    去中心化

    ROS并非完全的基于分布式的框架结构,它严重依赖 Master 中心节点,因此可以尝试在架构中去掉 Master 这个中心节点,采用节点自发现模式,动态的添加和去掉节点,比如ROS2.0所采用的DDS(Data Distribution Service)数据分发服务,以及 Apollo 中的基于 RTPS 协议的服务发现机制,当一个新的节点加入时,系统的自发现机制会自动向其他节点广播消息,各个节点也会将自己的信息发送至新加入的节点,从而代替 Master 功能。

    采用共享内存,提高数据传输效率

    摒弃ROS中的多个消息接收端拷贝多次现象,直接采用共享内存的方式实现,提高数据吞吐量,减少CPU负担,提高系统效率。

    实时监控

    实时监测并记录节点的运行数据,当检测到系统错误时做出报警,并采取必要的措施进行解决。监测记录节点的运行数据、统计数据、运行状态等,能够为错误追踪提供必要的线索,在系统发生紧急情况时做出反应。记录节点的状态,也是为了恢复宕掉的节点,如果没有记录这些状态,那么再启动将会丢失一些必要的数据,造成系统错误。

    信息加密与安全

    节点之间传递的信息很容易被截获,或被伪造,在无人驾驶领域,发生这种情况意味着严重的事故。必要时可以对发送的信息进行加密,或虚拟化处理,限制ROS节点进程权限,避免对其他节点造成破坏。

    转至:https://zhuanlan.zhihu.com/p/35219808

    展开全文
  • 目录发布/订阅者模型(一)发布者(二)订阅者(三)综合参考资料 ROS (Robot Operating System),即机器人操作系统,是为了加快机器人的开发效率,提高机器人软件代码的复用率,用于...通信机制:ROS通信机制属

    ROS (Robot Operating System),即机器人操作系统,是为了加快机器人的开发效率,提高机器人软件代码的复用率,用于机器人算法快速仿真验证的一个软件平台。

    ROS已经成为机器人领域的一个普遍标准。换句话说,未来的任何一个机器人工程师都必须会ROS,越来越多的机器人也将基于ROS来进行开发。

    ROS主要可以由以下四个部分组成: ROS = 通信机制 + 开发工具 + 应用功能 + 生态系统。

    • 通信机制:ROS的通信机制属于分布式松耦合通信机制,即各通信对象(ROS中指节点)之间相对独立。
    • 开发工具:主要有命令行工具,Qt工具箱,Rviz三维可视化软件,Gazebo物理仿真平台等。
    • 应用功能:包括机器人的主要功能,如即时定位与地图构建(SLAM),导航(Navigation),运动规划(MoveIt)等。
    • 生态系统:主要是指ROS的社区资源。

    ROS通信机制中有两大通信模型:

    • 异步通信模型:Publish and Subscribe model (发布/订阅者模型)
    • 同步通信模型:Server and Client model (服务/客户端模型)

    发布/订阅者模型

    发布/订阅者模型是基于话题(topic)和消息(message)来实现的。发布者负责发布某一话题topic,而话题的内容就是消息message,其有属于自己的消息类型。当某个话题被发布后,该话题的订阅者便会接收到该消息。

    (一)发布者

    举个例子。

    我们打算编写这样一个节点:该节点名为“velocity_publisher”,负责发布turtlesim仿真器的海龟速度消息,而海龟仿真器负责订阅该话题消息。

    在这里插入图片描述

    再编写程序之前,我们先来看看ROS的海龟仿真器turtlesim。

    终端输入:roscore,启动ros_master。

    终端输入:rosrun turtlesim turtlesim_node,启动海龟仿真器,界面如下。

    在这里插入图片描述

    终端输入:rostopic list,查看当前环境的话题消息。

    在这里插入图片描述

    可见,当前环境中已经有了话题/turtle1/cmd_velturtle1表示仿真器中产生的第一只海龟,cmd_vel表示速度指令。

    终端输入:rostopic info /turtle1/cmd_vel,获取该话题的具体信息。
    在这里插入图片描述

    通过终端输出,我们可以知道话题的三个重要信息:消息类型、发布者和订阅者。

    turtle1/cmd_vel话题消息的类型是geometry_msgs/Twist,发布者无,订阅者是/turtlesim。即,/turtlesim已经自动订阅了话题消息/turtle/cmd_vel,我们需要做的仅仅是编写一个发布/turtle1/cmd_vel的节点。

    终端输入:rosmsg show geometry_msgs/Twist ,获取Twist消息的具体消息格式。

    在这里插入图片描述

    Twist消息格式主要分为两部分:linearangular。其中,linear指海龟在空间三个维度上的线速度,angular指海龟在空间三个维度上的角速度。

    首先,我们选择C++来编写程序,直接上代码,,详细可参考代码中的注释。

    #include <ros/ros.h>              //导入ros功能包
    #include <geometry_msgs/Twist.h>  //导入geometry_msgs::Twist消息类型
    
    /*
      功能:创建一个名为“velocity_publisher”的节点,负责发布海龟的速度指令
    */
    
    int main(int argc,char **argv)
    {
       //创建一个名为“velocity_publisher”的节点
       ros::init(argc,argv,"velocity_publisher");
    
       //创建节点句柄,用于管理节点对象
       ros::NodeHandle n;
       /*
          创建一个发布者对象: turtle_vel_pub,负责发布海龟速度消息
          消息类型:geometry_msgs::Twist(ros定义的关于海龟的速度消息类型)
          消息名字:/turtle1/cmd_vel
          消息队列长度:10
       */
       ros::Publisher turtle_vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel",10);
    
       //创建Rate对象,设置速度消息发布频率 单位Hz 10次/s 
       ros::Rate pub_rate(10);
    
       while (ros::ok())
       {
          //创建消息对象,并初始化数据
          geometry_msgs::Twist vel_msg;
          vel_msg.linear.x = 0.3;
          vel_msg.angular.z = 0.3;
    
          //发布速度消息
          turtle_vel_pub.publish(vel_msg);
    
          //打印日志信息
          ROS_INFO("Publishing turtle velocity command:[%0.2f  m/s,%0.2f rad/s]",vel_msg.linear.x,vel_msg.angular.z);
    
          //配合发布频率进行自适应延时
          pub_rate.sleep();
       }
       return 0;
    }
    

    编写好C++代码后,我们还需要在CMakeLists.txt中配置编译规则。

    • 生成可执行文件
    • 设置链接库
    add_executable(velocity_publisher src/velocity_publisher.cpp)
    target_link_libraries(velocity_publisher ${catkin_LIBRARIES})
    

    终端输入:

    roscore

    rosrun turtlesim turtlesim_node

    rosrun learning_topic velocity_publisher

    运行结果:

    在这里插入图片描述

    发现了嘛,我们的小海龟已经在做圆周运动了。

    终端输入:rqt_graph ,利用Qt工具箱得到当前环境的计算图。

    在这里插入图片描述

    通过rqt_graph我们可以直观的了解当前环境中各个节点之间的关系。

    python 版代码

    #!/usr/bin/env python
    # _*_ coding:utf-8 _*_
    
    """
    func: creating a node to publish a topic of /turtle1/cm_vel
    """
    
    import rospy    # 导入rospy库
    from geometry_msgs.msg import Twist  # 导入Twist消息类型
    
    
    def velocity_publisher():
        # 创建一个名为“velocity_publisher”的节点
        rospy.init_node("velocity_publisher", anonymous=True)
    
        # 创建一个发布者:turtle_vel_pub
        # 消息名称:/turtle1/cmd_vel
        # 消息类型:Twist
        # 消息队列长度:10
        turtle_vel_pub = rospy.Publisher("/turtle1/cmd_vel", Twist, queue_size=10)
    
        # 创建消息发布频率对象,10次/s
        pub_rate = rospy.Rate(10)
    
        while not rospy.is_shutdown():
            # 创建消息,并初始化数据
            vel_msg = Twist()
            vel_msg.linear.x = 0.3
            vel_msg.angular.z = 0.3
    
            # 发布消息
            turtle_vel_pub.publish(vel_msg)
    
            # 打印日志信息
            rospy.loginfo("Publishing turtle velocity commanding: [% 0.2f m/s, %0.2f rad/s]", vel_msg.linear.x,
                          vel_msg.angular.z)
    
            # 按照发布频率进行延时
            pub_rate.sleep()
    
    
    if __name__ == "__main__":
        try:
            velocity_publisher()
        except rospy.ROSInterruptException:
            pass
    

    小提示:在运行.py文件之前,确保右击文件,在属性中修改.py可作为可执行文件执行。

    这里,我们小结一下编写节点,发布话题的步骤:

    • 创建节点(节点名字)
    • 创建话题发布者对象(话题名,话题类型,队列长度等)
    • 设置话题发布频率
    • 创建话题消息,并初始化数据
    • 发布者发布话题
    • 延时
    (二)订阅者

    前面我们已经实现了编写一个节点用来发布海龟的速度指令信息。这一节,我们将编写一个节点,负责订阅海龟的位置信息。

    在这里插入图片描述

    不知道你们有没有发现在启动海龟仿真器turtlesim后,话题消息列表(见前面)中出现了/turtle1/pose这个话题?那我们来看看它的具体信息。

    终端输入:

    roscore

    rosrun turtlesim turtlesim_node

    rostopic info /turtle1/pose

    终端输出结果如下:

    在这里插入图片描述

    可知,话题消息/turtle1/pose的发布者是turtlesim,订阅者无。所以,我们需要做的仅仅是编写一个节点,负责订阅海龟的位置信息即可。

    终端输入:rosmsg show geometry_msgs/Pose

    终端输出:

    在这里插入图片描述

    可知,Pose话题消息格式包含两个部分:positionorientation,其中position代表三维空间中的位置,orientation代表的是三维空间中的方位。

    C++代码如下:

    #include <ros/ros.h>          // 导入ros cpp库
    #include "turtlesim/Pose.h"   // 导入Pose消息类型
    
    // 订阅者注册的回调函数
    void poseCallback(const turtlesim::Pose::ConstPtr &msg)
    {
       //将接收到的消息打印出来,这里只显示平面二维坐标
       ROS_INFO("The turtle pose: x:%0.6f, y: %0.6f",msg->x,msg->y);
    }
    
    
    int main(int argc,char **argv)
    {
        // 创建节点
        ros::init(argc,argv,"pose_subscriber");
    
        // 创建节点句柄
        ros::NodeHandle n;
        /*
          创建一个订阅者:turtle_pose_sub
          订阅消息名称:/turtle1/pose
          订阅消息类型:Pose
          消息队列长度:10
          回调函数:poseCallback
        */
        ros::Subscriber turtle_pose_sub = n.subscribe("/turtle1/pose",10,poseCallback);
    
        //循环等待回调函数
        ros::spin();
    
        return 0;
    }
    

    同样,在CMakeLists.txt配置编译规则

    add_executable(pose_subscriber src/pose_subscriber.cpp)
    target_link_libraries(pose_subscriber ${catkin_LIBRARIES})
    

    终端输入:

    roscore

    rosrun turtlesim turtlesim_node

    rosrun learning_topic velocity_publisher

    rosrun learning_topic pose_subscriber

    终端输出:

    在这里插入图片描述

    我们可以看到,小海龟在做圆周运动,同时它的位置也被实时输出到终端。

    终端输入:rqt_graph,查看计算图。

    在这里插入图片描述

    现在来总结一下,编写一个节点,实现订阅者的步骤:

    • 创建节点(配置节点名)
    • 创建订阅者,订阅话题消息(话题名,话题类型,回调函数)
    • 编写回调函数
    • 循环等待回调函数

    python版本代码

    #!/usr/bin/env python
    # _*_ coding:utf-8 _*_
    
    """
    func: subscribing the pose information of a turtle
    """
    
    import rospy   # 导入rospy
    from turtlesim.msg import Pose    # 导入Pose类型
    
    
    def poseCallback(msg):
        # 打印位置信息
        rospy.loginfo("The turtle's pose: x: %0.6f, y:%0.6f", msg.x, msg.y)
    
    
    def pose_subscriber():
        # 创建一个名为"pose_subscriber"的节点
        rospy.init_node("pose_subscriber", anonymous=True)
    
        # 订阅位置信息
        rospy.Subscriber("/turtle1/pose", Pose, poseCallback)
    
        # 循环等待回调函数
        rospy.spin()
    
    
    if __name__ == "__main__":
        pose_subscriber()
    
    (三)综合

    前面,我们分别单独介绍了如何编写一个节点实现发布者发布消息和订阅者订阅消息。但是,我们使用的都是ROS库封装好的消息结构,那我们可不可以定义自己的话题消息结构,然后实现发布和订阅呢?

    答案是可以的!

    ROS提供了一套机制,让用户可以定义自己想要的话题消息结构。

    首先,我们在功能包中创建一个msg文件夹,然后在该文件夹下创建一个Person.msg文件,在该文件中我们添加以下内容:

    string name
    string sex
    uint8 age
    

    Person.msg中我们定义了三个数据:name 、sex、age,用来表征一个人的信息。

    接下来我们需要在CMakeLists.txt和package.xml中添加相关内容进行配置。

    在CMakeLists.txt中添加:

    find_package( ...... message_generation)
    
    add_message_files(FILES Person.msg)
    generate_messages(DEPENDENCIES std_msgs)
    
    catkin_package(...... message_runtime)
    

    在package.xml中添加:

    <build_depend>message_generation</build_depend>
    <exec_depend>message_runtime</exec_depend>
    

    到此,我们的自定义消息结构便配置完成了,然后在工作空间下进行编译。

    终端输入:catkin_make

    编译后,我们在/devel/include/learning_topic目录下可以发现ROS生成了一个Person.h头文件,该文件中的内容就是一些关于我们自定义消息结构的相关配置说明。

    在这里插入图片描述

    现在我们来检查以下自己创建的消息类型是否成功。

    终端输入:rosmsg show learning_topic/Person

    在这里插入图片描述

    可见,我们已经成功定义了自己的话题消息结构learning_topic/Person

    接下来,便是编写发布者节点和订阅者节点了,具体操作步骤同(一)(二),这里就不详细介绍了,具体参考代码。

    发布者:person_publisher.cpp

    /*
      func: 发布/person_info话题消息,自定义消息类型learning_topic::Person
    */
    #include <ros/ros.h>
    #include "learning_topic/Person.h"  //加入自定义消息结构头文件Person.h
    
    int main(int argc,char **argv)
    {
       //创建节点
       ros::init(argc,argv,"person_publisher");
       //创建节点句柄
       ros::NodeHandle n;
       /*
       创建发布者:person_info_pub
       消息名称:/person_info
       消息类型:learning_topic
       消息队列长度:10
       */
       ros::Publisher person_info_pub = n.advertise<learning_topic::Person>("/person_info",10);
    
       //设置消息发布频率
       ros::Rate pub_rate(10);
    
       while(ros::ok())
       {
           //创建消息,并初始化数据
           learning_topic::Person person_msg;
           person_msg.name = "Steve";
           person_msg.sex = "male";
           person_msg.age = 25;
    
           //发布消息
           person_info_pub.publish(person_msg);
    
           //打印日志信息
           ROS_INFO("publishing person info: name:%s sex: %s age:%d",person_msg.name.c_str(),person_msg.sex.c_str(),person_msg.age);
    
           //按照发布频率延时
           pub_rate.sleep();
       }
       return 0;
    }
    

    订阅者:person_subscriber.cpp

    /*
      func:订阅话题消息/person_info
    */
    
    #include <ros/ros.h>
    #include "learning_topic/Person.h"
    
    void personCallback(const learning_topic::Person::ConstPtr &msg)
    {
       //打印接收到的信息
       ROS_INFO("Subscribing peron info: name %s  sex:%s  age:%d",msg->name.c_str(),msg->sex.c_str(),msg->age);
    }
    
    
    int main(int argc,char **argv)
    {
        //创建节点
        ros::init(argc,argv,"person_subscriber");
    
        //创建节点句柄
        ros::NodeHandle n;
        /*
          创建订阅者:person_info_sub
          消息名称:/person_info
          回调函数:personCallback
        */
        ros::Subscriber person_info_sub = n.subscribe("/person_info",10,personCallback);
    
        //循环等待回调函数
        ros::spin();
    
        return 0;
    }
    

    配置编译规则

    add_executable(person_publisher src/person_publisher.cpp)
    target_link_libraries(person_publisher ${catkin_LIBRARIES})
    add_dependencies(person_publisher ${PROJECT_NAME}_generate_messages_cpp)
    
    add_executable(person_subscriber src/person_subscriber.cpp)
    target_link_libraries(person_subscriber ${catkin_LIBRARIES})
    add_dependencies(person_subscriber ${PROJECT_NAME}_generate_messages_cpp)
    

    在工作空间目录下编译

    catkin_make

    终端输入

    roscore
    rosrun learning_topic person_subscriber
    rosrun learning_topic person_publisher
    

    运行效果:

    在这里插入图片描述

    终端输入:rqt_graph,查看当前环境的计算图。

    在这里插入图片描述

    到此,我们便是简单地介绍了ROS的发布/订阅者模型。接下来,我们将会学习ROS的另外一大通信模型:服务/客户端模型。

    参考资料

    古月居

    展开全文
  • 第 2 章 ROS通信机制

    2021-02-25 18:34:51
    ROS入门学习 第 2 章 ROS通信机制 机器人是一种高度复杂的系统性实现,在机器人上可能集成各种传感器(雷达、摄像头、GPS…)以及运动控制实现,为了解耦合,在ROS中每一个功能点都是一个单独的进程,每一个进程都是...
  • ROS通信解析

    2020-10-11 23:54:58
    ROS通信方式有以下四种: (1)Topic主题 (2)Service服务 (3)Parameter Service参数服务器 (4)Actionlib动作 主题Topic 发布publicer源码解析 //ROS头文件 #include <ros/ros.h> //自定义msg...
  • tello_ros 用C ++编写的DJI Ryze Tello ROS通信API
  • ROS通信机制

    2021-08-26 18:38:28
    ROS中的通信机制 通信机制的分类 在ROS中比较常见的通信机制分为话题通信和服务通信,当然还有其它更多的通信方式,在这里不过多描述 话题通信 角色 发布者(Publisher) 订阅者(Subscriber) 管理者(ROS Master...
  • 使用QT开发界面和ROS通信 环境:ubuntu18.04 +ROS Melodic,Qt使用qtcreator-ros-bionic-latest-offline-installer.run(集成了ROS插件,功能类似于Roboware,同时可以开发界面调用ROS),以下是项目地址,下载Qt安装包...
  • 安卓与ROS通信开发——1、安卓与ROS通信的现状 概述概述概述 安卓与ROS通信的现状 ROS官方支持的语言绑定只有C++和Python,目前安卓想与ROS通信,必须借助半官方的rosjava包。 rosjava话题通信机制(Publish/...
  • ros通信方式示例

    2021-03-20 16:19:39
    目录ros工作空间和功能包话题通信服务通信 ros工作空间和功能包 ** 所有的ROS程序,包括我们自己开发的程序,都被组织成功能包 ** ROS的功能包被存放在工作空间。 ** 因此,在我们写程序之前,第一步是创建一个工作...
  • ROS通信编程(三)

    千次阅读 2018-08-14 13:35:11
    ROS通信编程 ros通信编程三大内容:话题编程(topic)、服务编程(service)、动作编程(action) ROS通信编程——话题编程 如何运行文件  rosrun learning_communication talker  ...
  • ROS的一个典型应用场景是:在机器人上安装一台笔记本或单板机,然后在桌面计算机上监视或控制机器人,这时就需要在机器人与桌面计算机之间进行通信ROS使得多台机器观察同一套话题、服务和参数变得相当容易。 1. ...
  • RosBridge底层通过Websocket以Json格式进行通信。在Ros端安装服务,在Android端实现Websocket,完成和Ros端的通信ROS服务端 安装suite服务 sudo apt-get install ros-<rosdistro>-rosbridge-suite 启动 ...
  • Android和Ros之间通过局域网进行通信。常用的方式主要有RosBridge和RosJava两种。 RosBridge 底层通过Websocket以Json格式实现非Ros环境和Ros之间的通信。这种通信方式是轻量级的,能将非Ros环境和Ros解耦。 RosJava...
  • 介绍ROS的4种通信方式与消息文件的概略。
  • 4 ROS通信架构 4.1 启动master和node 4.1.1启动master : roscore 4.1.2 启动node : rosrun, roslaunch 4.1.3 rosnode命令 4.2 ROS的通信方式 4.2.1 Topic 4.2.2 Service 4.2.3 Parameter server 4.2.4 ...
  • 贝叶斯优化(BO)算法和机器人之间的ROS通信框架,用于自动调整机器人控制器。 该工具的目的是在BO和机器人之间可靠地传递消息。 简而言之,当BO算法要求进行新的评估时,此框架将触发机器人上的新实验。 BO等待直到...
  • 主要记录了ROS节点之间通过话题订阅和发布消息的全过程,以及自定义msg消息。
  • 参考:《ROS机器人开发实践》 注:在上节创建的 catkin_ws 工作空间下的功能包 learning_communication 下继续实现通信编程 一、话题通讯模型 二、基础话题编程实现 1、话题编程流程: 1、创建发布者(talker); 2...
  • 基础准备 两台电脑:PCWindows PCUnbuntu 用局部路由器连线两个电脑,两个电脑在Windows系统环境...常看电脑通信ip 在windows的cmd中输入ipconfig,ip为: 无线局域网适配器 WLAN: IPv4 地址 . . . . . . . . . . . . :
  • ros系统与stm32f407的串口通信ros系统发布信息,stm32通过串口接收消息,有食用方法。
  • ROS通信是整个系统的核心和精髓部分。 ROS主要的通信方式有: Topic Service Parameter Servi...
  • ROS通信架构

    2019-04-20 17:12:07
    ROS通信架构 1.图概念概述 Nodes:节点,一个节点即为一个可执行文件,它可以通过ROS与其它节点进行通信。 Messages:消息,消息是一种ROS数据类型,用于订阅或发布到一个话题。 topics:话题,节点可以发布消息到话题...
  • ROS通信编程-----话题编程 作为嵌入式系统应用开发的重要支柱之一的ROS,是我们学习嵌入式开发的第一步,既要学习ROS,我们就得知道ROS怎么使用,今天,林君学长带大家开始学习ROS的第一步:ROS通信编程—话题编程 ...
  • 地图导航功能的实现 之 ROS通信

    千次阅读 热门讨论 2018-01-22 21:13:30
    地图导航分为三个部分,第一个部分为雷达部分的ROS系统,第二部分为通信部分,一般有...ROS官方支持的绑定只有C++和Python,所以目前安卓想与ROS通信,必须借助官方的ROSjava包,通过ROSjava实现与ROS端的通信并进行
  • ROS通信架构简述(一)

    千次阅读 2018-06-05 10:22:30
    实现基础的通信,包括各种数据的处理,进程的运行,消息的传递ROS的设计之初,是为了方便通信,各个节点之间具有分布式架构、松耦合关系,比如对于机器人的遥控系统,在前人造好机器人的情况下,可替换/添加成任意的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,500
精华内容 4,600
关键字:

ros通信