在ubnutu18中进行话题进行话题编程和控制小乌龟画圆

在ubnutu18中进行话题进行话题编程和控制小乌龟画圆

一，话题编程

1.创建工作区

工作区可以作为一个独立的项目进行编译，存放ROS程序的源文件、编译文件和执行文件。
首先打开终端，
1）创建一个名为ros的工作区

mkdir -p ~/ros/src

再进入src的工作空间

cd ~/ros/src

然后生成工作区

catkin_init_workspace

最后再进入ros的工作区进行编译

cd ~/ros/

catkin_make

这时候，会在当前文件夹下生成devel，build这两个子文件夹，在devel文件夹下能看到几个setup.*sh文件
当前文件夹下生成devel，build这两个子文件夹如下图

devel文件夹下能看到几个setup.*sh文件

2.在bash中注册和创建工程包

1）bash注册

source devel/setup.bash

2）验证是否注册

echo $ROS_PACKAGE_PATH

如果能看到自己工作区的文件路径就说明已经成功了。
以上的工作区我们就创建成功了
3）工程包创建
先切换工作区

cd ~/ros/src

再创建一个comm的工程包

catkin_create_pkg comm std_msgs rospy roscpp

4）工程包编译
切换工作区

cd ~/ros

然后编译

catkin_make

经过以上步骤，ROS工程包就建立好了

3.创建收发节点

将目录切换到comm中

cd ~/ros/src/comm

再进入src子目录

cd src

创建并打开talker.cpp

touch talker.cpp

gedit talker.cpp

再将一下内容写入文件中，

#include "ros/ros.h"
#include "std_msgs/String.h"
#include <sstream>
int main(int argc, char **argv)
{
  /**
   * The ros::init() function needs to see argc and argv so that it can perform
   * any ROS arguments and name remapping that were provided at the command line. For programmatic
   * remappings you can use a different version of init() which takes remappings
   * directly, but for most command-line programs, passing argc and argv is the easiest
   * way to do it.  The third argument to init() is the name of the node.
   *
   * You must call one of the versions of ros::init() before using any other
   * part of the ROS system.
   */
  ros::init(argc, argv, "talker");
 
  /**
   * NodeHandle is the main access point to communications with the ROS system.
   * The first NodeHandle constructed will fully initialize this node, and the last
   * NodeHandle destructed will close down the node.
   */
  ros::NodeHandle n;
 
  /**
   * The advertise() function is how you tell ROS that you want to
   * publish on a given topic name. This invokes a call to the ROS
   * master node, which keeps a registry of who is publishing and who
   * is subscribing. After this advertise() call is made, the master
   * node will notify anyone who is trying to subscribe to this topic name,
   * and they will in turn negotiate a peer-to-peer connection with this
   * node.  advertise() returns a Publisher object which allows you to
   * publish messages on that topic through a call to publish().  Once
   * all copies of the returned Publisher object are destroyed, the topic
   * will be automatically unadvertised.
   *
   * The second parameter to advertise() is the size of the message queue
   * used for publishing messages.  If messages are published more quickly
   * than we can send them, the number here specifies how many messages to
   * buffer up before throwing some away.
   */
  ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);
 
  ros::Rate loop_rate(10);
 
  /**
   * A count of how many messages we have sent. This is used to create
   * a unique string for each message.
   */
  int count = 0;
  while (ros::ok())
  {
    /**
     * This is a message object. You stuff it with data, and then publish it.
     */
    std_msgs::String msg;
 
    std::stringstream ss;
    ss << "hello world " << count;
    msg.data = ss.str();
 
    ROS_INFO("%s", msg.data.c_str());
 
    /**
     * The publish() function is how you send messages. The parameter
     * is the message object. The type of this object must agree with the type
     * given as a template parameter to the advertise<>() call, as was done
     * in the constructor above.
     */
    chatter_pub.publish(msg);
 
    ros::spinOnce();
 
    loop_rate.sleep();
    ++count;
  }
  return 0;
}

创建并打开listener.cpp

touch listener.cpp

gedit listener.cpp

将一下内容写入文件中，

#include "ros/ros.h"
#include "std_msgs/String.h"
 
/**
 * This tutorial demonstrates simple receipt of messages over the ROS system.
 */
void chatterCallback(const std_msgs::String::ConstPtr& msg)
{
  ROS_INFO("I heard: [%s]", msg->data.c_str());
}
 
