学习笔记 9.22 -9.29 补

---

学习笔记一补充

随便写写，想写啥写啥

一、ROS1

1、WritingPublisherSubscriber

publisher > chatter > subscriber

1.1 Publisher

//ros提供的c++客户端
#include <ros/ros.h>
//使用ros的消息类型std_msgs::String
#include <std_msgs/String.h>
#include <sstream>

int main(int argc, char **argv)
{
//初始化ros节点并命名
  ros::init(argc, argv, "publish_node");
//初始化ros句柄
  ros::NodeHandle nh;
//在chatter这个话题上发布std_msgs::String类型的消息
  ros::Publisher chatter_pub = nh.advertise<std_msgs::String>("chatter", 1000);
//10Hz意味着1秒内触发10次
  ros::Rate loop_rate(10);
  int count = 0;

  while (ros::ok())
  {
    std_msgs::String msg;
    std::stringstream ss;
    ss << "how are you " << count;
    msg.data = ss.str();
    ROS_INFO("%s", msg.data.c_str());
//利用定义好的发布器对象将消息数据发布出去
    chatter_pub.publish(msg);
    ros::spinOnce();
    loop_rate.sleep();
    ++count;
  }
  return 0;
}

1.2 Subscriber

#include <ros/ros.h>
#include <std_msgs/String.h>
\\当有消息到达时会自动调用这里指定的chatterCallback回调函数
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, "subscribe_node");
  ros::NodeHandle nh;
  ros::Subscriber chatter_sub = nh.subscribe("chatter", 1000,chatterCallback);
\\这一句话让程序进入自循环的挂起状态，从而让程序以最好的效率接收消息并调用回调函数
  ros::spin();
  return 0;
}

2、WritingServerClient

client端节点向server端节点发送a、b的请求，server端节点返回响应sum=a+b给client端节点

配置依赖：

• 创建 AddTwoInts.srv 文件
• 编译依赖 message_generation，运行依赖 message_runtime
• 将 AddTwoInts.srv 添加到 add_service_files 中
• 在 generate_messages 中指明该依赖，由于我们定义的服务类型使用了 std_msgs 中的 int64 基本类型
• 修改 package.xml

2.1 Client

#include "ros/ros.h"
#include "service_example/AddTwoInts.h"
#include <iostream>
int main(int argc,char **argv)
{
  ros::init(argc,argv,"client_node");
  ros::NodeHandle nh;
  //创建client对象，用来向ROS网络中名称叫add_two_ints的service发起请求
  ros::ServiceClient client = nh.serviceClient<service_example::AddTwoInts>("add_two_ints");
  service_example::AddTwoInts srv;
  while(ros::ok())
  {
    long int a_in,b_in;
    std::cout<<"please input a and b:";
    std::cin>>a_in>>b_in;

    srv.request.a = a_in;
    srv.request.b = b_in;
    if(client.call(srv))
    {
      ROS_INFO("sum=%ld",(long int)srv.response.sum);
    }
    else
    {
      ROS_INFO("failed to call service add_two_ints");
    }
  }
  return 0;
}

2.2 Server

#include <ros/ros.h>
#include <service_example/AddTwoInts.h>
bool add_execute(service_example::AddTwoInts::Request &req,service_example::AddTwoInts::Response &res)
{
  res.sum = req.a + req.b;
  ROS_INFO("recieve request: a=%ld,b=%ld",(long int)req.a,(long int)req.b);
  ROS_INFO("send response: sum=%ld",(long int)res.sum);
  return true;
}
int main(int argc,char **argv)
{
  ros::init(argc,argv,"server_node");
  ros::NodeHandle nh;
  //创建服务，这个服务在ROS网络中以名称add_two_ints唯一标识
  ros::ServiceServer service = nh.advertiseService("add_two_ints",add_execute);
  ROS_INFO("service is ready!!!");
  ros::spin();
  return 0;
}

二、TF

1、Writing a tf broadcaster

