[Notas de estudio ROS 8] Operación práctica del mecanismo de comunicación

[Notas de estudio ROS 8] Operación práctica del mecanismo de comunicación

Escrito en el frente, esta serie de notas se refiere al tutorial de AutoLabor, la dirección específica del proyecto está aquí

---

prefacio

Realice el control de movimiento de la tortuga a través de la codificación, deje que la pequeña tortuga haga un movimiento circular, como se muestra a continuación:

1. Publicación del tema

Descripción del requisito: código para realizar el control de movimiento de la tortuga, deje que la pequeña tortuga haga un movimiento circular.

Realizar análisis:

1. Implementación de control de movimiento de tortuga, hay dos nodos clave, uno es el nodo de visualización de movimiento de tortuga turtlesim_node, y el otro es el nodo de control, los dos están en el modo de liberación de suscripción para lograr la comunicación, el nodo de visualización de movimiento de tortuga se puede llamar directamente, el nodo de control de movimiento se usó antes Turtle_teleop_key se controla a través del teclado y ahora requiere un nodo de control personalizado.
2. Cuando el nodo de control es autoimplementado, primero es necesario comprender los temas y mensajes utilizados en la comunicación entre el nodo de control y el nodo de visualización, lo que se puede obtener usando el comando ros combinado con el gráfico de cálculo.
3. Después de comprender el tema y el mensaje, escriba el nodo de control de movimiento a través de C++ o Python y publique el mensaje de acuerdo con cierta lógica a través del tema especificado.

Proceso de implementación:

1. Obtenga información de temas y mensajes a través del gráfico de cálculo combinado con el comando ros.
2. La codificación implementa nodos de control de movimiento.
3. Inicie roscore, turtlesim_node y el nodo de control personalizado para ver los resultados de ejecución.

0. Demostración de control de tortugas

Entrar respectivamente en la terminal

rosrun turtlesim turtlesim_node
rosrun turtlesim turtle_teleop_key

1. Obtención de temas y noticias

Preparación: Primero inicie el teclado para controlar el caso del movimiento de la tortuga

rostopic listObtener temas enumerándolos :/turtle1/cmd_vel

rostopic list

Luego obtenga el mensaje y obtenga el tipo de mensaje:geometry_msgs/Twist

rostopic info /turtle1/cmd_vel

El resultado es el siguiente:

2. Realizar el nodo de liberación

Implementación de Cpp

/*
    编写 ROS 节点，控制小乌龟画圆

    准备工作:
        1.获取topic(已知: /turtle1/cmd_vel)
        2.获取消息类型(已知: geometry_msgs/Twist)
        3.运行前，注意先启动 turtlesim_node 节点

    实现流程:
        1.包含头文件
        2.初始化 ROS 节点
        3.创建发布者对象
        4.循环发布运动控制消息
*/

#include "ros/ros.h"
#include "geometry_msgs/Twist.h"

int main(int argc, char *argv[])
{
    
    
    setlocale(LC_ALL,"");
    // 2.初始化 ROS 节点
    ros::init(argc,argv,"control");
    ros::NodeHandle nh;
    // 3.创建发布者对象
    ros::Publisher pub = nh.advertise<geometry_msgs::Twist>("/turtle1/cmd_vel",1000);
    // 4.循环发布运动控制消息
    //4-1.组织消息
    geometry_msgs::Twist msg;
    msg.linear.x = 1.0;
    msg.linear.y = 0.0;
    msg.linear.z = 0.0;

    msg.angular.x = 0.0;
    msg.angular.y = 0.0;
    msg.angular.z = 2.0;

    //4-2.设置发送频率
    ros::Rate r(10);
    //4-3.循环发送
    while (ros::ok())
    {
    
    
        pub.publish(msg);

        ros::spinOnce();
    }


    return 0;
}

Implementación de Python

#! /usr/bin/env python
"""
    编写 ROS 节点，控制小乌龟画圆

    准备工作:
        1.获取topic(已知: /turtle1/cmd_vel)
        2.获取消息类型(已知: geometry_msgs/Twist)
        3.运行前，注意先启动 turtlesim_node 节点

    实现流程:
        1.导包
        2.初始化 ROS 节点
        3.创建发布者对象
        4.循环发布运动控制消息

"""

