1.发布者Publisher的编程实现

2.订阅者Subscriber的编程实现

3.话题消息的定义与使用

4.客户端Client的编程实现

1.发布者Publisher的编程实现

删除功能包再创建一个

cd ~/catkin_ws/src
rm -rf beginner_tutorials
catkin_create_pkg learning_topic roscpp rospy std_msgs geometry_msgs turtlesim

yys@yys:~/catkin_ws/src$ ls
CMakeLists.txt  learning_topic

如何实现一个发布者

• 初始化ROS节点；

• 向ROS Master注册节点信息，

包括发布的话题名和话题中

的消息类型；

• 创建消息数据；

• 按照一定频率循环发布消息。

①c++实现

如何配置CMakeLists.txt中的编译规则

• 设置需要编译的代码和生成的可执行文件；

• 设置链接库；

下面两句话复制learning_topic下的CMakeLists.txt中,install上面

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

add_executable(velocity_publisher src/velocity_publisher.cpp)
target_link_libraries(velocity_publisher ${catkin_LIBRARIES})
#############
## Install ##
#############

注意:空格,不然报错

velocity_publisher.cpp

/**
 * 该例程将发布turtle1/cmd_vel话题，消息类型geometry_msgs::Twist
 */
 
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>

int main(int argc, char **argv)
{
	// ROS节点初始化
	ros::init(argc, argv, "velocity_publisher");

	// 创建节点句柄
	ros::NodeHandle n;

	// 创建一个Publisher，发布名为/turtle1/cmd_vel的topic，消息类型为geometry_msgs::Twist，队列长度10
	ros::Publisher turtle_vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel", 10);

	// 设置循环的频率
	ros::Rate loop_rate(10);

	while (ros::ok())
	{
	    // 初始化geometry_msgs::Twist类型的消息
		geometry_msgs::Twist vel_msg;
		vel_msg.linear.x = 0.5;
		vel_msg.angular.z = 0.2;

	    // 发布消息
		turtle_vel_pub.publish(vel_msg);
		ROS_INFO("Publsh turtle velocity command[%0.2f m/s, %0.2f rad/s]", 
				vel_msg.linear.x, vel_msg.angular.z);

	    // 按照循环频率延时
	    loop_rate.sleep();
	}

	return 0;
}

编译

cd ~/catkin_ws

catkin_make

roscore

rosrun turtlesim turtlesim_node

learning_topic 文件名, velocity_publisher编译后名字,可以~/catkin_ws/devel/lib/learning_topic找到

yys@yys:~/catkin_ws/devel/lib/learning_topic$ ls
velocity_publisher

rosrun learning_topic velocity_publisher

 

②用python 代码实现

velocity_publisher.py

注意:python3 要改成#!/usr/bin/env python3 才能运行

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 该例程将发布turtle1/cmd_vel话题，消息类型geometry_msgs::Twist

import rospy
from geometry_msgs.msg import Twist


def velocity_publisher():
    # ROS节点初始化
    rospy.init_node('velocity_publisher', anonymous=True)

    # 创建一个Publisher，发布名为/turtle1/cmd_vel的topic，消息类型为geometry_msgs::Twist，队列长度10
    turtle_vel_pub = rospy.Publisher('/turtle1/cmd_vel', Twist, queue_size=10)

    # 设置循环的频率
    rate = rospy.Rate(10)

    while not rospy.is_shutdown():
        # 初始化geometry_msgs::Twist类型的消息
        vel_msg = Twist()
        vel_msg.linear.x = 0.5
        vel_msg.angular.z = 0.2

        # 发布消息
        turtle_vel_pub.publish(vel_msg)
        rospy.loginfo("Publsh turtle velocity command[%0.2f m/s, %0.2f rad/s]",
                      vel_msg.linear.x, vel_msg.angular.z)

        # 按照循环频率延时
        rate.sleep()


if __name__ == '__main__':
    try:
        velocity_publisher()
    except rospy.ROSInterruptException:
        pass