int main(int argc, char **argv)
{
  /**
   * The ros::init() function needs to see argc and argv so that it can perform
   * any ROS arguments and name remapping that were provided at the command line. For programmatic
   * remappings you can use a different version of init() which takes remappings
   * directly, but for most command-line programs, passing argc and argv is the easiest
   * way to do it.  The third argument to init() is the name of the node.
   *
   * You must call one of the versions of ros::init() before using any other
   * part of the ROS system.
   */
  ros::init(argc, argv, "listener");
 
  /**
   * NodeHandle is the main access point to communications with the ROS system.
   * The first NodeHandle constructed will fully initialize this node, and the last
   * NodeHandle destructed will close down the node.
   */
  ros::NodeHandle n;
 
  /**
   * The subscribe() call is how you tell ROS that you want to receive messages
   * on a given topic.  This invokes a call to the ROS
   * master node, which keeps a registry of who is publishing and who
   * is subscribing.  Messages are passed to a callback function, here
   * called chatterCallback.  subscribe() returns a Subscriber object that you
   * must hold on to until you want to unsubscribe.  When all copies of the Subscriber
   * object go out of scope, this callback will automatically be unsubscribed from
   * this topic.
   *
   * The second parameter to the subscribe() function is the size of the message
   * queue.  If messages are arriving faster than they are being processed, this
   * is the number of messages that will be buffered up before beginning to throw
   * away the oldest ones.
   */
  ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
 
  /**
   * ros::spin() will enter a loop, pumping callbacks.  With this version, all
   * callbacks will be called from within this thread (the main one).  ros::spin()
   * will exit when Ctrl-C is pressed, or the node is shutdown by the master.
   */
  ros::spin();
 
  return 0;
}

最后对src文件夹旁边的Cmakelist.txt文件末尾添加一段代码，

include_directories(include ${catkin_INCLUDE_DIRS})
add_executable(talker src/talker.cpp)
target_link_libraries(talker ${catkin_LIBRARIES})
add_dependencies(talker comm_generate_messages_cpp)
add_executable(listener src/listener.cpp)
target_link_libraries(listener ${catkin_LIBRARIES})
add_dependencies(listener comm_generate_messages_cpp)

注意：代码行之间最好不要有间隔，后面编译的时候如果有错误则可以将文件最上方的 version 3.0.2 改为 version 2.8.3
接下来进行编译，

cd ~/ros

catkin_make

如果成功，则会出现100%进度条，

4.测试

首先打开一个新终端，启动ros

roscore

然后再打开一个终端,进入ros工作区

cd ~/ros

并进行程序注册，

source ./devel/setup.bash

然后运行talker节点

rosrun comm talker

接下来，再打开一个新端口，重复上面的步骤，

cd ~/ros

source ./devel/setup.bash

运行lisetener节点

rosrun comm listener

这是listener节点就会同步更新talker的节点的内容。

二，控制小乌龟画圆

1.创建并写入程序

打开一个新终端创建并写入程序，

cd ~/ros/src/comm/src

新建画圆程序为

touch yuan.cpp

并打开

gedit yuan.cpp

代码如下，

#include "ros/ros.h"
#include "std_msgs/String.h"
#include<geometry_msgs/Twist.h> //运动速度结构体类型  geometry_msgs::Twist的定义文件
 
int main(int argc, char *argv[])
{
    ros::init(argc, argv, "vel_ctrl");  //对该节点进行初始化操作
    ros::NodeHandle n;         //申明一个NodeHandle对象n，并用n生成一个广播对象vel_pub
    ros::Publisher vel_pub = n.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel", 10);
    ros::Publisher chatter_pub = n.advertise<std_msgs::String>("chatter", 1000);
    ros::Rate loop_rate(10);
    //vel_pub会在主题"/turtle1/cmd_vel"(机器人速度控制主题)里广播geometry_msgs::Twist类型的数据
    //ros::Rate loopRate(2);
    ROS_INFO("draw_circle start...");//输出显示信息
    while(ros::ok())
    {
        geometry_msgs::Twist vel_cmd; //声明一个geometry_msgs::Twist 类型的对象vel_cmd，并将速度的值赋值到这个对象里面

        vel_cmd.linear.x = 2.0;//前后（+-） m/s
        vel_cmd.linear.y = 0.0;  //左右（+-） m/s
        vel_cmd.linear.z = 0.0;
 
        vel_cmd.angular.x = 0;
        vel_cmd.angular.y = 0;
        vel_cmd.angular.z = 1.8; //机器人的自转速度，+左转，-右转，单位是rad/s

        vel_pub.publish(vel_cmd); //赋值完毕后，发送到主题"/turtle1/cmd_vel"。机器人的核心节点会从这个主题接受发送过去的速度值，并转发到硬件体上去执行
	std_msgs::String msg;
        std::stringstream ss;//定义输出流对象
        ss <<vel_cmd;
        msg.data = ss.str();
    	/**
     	* The publish() function is how you send messages. The parameter
     	* is the message object. The type of this object must agree with the type
     	* given as a template parameter to the advertise<>() call, as was done
     	* in the constructor above.
     	*/
        chatter_pub.publish(msg);
        ros::spinOnce();//调用此函数给其他回调函数得以执行(比例程未使用回调函数)
       //loopRate.sleep();
    }
    return 0;
}