import rospy
from geometry_msgs.msg import Twist

if __name__ == "__main__":
    # 2.初始化 ROS 节点
    rospy.init_node("control_circle_p")
    # 3.创建发布者对象
    pub = rospy.Publisher("/turtle1/cmd_vel",Twist,queue_size=1000)
    # 4.循环发布运动控制消息
    rate = rospy.Rate(10)
    msg = Twist()
    msg.linear.x = 1.0
    msg.linear.y = 0.0
    msg.linear.z = 0.0
    msg.angular.x = 0.0
    msg.angular.y = 0.0
    msg.angular.z = 0.5

    while not rospy.is_shutdown():
        pub.publish(msg)
        rate.sleep()

3. Corre

1. empezar roscore
2. Inicie el nodo de visualización de tortugas.
3. Ejecutar nodo de control de movimiento

---

2. Suscripción al tema

Descripción del requisito: se sabe que el nodo de visualización de tortugas en Turtlesim publicará la pose actual de la tortuga (las coordenadas y la orientación de la tortuga en el formulario), y se requiere controlar el movimiento de la tortuga e imprimir la actual pose de la tortuga de vez en cuando.

El efecto es el siguiente:

Realizar análisis:

1. En primer lugar, debe iniciar los nodos de visualización y control de movimiento de la tortuga y controlar el movimiento de la tortuga.
2. Para obtener el tema y las noticias de la postura de la tortuga a través del comando ROS.
3. Escriba un nodo de suscripción, suscríbase e imprima la pose de la tortuga.

Proceso de implementación:

1. Obtenga información de temas y mensajes a través del comando ros.
2. Código para realizar el nodo de adquisición de pose.
3. Inicie roscore, turtlesim_node, nodo de control y nodo de suscripción de pose para controlar el movimiento de la tortuga y generar la pose de la tortuga.

1. Obtención de temas y noticias

Obtener tema:/turtle1/pose

rostopic list

Obtener tipo de mensaje:turtlesim/Pose

rostopic type /turtle1/pose

Obtener formato de mensaje:

rosmsg info turtlesim/Pose

Resultado de la respuesta:

float32 x
float32 y
float32 theta
float32 linear_velocity
float32 angular_velocity

2. Realizar el nodo de suscripción

Los paquetes de funciones en los que se debe confiar para crear un paquete de funciones:roscpp rospy std_msgs turtlesim

implementación de cpp:

/*  
    订阅小乌龟的位姿: 时时获取小乌龟在窗体中的坐标并打印
    准备工作:
        1.获取话题名称 /turtle1/pose
        2.获取消息类型 turtlesim/Pose
        3.运行前启动 turtlesim_node 与 turtle_teleop_key 节点

    实现流程:
        1.包含头文件
        2.初始化 ROS 节点
        3.创建 ROS 句柄
        4.创建订阅者对象
        5.回调函数处理订阅的数据
        6.spin
*/

#include "ros/ros.h"
#include "turtlesim/Pose.h"

void doPose(const turtlesim::Pose::ConstPtr& p){
    
    
    ROS_INFO("乌龟位姿信息:x=%.2f,y=%.2f,theta=%.2f,lv=%.2f,av=%.2f",
        p->x,p->y,p->theta,p->linear_velocity,p->angular_velocity
    );
}

int main(int argc, char *argv[])
{
    
    
    setlocale(LC_ALL,"");
    // 2.初始化 ROS 节点
    ros::init(argc,argv,"sub_pose");
    // 3.创建 ROS 句柄
    ros::NodeHandle nh;
    // 4.创建订阅者对象
    ros::Subscriber sub = nh.subscribe<turtlesim::Pose>("/turtle1/pose",1000,doPose);
    // 5.回调函数处理订阅的数据
    // 6.spin
    ros::spin();
    return 0;
}

Implementación de Python:

#! /usr/bin/env python
"""
    订阅小乌龟的位姿: 时时获取小乌龟在窗体中的坐标并打印
    准备工作:
        1.获取话题名称 /turtle1/pose
        2.获取消息类型 turtlesim/Pose
        3.运行前启动 turtlesim_node 与 turtle_teleop_key 节点

    实现流程:
        1.导包
        2.初始化 ROS 节点
        3.创建订阅者对象
        4.回调函数处理订阅的数据
        5.spin

"""

import rospy
from turtlesim.msg import Pose

def doPose(data):
    rospy.loginfo("乌龟坐标:x=%.2f, y=%.2f,theta=%.2f",data.x,data.y,data.theta)

if __name__ == "__main__":

    # 2.初始化 ROS 节点
    rospy.init_node("sub_pose_p")

    # 3.创建订阅者对象
    sub = rospy.Subscriber("/turtle1/pose",Pose,doPose,queue_size=1000)
    #     4.回调函数处理订阅的数据
    #     5.spin
    rospy.spin()

3. correr

Primero, comience roscore;

Luego inicie el nodo de visualización de tortugas y ejecute el nodo de control de movimiento;

Finalmente, inicie el nodo de suscripción de pose de tortuga;

El resultado final de la ejecución es similar al resultado de la demostración.

---

3. Llamada de servicio

**Descripción de los requisitos: **Implementación de codificación para enviar una solicitud a turtlesim y generar una tortuga en la posición especificada del formulario del nodo de visualización de tortugas, que es una operación de solicitud de servicio.

El efecto es el siguiente:

Realizar análisis:

1. Primero, se debe iniciar el nodo de visualización de la tortuga.
2. Para obtener el nombre del servicio y el tipo de mensaje del servicio generado por la tortuga a través del comando ROS.
3. Escriba un nodo de solicitud de servicio y genere una nueva tortuga.

Proceso de implementación:

1. Utilice el comando ros para obtener información sobre el servicio y los mensajes de servicio.
2. La codificación implementa el nodo de solicitud de servicio.
3. Inicie roscore, turtlesim_node y los nodos de generación de tortugas para generar nuevas tortugas.

1. Adquisición de nombre de servicio y mensaje de servicio

Obtener tema:/spawn

rosservice list

Obtener tipo de mensaje:turtlesim/Spawn

rosservice type /spawn

Obtener formato de mensaje:

rossrv info turtlesim/Spawn

Resultado de la respuesta:

float32 x
float32 y
float32 theta
string name
---
string name

2. Implementación del servidor

Cree un paquete de funciones que deba depender del paquete de funciones: roscpp rospy std_msgs turtlesim

Implementación de Cpp:

/*
    生成一只小乌龟
    准备工作:
        1.服务话题 /spawn
        2.服务消息类型 turtlesim/Spawn
        3.运行前先启动 turtlesim_node 节点

    实现流程:
        1.包含头文件
          需要包含 turtlesim 包下资源，注意在 package.xml 配置
        2.初始化 ros 节点
        3.创建 ros 句柄
        4.创建 service 客户端
        5.等待服务启动
        6.发送请求
        7.处理响应

*/

#include "ros/ros.h"
#include "turtlesim/Spawn.h"

int main(int argc, char *argv[])
{
    
    
    setlocale(LC_ALL,"");
    // 2.初始化 ros 节点
    ros::init(argc,argv,"set_turtle");
    // 3.创建 ros 句柄
    ros::NodeHandle nh;
    // 4.创建 service 客户端
    ros::ServiceClient client = nh.serviceClient<turtlesim::Spawn>("/spawn");
    // 5.等待服务启动
    // client.waitForExistence();
    ros::service::waitForService("/spawn");
    // 6.发送请求
    turtlesim::Spawn spawn;
    spawn.request.x = 1.0;
    spawn.request.y = 1.0;
    spawn.request.theta = 1.57;
    spawn.request.name = "my_turtle";
    bool flag = client.call(spawn);
    // 7.处理响应结果
    if (flag)
    {
    
    
        ROS_INFO("新的乌龟生成,名字:%s",spawn.response.name.c_str());
    } else {
    
    
        ROS_INFO("乌龟生成失败！！！");
    }


    return 0;
}

Implementación de Python:

#! /usr/bin/env python
"""
    生成一只小乌龟
    准备工作:
        1.服务话题 /spawn
        2.服务消息类型 turtlesim/Spawn
        3.运行前先启动 turtlesim_node 节点

    实现流程:
        1.导包
          需要包含 turtlesim 包下资源，注意在 package.xml 配置
        2.初始化 ros 节点
        3.创建 service 客户端
        4.等待服务启动
        5.发送请求
        6.处理响应

"""

import rospy
from turtlesim.srv import Spawn,SpawnRequest,SpawnResponse

if __name__ == "__main__":
    # 2.初始化 ros 节点
    rospy.init_node("set_turtle_p")
    # 3.创建 service 客户端
    client = rospy.ServiceProxy("/spawn",Spawn)
    # 4.等待服务启动
    client.wait_for_service()
    # 5.发送请求
    req = SpawnRequest()
    req.x = 2.0
    req.y = 2.0
    req.theta = -1.57
    req.name = "my_turtle_p"
    try:
        response = client.call(req)
        # 6.处理响应
        rospy.loginfo("乌龟创建成功!，叫:%s",response.name)
    except expression as identifier:
        rospy.loginfo("服务调用失败")

3. Corre

Primero, comience roscore;

Luego inicie el nodo de visualización de tortugas;

Finalmente, inicie la tortuga para generar el nodo de solicitud;

El resultado final de la ejecución es similar al resultado de la demostración.

---

4. Configuración de parámetros

Descripción del requisito: Modifique el color de fondo del formulario del nodo de visualización de tortugas Turtlesim.Se sabe que el color de fondo se establece en modo rgb a través del servidor de parámetros.

El efecto es el siguiente:

Realizar análisis:

1. Primero, se debe iniciar el nodo de visualización de la tortuga.
2. Obtener los parámetros para configurar el color de fondo en el servidor de parámetros a través del comando ROS.
3. Escriba un nodo de configuración de parámetros para modificar el valor del parámetro en el servidor de parámetros.

Proceso de implementación:

1. Obtener parámetros a través del comando ros.
2. La codificación se da cuenta del nodo de configuración de parámetros del servidor.
3. Inicie roscore, turtlesim_node y los nodos de configuración de parámetros para ver los resultados de la ejecución.

1. Obtención del nombre del parámetro

Obtenga la lista de parámetros:

rosparam list

Resultado de la respuesta:

/turtlesim/background_b
/turtlesim/background_g
/turtlesim/background_r

2. Modificación de parámetros

implementación de cpp

/*
    注意命名空间的使用。

*/
#include "ros/ros.h"


int main(int argc, char *argv[])
{
    
    
    ros::init(argc,argv,"haha");

    ros::NodeHandle nh("turtlesim");
    //ros::NodeHandle nh;

    // ros::param::set("/turtlesim/background_r",0);
    // ros::param::set("/turtlesim/background_g",0);
    // ros::param::set("/turtlesim/background_b",0);

    nh.setParam("background_r",0);
    nh.setParam("background_g",0);
    nh.setParam("background_b",0);


    return 0;
}

Implementación de Python

#! /usr/bin/env python

import rospy

if __name__ == "__main__":
    rospy.init_node("hehe")
    # rospy.set_param("/turtlesim/background_r",255)
    # rospy.set_param("/turtlesim/background_g",255)
    # rospy.set_param("/turtlesim/background_b",255)
    rospy.set_param("background_r",255)
    rospy.set_param("background_g",255)
    rospy.set_param("background_b",255)  # 调用时，需要传入 __ns:=xxx

3. Corre

Primero, comience roscore;

Luego inicie el nodo de configuración del color de fondo;

Finalmente inicie el nodo de visualización de tortugas;

El resultado final de la ejecución es similar al resultado de la demostración.

PD: preste atención al orden de inicio de los nodos. Si inicia primero el nodo de visualización de la tortuga y luego inicia el nodo de configuración del color de fondo, la configuración del color no tendrá efecto.

Referencia

http://www.autolabor.com.cn/book/ROSTutorials/di-2-zhang-ros-jia-gou-she-ji/23-fu-wu-tong-xin/224-fu-wu-tong- xin-zi-ding-yi-srv-diao-yong-b-python.html