再learning_topic新建一个文件夹与c++区分开,比如script

把python 代码放进去,进入script文件夹直接运行

rosrun learning_topic velocity_publisher.py

2.订阅者Subscriber的编程实现

①c++

pose_subscriber.cpp

/**
 * 该例程将订阅/turtle1/pose话题，消息类型turtlesim::Pose
 */
 
#include <ros/ros.h>
#include "turtlesim/Pose.h"

// 接收到订阅的消息后，会进入消息回调函数
void poseCallback(const turtlesim::Pose::ConstPtr& msg)
{
    // 将接收到的消息打印出来
    ROS_INFO("Turtle pose: x:%0.6f, y:%0.6f", msg->x, msg->y);
}

int main(int argc, char **argv)
{
    // 初始化ROS节点
    ros::init(argc, argv, "pose_subscriber");

    // 创建节点句柄
    ros::NodeHandle n;

    // 创建一个Subscriber，订阅名为/turtle1/pose的topic，注册回调函数poseCallback
    ros::Subscriber pose_sub = n.subscribe("/turtle1/pose", 10, poseCallback);

    // 循环等待回调函数
    ros::spin();

    return 0;
}

 

如何实现一个订阅者

• 初始化ROS节点；

• 订阅需要的话题；

• 循环等待话题消息，接收到

消息后进入回调函数；

• 在回调函数中完成消息处理。

如何配置CMakeLists.txt中的编译规则

• 设置需要编译的代码和生成的可执行文件；

• 设置链接库；

跟上面一样:

add_executable(pose_subscriber src/pose_subscriber.cpp)

target_link_libraries(pose_subscriber ${catkin_LIBRARIES})

和上面一样编译运行

最后要rosrun turtlesim turtle_teleop_key 键盘控制海龟动,会显示位置信息

 

cd ~/catkin_ws

catkin_make

roscore

rosrun turtlesim turtlesim_node

rosrun learning_topic velocity_publisher
rosrun turtlesim turtle_teleop_key

 

②python实现

pose_subscriber.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 该例程将订阅/turtle1/pose话题，消息类型turtlesim::Pose

import rospy
from turtlesim.msg import Pose

def poseCallback(msg):
    rospy.loginfo("Turtle pose: x:%0.6f, y:%0.6f", msg.x, msg.y)

def pose_subscriber():
	# ROS节点初始化
    rospy.init_node('pose_subscriber', anonymous=True)

	# 创建一个Subscriber，订阅名为/turtle1/pose的topic，注册回调函数poseCallback
    rospy.Subscriber("/turtle1/pose", Pose, poseCallback)

	# 循环等待回调函数
    rospy.spin()

if __name__ == '__main__':
    pose_subscriber()

运行py

rosrun learning_topic pose_subscriber.py

 

3.话题消息的定义与使用

 

➢ 定义msg文件；
在~/catkin_ws/src/learning_topic新建一个文件夹
mkdir msg
新建Person.msg文件
string name
uint8 sex
uint8 age
uint8 unknown = 0
uint8 male = 1
uint8 female = 2

 

➢ 在package.xml中添加功能包依赖(放到<exec_depend>turtlesim</exec_depend>下面)
<build_depend>message_generation</build_depend>
<exec_depend>message_runtime</exec_depend>

➢ 在CMakeLists.txt添加编译选项

• find_package( …… message_generation)
find_package(catkin REQUIRED COMPONENTS
  geometry_msgs
  roscpp
  rospy
  std_msgs
  turtlesim
  message_generation
)
 
• add_message_files(FILES Person.msg)
generate_messages(DEPENDENCIES std_msgs)
add_message_files(FILES Person.msg) 
generate_messages(DEPENDENCIES std_msgs)
################################################
## Declare ROS messages, services and actions ##
################################################
• catkin_package(…… message_runtime)
把前面#去掉
catkin_package(
#  INCLUDE_DIRS include
#  LIBRARIES learning_topic
CATKIN_DEPENDS geometry_msgs roscpp rospy std_msgs turtlesim message_runtime
#  DEPENDS system_lib
)
➢ 编译生成语言相关文件
cd ~/catkin_ws