再写一个接收程序，

touch callBackYuan.cpp

gedit callBackYuan.cpp

代码如下，

#include "ros/ros.h"
#include "std_msgs/String.h"
 
/**
 * This tutorial demonstrates simple receipt of messages over the ROS system.
 */
void chatterCallback(const std_msgs::String::ConstPtr& msg)
{
  ROS_INFO("it is location: [%s]", msg->data.c_str());
}
 
int main(int argc, char **argv)
{
  /**
   * The ros::init() function needs to see argc and argv so that it can perform
   * any ROS arguments and name remapping that were provided at the command line. For programmatic
   * remappings you can use a different version of init() which takes remappings
   * directly, but for most command-line programs, passing argc and argv is the easiest
   * way to do it.  The third argument to init() is the name of the node.
   *
   * You must call one of the versions of ros::init() before using any other
   * part of the ROS system.
   */
  ros::init(argc, argv, "yuan");
 
  /**
   * NodeHandle is the main access point to communications with the ROS system.
   * The first NodeHandle constructed will fully initialize this node, and the last
   * NodeHandle destructed will close down the node.
   */
  ros::NodeHandle n;
 
  /**
   * The subscribe() call is how you tell ROS that you want to receive messages
   * on a given topic.  This invokes a call to the ROS
   * master node, which keeps a registry of who is publishing and who
   * is subscribing.  Messages are passed to a callback function, here
   * called chatterCallback.  subscribe() returns a Subscriber object that you
   * must hold on to until you want to unsubscribe.  When all copies of the Subscriber
   * object go out of scope, this callback will automatically be unsubscribed from
   * this topic.
   *
   * The second parameter to the subscribe() function is the size of the message
   * queue.  If messages are arriving faster than they are being processed, this
   * is the number of messages that will be buffered up before beginning to throw
   * away the oldest ones.
   */
  ros::Subscriber sub = n.subscribe("chatter", 1000, chatterCallback);
 
  /**
   * ros::spin() will enter a loop, pumping callbacks.  With this version, all
   * callbacks will be called from within this thread (the main one).  ros::spin()
   * will exit when Ctrl-C is pressed, or the node is shutdown by the master.
   */
  ros::spin();
 
  return 0;
}

然后再进入comm文件夹，修改CMakeLists

cd ~/ros/src/comm

gedit CMakeLists.txt

再在末尾加上以下代码，

add_executable(yuan src/yuan.cpp)
target_link_libraries(yuan ${catkin_LIBRARIES})
#add_dependencies(yuan comm_generate_messages_cpp)
add_executable(callBackYuan src/callBackYuan.cpp)
target_link_libraries(callBackYuan ${catkin_LIBRARIES})

最后进行编译，

cd ~/ros

source ./devel/setup.bash

成功进度会显示100%。

运行

先回到ros工作空间，

cd ~/ros

进行程序注册，将原来这个终端记为终端1

source ./devel/setup.bash

再新建一个终端，运行ros，这个终端记为终端2

roscore

再新建一个终端，进入工作空间，运行接收程序，这个终端记为终端3

cd ~/ros

source ./devel/setup.bash

运行我们的接受实时位置的服务程序，

rosrun comm callBackYuan

再新建一个终端，启动小乌龟，记为终端4，

rosrun turtlesim turtlesim_node

最后在终端一运行画圆程序，

rosrun comm yuan

这个时候小乌龟就会开始画圆

总结

这次的实验让我进一步认识到了ros的话题编程和控制小乌龟行动的程序，知道了操作的具体步骤，明白了更深层的原理。