• tf 让用户任何时间点完成两个坐标系之间点、向量之间的转换
• translation：3D平移向量，表示从目标坐标系到相对坐标系的平移量
• Rotation：旋转量，包括四元式（Quaternion）和欧拉角（RPY）

由于需要乌龟的位姿信息来计算它与世界坐标的转换关系，因此需要 pose 消息格式的头文件。可以通过编写订阅器来获取位姿信息。

create a Transform object, and copy the information from the 2D turtle pose into the 3D transform

tf::Transform transform;
transform.setOrigin( tf::Vector3(msg->x, msg->y, 0.0) );
tf::Quaternion q;
q.setRPY(0, 0, msg->theta);

• 根据获得的 msg 设置 transform
• 从 turtle_name/pose 订阅到的是 turtlesim 功能包中的 Pose 消息。Pose 消息用“rosmsg show turtlesim/Pose”查看到位置信息只有x，y。因为乌龟只活动在二维平面中，即 transform.setOrigin( tf::Vector3(msg->x, msg->y, 0.0) );
• 方向信息只有 theta，即绕着 z 轴的旋转角度，对应欧拉角 rpy 中的 yaw 即 q.setRPY(0, 0, msg->theta);

2、Writing a tf listener

该节点的主要任务是监听 tf 中 turtle2 到 turtl1 的转换，然后再将速度信息发送给 turtle2

tf 中坐标系总是右手系

#include <ros/ros.h>
#include <tf/transform_listener.h>
#include <geometry_msgs/Twist.h>
#include <turtlesim/Spawn.h>
int main(int argc, char** argv){
  //初始化节点
  ros::init(argc, argv, "my_tf_listener");
  ros::NodeHandle node;
  //等待spawn服务直到启动
  ros::service::waitForService("spawn");
  //然后创建spawn服务客户端，以及spawn服务
  ros::ServiceClient add_turtle =
    node.serviceClient<turtlesim::Spawn>("spawn");
  turtlesim::Spawn srv;
  //使用客户端调用服务
  add_turtle.call(srv);
  //创建消息发布器，将geometry_msgs::Twist类型的数据发布到turtle2/cmd_vel上，这个话题就是t2的速度
  ros::Publisher turtle_vel =
    node.advertise<geometry_msgs::Twist>("turtle2/cmd_vel", 10);
  tf::TransformListener listener;
  ros::Rate rate(10.0);
  while (node.ok()){
    tf::StampedTransform transform;
    try{
      //收集最近的从t1到t2的转换，并存到transform中
      listener.lookupTransform("/turtle2", "/turtle1",
                               ros::Time(0), transform);
    }
    catch (tf::TransformException &ex) {
      ROS_ERROR("%s",ex.what());
      ros::Duration(1.0).sleep();
      continue;
    }

    geometry_msgs::Twist vel_msg;
    vel_msg.angular.z = 4.0 * atan2(transform.getOrigin().y(),
                                    transform.getOrigin().x());
    vel_msg.linear.x = 0.5 * sqrt(pow(transform.getOrigin().x(), 2) +
                                  pow(transform.getOrigin().y(), 2));
    turtle_vel.publish(vel_msg);

    rate.sleep();
  }
  return 0;
};

3、Setting up your robot using tf

定义两个坐标系：一个以机器人移动平台的中心为原点，称为base_link，另一个以雷达中心为原点，称为base_laser参考系。使用坐标变换，将激光数据从base_laser变换到base_link中。

告诉tf这些转换公式，即可管理我们所需要的参考系变换，也就是说所有的变换关系都是父节点到子节点的变换。

通过TransformBroadcaster类发布变换关系的接口需要五个参数：

• 两个参考系之间的旋转变换，由于没有旋转，所以为0
• 位移变换
• 时间戳
• 母节点 base_link
• 子结点 bse_laser

使用TransformListener对象的transformPoint()函数即可将完成坐标转换，参数1为需要转换的坐标系，参数2为原始数据，参数3为坐标的存储。该函数完成后，base_point就是完成转换的坐标。

三、ROS 中使用摄像头

0、使用前设置