catkin_make

①python实现,不用编译

\scripts\person_subscriber.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 该例程将订阅/person_info话题，自定义消息类型learning_topic::Person

import rospy
from learning_topic.msg import Person


def personInfoCallback(msg):
    rospy.loginfo("Subcribe Person Info: name:%s  age:%d  sex:%d",
                  msg.name, msg.age, msg.sex)


def person_subscriber():
    # ROS节点初始化
    rospy.init_node('person_subscriber', anonymous=True)

    # 创建一个Subscriber，订阅名为/person_info的topic，注册回调函数personInfoCallback
    rospy.Subscriber("/person_info", Person, personInfoCallback)

    # 循环等待回调函数
    rospy.spin()


if __name__ == '__main__':
    person_subscriber()

\scripts\person_publisher.py 

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 该例程将发布/person_info话题，自定义消息类型learning_topic::Person

import rospy
from learning_topic.msg import Person


def velocity_publisher():
    # ROS节点初始化
    rospy.init_node('person_publisher', anonymous=True)

    # 创建一个Publisher，发布名为/person_info的topic，消息类型为learning_topic::Person，队列长度10
    person_info_pub = rospy.Publisher('/person_info', Person, queue_size=10)

    # 设置循环的频率
    rate = rospy.Rate(10)

    while not rospy.is_shutdown():
        # 初始化learning_topic::Person类型的消息
        person_msg = Person()
        person_msg.name = "Tom"
        person_msg.age = 18
        person_msg.sex = Person.male

        # 发布消息
        person_info_pub.publish(person_msg)
        rospy.loginfo("Publsh person message[%s, %d, %d]",
                      person_msg.name, person_msg.age, person_msg.sex)

        # 按照循环频率延时
        rate.sleep()


if __name__ == '__main__':
    try:
        velocity_publisher()
    except rospy.ROSInterruptException:
        pass

一个窗口执行一个,就会一个接收一个发送 

rosrun learning_topic person_subscriber.py
rosrun learning_topic person_publisher.py

②c++实现

如何实现一个发布者
• 初始化ROS节点；
• 向ROS Master注册节点信息，
包括发布的话题名和话题中
的消息类型；
• 创建消息数据；
• 按照一定频率循环发布消息。
person_subscriber.cpp
/**
 * 该例程将订阅/person_info话题，自定义消息类型learning_topic::Person
 */
 
#include <ros/ros.h>
#include "learning_topic/Person.h"

// 接收到订阅的消息后，会进入消息回调函数
void personInfoCallback(const learning_topic::Person::ConstPtr& msg)
{
    // 将接收到的消息打印出来
    ROS_INFO("Subcribe Person Info: name:%s  age:%d  sex:%d", 
			 msg->name.c_str(), msg->age, msg->sex);
}

int main(int argc, char **argv)
{
    // 初始化ROS节点
    ros::init(argc, argv, "person_subscriber");

    // 创建节点句柄
    ros::NodeHandle n;

    // 创建一个Subscriber，订阅名为/person_info的topic，注册回调函数personInfoCallback
    ros::Subscriber person_info_sub = n.subscribe("/person_info", 10, personInfoCallback);

    // 循环等待回调函数
    ros::spin();

    return 0;
}

person_publisher.cpp

/**
 * 该例程将发布/person_info话题，自定义消息类型learning_topic::Person
 */
 
#include <ros/ros.h>
#include "learning_topic/Person.h"