在关闭虚拟机的情况下，点击虚拟机设置，选中硬件，usb控制器，选择usb3.1，勾选显示所有usb输入设备。之后在虚拟机，可移动设备中将摄像头断开和主机的连接，并连接至虚拟机。

1、usb_cam

1.1 usb_cam 安装

$ cd catkin_ws/src  
$ git clone https://github.com/bosch-ros-pkg/usb_cam.git  
$ cd ..  
$ catkin_make  

1.2 usb_cam 使用

$ roscore
# new terminal
$ source ~/catkin_src/devel/setup.bash
$ cd 
$ roslaunch usb_cam-test.launch

2、uvc_cam

2.1 uvc_cam 安装

$ sudo apt-get install ros-kinetic-uvc-camera

2.2 uvc_cam 使用

$ roscore
$ source /opt/ros/kinetic/setup.bash
$ rosrun uvc_camera uvc_camera_node
$ rosrun image_view image_view image:=/image_raw

四、Kobuki 入门教程

1、安装

# Kobuki debs 包安装,Ecl和Yujin OCS包会一并安装
$ sudo apt-get install ros-kinetic-kobuki ros-kinetic-kobuki-core
# 配置udev别名
$ rosrun kobuki_ftdi create_udev_rules
# 启动底盘
$ roslaunch kobuki_node minimal.launch
# 键盘遥控
$ roslaunch kobuki_keyop keyop.launch

2、检测

# 启动
$ roslaunch kobuki_node minimal.launch --screen
# 检查话题
$ rostopic list

Kobuki 话题结构：

• <node_name>/sensor/: 传感器的连续数据流（注意：/odom和/joints_states默认重新映射，因为它们广泛应用在最顶层/命名空间）
• <node_name>/events/: 如果一个传感器改变了它的状态，例如保险杠被按下/释放，新的状态就在这里发布。
• <node_name>/commands/: 利用这些主题让Kobuki做开关LED，播放声音和跑动
• <node_name>/debug/: 输出关于Kobuki的许多内部详细的信息。

# 检查保险杠：监听bumper话题
$ rostopic echo /mobile_base/events/bumper
# 检查车轮跌落传感器：监听wheel_drop话题
$ rostopic echo /mobile_base/events/wheel_drop
# 检查IMU：监听IMU话题
$ rostopic echo /mobile_base/sensors/imu_data
# 改变颜色或关闭LED:发布话题
$ rostopic pub /mobile_base/commands/led1 kobuki_msgs/Led "value: 1"
$ rostopic pub /mobile_base/commands/led1 kobuki_msgs/Led "value: 0"
# 播放声音
$ rostopic pub /mobile_base/commands/sound kobuki_msgs/Sound "value: 6"
# 命令前进：发布velocity命令话题
$ rostopic pub /mobile_base/commands/velocity geometry_msgs/Twist "linear:
  x: 1.0
  y: 0.0
  z: 0.0
angular:
  x: 0.0
  y: 0.0
  z: 0.0"

3、检测

使用 Robot Monitor GUI(机器人监视器)

# 安装
$ sudo apt-get install ros-kinetic-rqt-robot-monitor
# 启动
$ rosrun rqt_robot_monitor rqt_robot_monitor

4、仿真

# 安装
$ sudo apt-get install ros-kinetic-kobuki-soft
# 执行
$ roslaunch kobuki_softnode full.launch
# 查看 rviz
# 设置 fixed frame '/odom'
# 增加 RobotModel
$ rosrun rviz rviz
# 遥控
$ roslaunch kobuki_keyop keyop.launch
# 安装导航相关包
$ sudo apt-get install ros-kinetic-turtlebot-apps
$ sudo apt-get install ros-kinetic-turtlebot-viz
$ sudo apt-get install ros-kinetic-navigation
$ sudo apt-get install ros-kinetic-yujin-maps
# 执行
$ roslaunch kobuki_softapps nav_demo.launch

5、练习

让 kobuki 走直线，同理转弯也能实现，来源

通过修改 loopRate 完成自己想要让 kobuki 走的路线