int main(int argc, char **argv)
{
    // ROS节点初始化
    ros::init(argc, argv, "person_publisher");

    // 创建节点句柄
    ros::NodeHandle n;

    // 创建一个Publisher，发布名为/person_info的topic，消息类型为learning_topic::Person，队列长度10
    ros::Publisher person_info_pub = n.advertise<learning_topic::Person>("/person_info", 10);

    // 设置循环的频率
    ros::Rate loop_rate(1);

    int count = 0;
    while (ros::ok())
    {
        // 初始化learning_topic::Person类型的消息
    	learning_topic::Person person_msg;
		person_msg.name = "Tom";
		person_msg.age  = 18;
		person_msg.sex  = learning_topic::Person::male;

        // 发布消息
		person_info_pub.publish(person_msg);

       	ROS_INFO("Publish Person Info: name:%s  age:%d  sex:%d", 
				  person_msg.name.c_str(), person_msg.age, person_msg.sex);

        // 按照循环频率延时
        loop_rate.sleep();
    }

    return 0;
}

 

CMakeLists.txt加入编译
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)

编译

cd ~/catkin_ws

catkin_make
roscore

 

rosrun learning_topic person_subscriber
rosrun learning_topic person_publisher

 

 
创建功能包
cd ~/catkin_ws/src
catkin_create_pkg learning_service roscpp rospy std_msgs geometry_msgs turtlesim

 

①python 实现

如何实现一个客户端

/home/yys/catkin_ws/src/learning_service/python/turtle_spawn.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 该例程将请求/spawn服务，服务数据类型turtlesim::Spawn

import sys
import rospy
from turtlesim.srv import Spawn

def turtle_spawn():
	# ROS节点初始化
    rospy.init_node('turtle_spawn')

	# 发现/spawn服务后，创建一个服务客户端，连接名为/spawn的service
    rospy.wait_for_service('/spawn')
    try:
        add_turtle = rospy.ServiceProxy('/spawn', Spawn)

		# 请求服务调用，输入请求数据
        response = add_turtle(2.0, 2.0, 0.0, "turtle2")
        return response.name
    except rospy.ServiceException as e:
        print ("Service call failed: %s"%e)

if __name__ == "__main__":
	#服务调用并显示调用结果
    print ("Spwan turtle successfully [name:%s]" %(turtle_spawn()))

roscore
rosrun turtlesim turtlesim_node

rosrun learning_service turtle_spawn.py
• 初始化ROS节点；
• 创建一个Client实例；
• 发布服务请求数据；
• 等待Server处理之后的应答结果。
 

 ②c++实现

如何实现一个客户端

/home/yys/catkin_ws/src/learning_service/src/turtle_spawn.cpp

/**
 * 该例程将请求/spawn服务，服务数据类型turtlesim::Spawn
 */

#include <ros/ros.h>
#include <turtlesim/Spawn.h>

int main(int argc, char** argv)
{
    // 初始化ROS节点
	ros::init(argc, argv, "turtle_spawn");

    // 创建节点句柄
	ros::NodeHandle node;

    // 发现/spawn服务后，创建一个服务客户端，连接名为/spawn的service
	ros::service::waitForService("/spawn");
	ros::ServiceClient add_turtle = node.serviceClient<turtlesim::Spawn>("/spawn");

    // 初始化turtlesim::Spawn的请求数据
	turtlesim::Spawn srv;
	srv.request.x = 2.0;
	srv.request.y = 2.0;
	srv.request.name = "turtle2";

    // 请求服务调用
	ROS_INFO("Call service to spwan turtle[x:%0.6f, y:%0.6f, name:%s]", 
			 srv.request.x, srv.request.y, srv.request.name.c_str());

	add_turtle.call(srv);

	// 显示服务调用结果
	ROS_INFO("Spwan turtle successfully [name:%s]", srv.response.name.c_str());

	return 0;
};
 
• 初始化ROS节点；
• 创建一个Client实例；
• 发布服务请求数据；
• 等待Server处理之后的应答结果。
 
如何配置CMakeLists.txt中的编译规则
• 设置需要编译的代码和生成的可执行文件；
• 设置链接库；
 
add_executable(turtle_spawn src/turtle_spawn.cpp)
target_link_libraries(turtle_spawn ${catkin_LIBRARIES})

编译,运行  

cd ~/catkin_ws
catkin_make
roscore
rosrun turtlesim turtlesim_node
rosrun learning_service turtle_spawn