高斯机械臂培训教程

欢迎来到Tonyrobotics(汤尼机器人)推出的高斯机械臂培训教程！

第一天上午 机械臂介绍和Studio使用

目标：了解工业机器人的使用场景、基本组成和原理，熟悉高斯机械臂的功能，了解高斯机械臂的软件架构

0.工业机器人的使用场景和基本原理

0.1 工业机器人的使用场景

工业机器依据具体应用的不同，通常可以分成焊接机器人、装配机器人、喷漆机器人、码垛机器人、搬运机器人等多种类型。

• 焊接机器人，包括点焊（ 电阻焊） 和电弧焊机器人，用途是实现自动的焊接作业。
• 装配机器人，比较多地用于电子部件电器的装配。
• 喷漆机器人，代替人进行喷漆作业。
• 码垛、上下料、搬运机器人的功能则是根据一定的速度和精度要求，将物品从一处运到另一处。

在工业生产中应用机器人，可以方便迅速地改变作业内容或方式，以满足生产要求的变化。 比如， 改变焊缝轨迹， 改变喷漆位置， 变更装配部件或位置等等。随着对工业生产线柔性的要求越来越高， 对各种机器人的需求也就越来越强烈。

0.2 机器人的基本组成和原理

机器人是典型的机电一体化产品， 一般由机械本体、 控制系统、 传感器、 和驱动器等四部分组成。 机械本体是机器人实施作业的执行机构。为对本体进行精确控制，传感器应提供机器人本体或其所处环境的信息，控制系统依据控制程序产生指令信号， 通过控制各关节运动坐标的驱动器， 使各臂杆端点按照要求的轨迹、 速度和加速度， 以一定的姿态达到空间指 定的位置。驱动器将控制系统输出的信号变换成大功率的信号， 以驱动执行器工作。

1．机械本体

机械本体， 是机器人赖以完成作业任务的执行机构， 一般是一台机械手， 也称操作器、或操作手， 可以在确定的环境中执行控制系统指定的操作。 典型工业机器人的机械本体一般由手部（ 末端执行器） 、 腕部、 臂部、 腰部和基座构成。 机械手多采用关节式机械结构， 一般具有6个自由度， 其中3个用来确定末端执行器的位置， 另外3个则用来确定末端执行装置 的方向（ 姿势） 。 机械臂上的末端执行装置可以根据操作需要换成焊枪、 吸盘、 扳手等作业工具。

2．控制系统

控制系统是机器人的指挥中枢， 相当于人的大脑功能， 负责对作业指令信息、 内外环境信息进行处理， 并依据预定的本体模型、 环境模型和控制程序做出决策， 产生相应的控制信号， 通过驱动器驱动执行机构的各个关节按所需的顺序、 沿确定的位置或轨迹运动， 完成特定的作业。 从控制系统的构成看， 有开环控制系统和闭环控制系统之分； 从控制方式看有程 序控制系统、 适应性控制系统和智能控制系统之分。

3．驱动器

驱动器是机器人的动力系统， 相当于人的心血管系统， 一般由驱动装置和传动机构两部分组成。 因驱动方式的不同， 驱动装置可以分成电动、 液动和气动三种类型。 驱动装置中的电动机、 液压缸、 气缸可以与操作机直接相连， 也可以通过传动机构与执行机构相连。 传动机构通常有齿轮传动、 链传动、 谐波齿轮传动、 螺旋传动、 带传动等几种类型。

4．传感器

传感器是机器人的感测系统， 相当于人的感觉器官， 是机器人系统的重要组成部分， 包括内部传感器和外部传感器两大类。 内部传感器主要用来检测机器人本身的状态， 为机器人的运动控制提供必要的本体状态信息， 如位置传感器、 速度传感器等。 外部传感器则用来感知机器人所处的工作环境或工作状况信息，又可分成环境传感器和末端执行器传感器两种类型； 前者用于识别物体和检测物体与机器人的距离等信息， 后者安装在末端执行器上， 检测 处理精巧作业的感觉信息。 常见的外部传感器有力觉传感器、 触觉传感器、 接近觉传感器、视觉传感器等。

0.3 机械臂基本原理思维导图

参考：

1. https://github.com/ros-industrial
2. http://wiki.ros.org/Robots/
3. https://industrial-training-master.readthedocs.io/en/melodic/
4. https://robots.ros.org/
5. https://github.com/ros-industrial/kuka_experimental

1.高斯机械臂介绍和Studio的使用

本章节为机械臂操作部分，包括：

1. 机械臂开机和网络模式切换
2. 示教模式切换
3. 关节空间运动
4. 笛卡尔空间运动
5. 手持示教
6. 夹爪使用
7. 气泵使用
8. 电磁铁使用
9. Blockly编程
10. 视觉抓取

2. 高斯机械臂的软件架构

2.1.软件架构

上图为高斯机械臂的软件架构图。

1、圆角矩形为 ROS Package （ROS软件包），gauss_commander、gauss_moveit、gauss_driver、gauss_rpi、gauss_tools为核心包。

gauss_python_api 提供Python api，gauss_user_interface提供blockly功能和手柄功能，gauss_userinterface的功能实现基本是调用了gauss_python_api实现的。

2、白色矩形为各个ROS包实现的功能，如gauss_driver 通过mcp_can_api和dynamixelsdk实现了SPI通信和串口通信。gaussrpi和gauss_tools通过GPIO实现了按钮、LED、工具控制等功能。

3、蓝色矩形为其他功能包，gauss_ikfast_gauss_arm_plugin为运动学逆解插件，gauss_msgs为自定义的ROS消息，gauss_description为机械臂的URDF描述文件等。

4、紫色矩形 gauss_bringup 为整个机械臂的入库文件以及全局的配置文件，可以通过这个功能包一键启动所有功能包、启动gauss_driver等。

2.2.ros_control

ROS中提供了丰富的机器人应用：SLAM、导航、MoveIt……但是你可能一直有一个疑问，这些功能包到底应该怎么样用到我们的机器人上，也就是说在应用和实际机器人或者机器人仿真器之间，缺少一个连接两者的东西。

ros_control就是ROS为用户提供的应用与机器人之间的中间件，包含一系列控制器接口、传动装置接口、硬件接口、控制器工具箱等等，可以帮助机器人应用快速落地，提高开发效率。

参考：

1. http://wiki.ros.org/ros_control
2. https://github.com/frankaemika/franka_ros
3. https://github.com/ros-industrial/universal_robot
4. https://github.com/RethinkRobotics/sawyer_robot

第一天下午 ROS基本概念和简单命令的使用

目标：了解ROS基本概念，熟悉基本指令的使用

3.ROS介绍和基本概念

3.1 ROS是什么

官方定义：ROS(Robot Operating System)是面向机器人的开源的元操作系统(meta-operating system)。它能够提供类似传统操作系统的诸多功能,如硬件抽象、底层设备控制、常用功能实现、进程间消息传递和程序包管理等。此外,它还提供相关工具和库,用于获取、编译、编辑代码以及在多个计算机之间运行程序完成分布式计算。

ROS = 管道+工具+能力+生态

3.2 ROS版本介绍

ROS版本	electric	fuerte	groovy	hydro	indigo
Ubuntu	10.04 11.10	10.04 11.10 12.04	11.10 12.04 12.10	12.04 12.10 13.04	13.10 14.04

ROS版本	jade	kinetic	luna	melodic
Ubuntu	14.04 14.10 15.04	15.10 16.04	16.04 16.10 17.04	17.10 18.04

3.3 ROS安装方法

官方教程具有十分详细的介绍。

步骤1 添加Ubuntu源地址：

$ sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'

注意： 有时使用系统默认源速度会较慢，并且缺少依赖。此时，可将Ubuntu源设置为中科大的，打开/etc/apt/sources.list文件：

$ sudo gedit /etc/apt/sources.list

改为以下内容(以Ubuntu 16.04为例)：

deb http://mirrors.ustc.edu.cn/ubuntu/ xenial main restricted universe multiverse
deb http://mirrors.ustc.edu.cn/ubuntu/ xenial-security main restricted universe multiverse
deb http://mirrors.ustc.edu.cn/ubuntu/ xenial-updates main restricted universe multiverse
deb http://mirrors.ustc.edu.cn/ubuntu/ xenial-proposed main restricted universe multiverse
deb http://mirrors.ustc.edu.cn/ubuntu/ xenial-backports main restricted universe multiverse
deb-src http://mirrors.ustc.edu.cn/ubuntu/ xenial main restricted universe multiverse
deb-src http://mirrors.ustc.edu.cn/ubuntu/ xenial-security main restricted universe multiverse
deb-src http://mirrors.ustc.edu.cn/ubuntu/ xenial-updates main restricted universe multiverse
deb-src http://mirrors.ustc.edu.cn/ubuntu/ xenial-proposed main restricted universe multiverse
deb-src http://mirrors.ustc.edu.cn/ubuntu/ xenial-backports main restricted universe multiverse

步骤2 设置安全公钥：

$ sudo apt-key adv --keyserver hkp://ha.pool.sks-keyservers.net:80 --recv-key 421C365BD9FF1F717815A3895523BAEEB01FA116

步骤3 更新源：

$ sudo apt update

步骤4 安装：

$ sudo apt install ros-kinetic-desktop-full

或安装其它包：

$ sudo apt install ros-kinetic-ros-base
$ sudo apt install ros-kinetic-navigation
$ sudo apt install ros-kinetic-gmapping

步骤5 安装完后，导出环境变量：

$ source /opt/ros/kinetic/setup.bash

如果不想每次打开终端都导出环境变量，可将其添加到.bashrc文件中：

$ echo "source /opt/ros/kinetic/setup.bash" >> ~/.bashrc

3.4 ROS通信机制

ROS整个通信机制的核心就是：发布订阅机制。例如下图：名为Talker的节点向/chatter主题发送字符串”hello”，另一个名为Listener的节点订阅/chatter主题，接收主题的字符串。

注意：每个主题跟消息类型是绑定的。比如，一个接收string类型消息的主题，是不能接收int数据类型消息的。

下面是一个更具体的例子，即底盘导航模块所用到的节点及主题。

3.5 ROS包、节点的创建

ROS中工作区、包、节点的概念类比：

ROS	Visual Studio
工作区(workspace)	解决方案(solution)
包(package)	工程(project)
节点(node)	可执行文件(executable)

创建工作区

工作区即一个目录，用mkdir命令创建即可：

$ cd ~
$ mkdir catkin_ws

在工作区目录下，创建名为src的文件夹：

$ cd ~/catkin_ws
$ mkdir src

此时的目录结构：

~
|--catkin_ws
    |--src

创建ROS包

$ cd ~/catkin_ws/src
$ catkin_create_pkg trd_driver

此时的目录结构：

~
|--catkin_ws
    |--src
        |--trd_driver
            |--CMakeLists.txt
            |--package.xml

添加节点(C++源代码)

$ cd ~/catkin_ws/src/trd_driver
$ mkdir src
$ cd src
$ gedit hello_world_node.cpp

编辑hello_world_node.cpp内容:

#include "ros/ros.h"
int main() {
    ROS_INFO("hello world!");
    return 0;
}

修改~/catkin_ws/src/trd_driver/CMakeLists.txt内容：

$ gedit ~/catkin_ws/src/trd_driver/CMakeLists.txt

cmake_minimum_required(VERSION 2.8.3)
project(trd_driver)

find_package(catkin REQUIRED
    roscpp
)
catkin_package(CATKIN_DEPENDS
)

include_directories(
  include
  ${catkin_INCLUDE_DIRS}
)

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

此时的目录结构：

~
|--catkin_ws
    |--src
        |--trd_driver
            |--CMakeLists.txt
            |--package.xml
            |--src
                |--hello_world_node.cpp

编译运行节点

编译：

$ cd ~/catkin_ws
$ catkin_make

~
|--catkin_ws
    |--lib #编译结果目录
    |--devel #编译结果目录
    |--src
        |--trd_driver
            |--CMakeLists.txt
            |--package.xml
            |--src
                |--hello_world_node.cpp

• 运行(方式一)：

$ cd ~/catkin_ws
$ ./devel/lib/trd_driver/hello_world_node

• 运行(方式二)：

先将此工作区下的ROS包导出到环境变量，然后用ros run指令启动：

$ cd ~/catkin_ws
$ source ./devel/setup.bash
$ rosrun trd_driver hello_world_node

• 运行(方式三)：

建立launch文件，用launch文件启动。

$ cd ~/catkin_ws/src/trd_driver
$ mkdir launch
$ cd launch
$ gedit trd_driver.launch

编辑launch文件内容：

<?xml version="1.0"?>
<launch>
    <node pkg="trd_driver" type="hello_world_node" name="hello_world_node">
    </node>
</launch>

启动launch文件（需要保证已经source当前工作区）：

$ roslaunch trd_driver trd_driver.launch

若需要打印节点的log输出，可在启动时加入 –screen 参数：

$ roslaunch trd_driver trd_driver.launch --screen

3.6 编写ROS订阅、发布节点(C++)

参照 hello_world_node 开发方式，创建一个名为 talker_node 的发布者节点 和一个名为 listener_node 订阅者节点。分别加入以下源代码并编译运行。

发布者节点

功能：以10Hz的频率，向/chatter主题发布”hello x”(x为计数)字符串。

trd_driver/src/talker_node.cpp

#include "ros/ros.h"
#include "std_msgs/String.h"
#include <sstream>

int main(int argc, char *argv[]) {
    ros::init(argc, argv, "talker"); //初始化节点,名称为"talker"
    ros::NodeHandle nh; //创建节点句柄
    ros::Publisher pub =
         nh.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 " << count;
        msg.data = ss.str(); //消息赋值
        ROS_INFO("send [%s]", msg.data.c_str());

        pub.publish(msg); //发布消息
        ros::spinOnce(); //非阻塞调用
        loop_rate.sleep();
        ++count;
    }
    return 0;
}

订阅者节点

功能：订阅/chatter主题，并打印收到的内容。

trd_driver/src/listener_node.cpp

#include "ros/ros.h"
#include "std_msgs/String.h"

void subCallback(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"); //初始化节点,名称为"listener"
    ros::NodeHandle nh;//创建节点句柄
    ros::Subscriber sub =
         nh.subscribe("chatter", 1000, subCallback); //创建订阅者
    ros::spin(); //阻塞调用
    return 0;
}

CMakeLists.txt

修改 trd_driver/CMakeLists.txt 内容，添加两节点。

trd_driver/CMakeLists.txt

cmake_minimum_required(VERSION 2.8.3)
project(trd_driver)

find_package(catkin REQUIRED
    roscpp
)
catkin_package(CATKIN_DEPENDS
)

include_directories(
  include
  ${catkin_INCLUDE_DIRS}
)

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

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

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

运行发布者和订阅者

为了避免每次启动终端，都要导出当前工作区环境变量， 可以将导出命令加入到当前用户的 ~/.bashrc 文件中：

$ echo "source ~/catkin_ws/devel/setup.bash" >> ~/.bashrc

打开新的终端，启动 roscore ：

$ roscore

打开新的终端，启动 talker_node 节点：

$ rosrun trd_driver talker_node

打开新的终端，启动 listener_node 节点：

$ rosrun trd_driver listener_node

此时，可看到订阅者打印接收到的内容。

3.7 编写ROS订阅、发布节点(Python)

请参照官方教程自行尝试。

3.8 ROS学习网站

• ROS维基网站： http://wiki.ros.org/
• ROS官方教程: http://wiki.ros.org/ROS/Tutorials
• ROS Answers论坛： answers.ros.org
• 创客智造： https://www.ncnynl.com/

3.9 ROS学习书籍

1. A Gentle Introduction to ROS

(英文版) 链接: https://pan.baidu.com/s/1WtsiWh7o542KCgSNMR8ugQ 密码: ci3k

(中文版) 链接: https://pan.baidu.com/s/1skP5o819hZE1OsXypFD_Gw 密码: p8f9

2. Learning ROS for Robotics Programming

链接: https://pan.baidu.com/s/1sjegN3w_ehvhxT00d1xBiw 密码: bnce

3. Programming Robots with ROS: A Practical Introduction to the Robot Operating System

链接: https://pan.baidu.com/s/1QkqD-Zu_i3KJNCn0xSsKng 密码: qd82

4. Robot Operating System (ROS)The Complete Reference

链接: https://pan.baidu.com/s/1d4UZd3Ast9SxPhz8HZh9gg 密码: ep42

4.ROS的基本使用和命令

4.1 ROS常用指令

• roscore：启动ROS master主服务
• rviz：可视化工具(地图、图片、点云、机器人模型… …)
• rqt_reconfigure：配置参数界面
• rqt_graph：弹出所有节点/主题关系可视化界面
• rosnode list：列出正在运行的节点
• rosnode info node_name：打印节点信息
• rosnode kill node_name：停止某个节点
• rosrun package node：启动package包下的node节点
• rostopic list：列出正在运行的topic名字列表
• rostopic info：打印topic类型信息
• rostopic echo：打印topic实时数据信息
• roscd package：切换到package包所在路径
• rosed package abc.cpp：用编辑器打开package包下的abc.cpp文件
• rosservice list：列出正在运行的service名字列表
• rosservice info service_name：打印service类型信息
• roslaunch launch_file_name：启动launch文件
• roslaunch-deps abc.launch：列出launch文件中依赖的package
• rosmsg list：已安装msg名字列表
• rosmsg show msg_name：已安装msg类型信息
• rosmsg package 包名：包包含的所有msg名
• rospack list： 列出已安装的包
• rosstack list：列出已安装的元包
• rosbag record topic_name -O abc.bag：记录topic到abc.bag文件
• rosbag play abc.bag：播放bag文件
• roswtf：打印错误检查
• rossrv list：已安装srv名字列表
• rossrv show srv_name：已安装srv类型信息
• rossrv package 包名：包包含的所有srv名

第二天上午 机械臂编程实践

目标：学会使用Python API 和 ROS API 开发机械臂

5.使用Python API开发机械臂

5.1.关节坐标系下的机械臂控制

#!/usr/bin/env python

import rospy
from gauss_python_api.gauss_api import Gauss

def test_move_joint(gauss):
    joints = [1.5,0,0,0,0,0]
    try:
        message = gauss.move_joints(joints)
    except Exception as e:
        print e
    else:
        print message

if __name__ == '__main__':

    rospy.init_node('gauss_move_joint')
    g = Gauss()
    test_move_joint(g)
    rospy.spin()

5.2.笛卡尔坐标系下的运动规划及控制

#!/usr/bin/env python

import rospy
from gauss_python_api.gauss_api import Gauss

def test_move_pose(gauss):
    pose = [300.5/1000, 4.0/1000, 338.3/1000, 0, 0, 0]
    try:
        message = gauss.move_pose(*pose)
    except Exception as e:
        print e
    else:
        print message

if __name__ == '__main__':

    rospy.init_node('gauss_move_pose')
    g = Gauss()
    test_move_pose(g)
    rospy.spin()

5.3.使用夹爪

#!/usr/bin/evn python

from gauss_python_api.gauss_api import *
import rospy
rospy.init_node('gauss_generated_code_execution')
n = Gauss()
n.change_tool(TOOL_GRIPPER_1_ID)
n.open_gripper(TOOL_GRIPPER_1_ID, 100)
n.wait(5)
n.close_gripper(TOOL_GRIPPER_1_ID, 100)

5.4.使用气泵

#!/usr/bin/env python

from gauss_python_api.gauss_api import *
import rospy
rospy.init_node('gauss_generated_code_execution')
n = Gauss()
n.change_tool(TOOL_VACUUM_PUMP_1_ID)
for count in range(3):
    n.pull_air_vacuum_pump(TOOL_VACUUM_PUMP_1_ID)
    n.wait(2)
    n.push_air_vacuum_pump(TOOL_VACUUM_PUMP_1_ID)

5.5.使用电磁铁

#!/usr/bin/env python

from gauss_python_api.gauss_api import *
import rospy
rospy.init_node('gauss_generated_code_execution')
n = Gauss()
n.change_tool(TOOL_ELECTROMAGNET_1_ID)
n.setup_electromagnet(TOOL_ELECTROMAGNET_1_ID, GPIO_2D)
n.activate_electromagnet(TOOL_ELECTROMAGNET_1_ID, GPIO_2D)
n.wait(5)
n.deactivate_electromagnet(TOOL_ELECTROMAGNET_1_ID, GPIO_2D)

5.6.机械臂的状态查看

查看关节状态

#!/usr/bin/evn python

import rospy
from sensor_msgs.msg import JointState

def callback_joint_states(joint_states):
    rospy.loginfo(list(joint_states.position))

def listener():
    rospy.init_node('node_name')
    joint_state_subscriber = rospy.Subscriber('/joint_states',
                JointState, callback_joint_states)

    # spin() simply keeps python from exiting until this node is stopped
    rospy.spin()

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

执行结果如下：

gauss@gauss-ros:~$ python joint_states_suscriber.py
[INFO /node_name 2019-03-21 15:56:40]: [-0.0, 0.5215757805660216, -0.3208912496166717, -0.0667588438887831, 0.005061454830783556, -0.015184364492350666]
[INFO /node_name 2019-03-21 15:56:40]: [-0.0, 0.5215757805660216, -0.3208912496166717, -0.06283185307179585, 0.005061454830783556, -0.010122909661567111]
[INFO /node_name 2019-03-21 15:56:40]: [-0.0, 0.5215757805660216, -0.3208912496166717, -0.0667588438887831, 0.005061454830783556, -0.015184364492350666]
[INFO /node_name 2019-03-21 15:56:40]: [-0.0, 0.5215757805660216, -0.3208912496166717, -0.06283185307179585, 0.005061454830783556, -0.015184364492350666]
[INFO /node_name 2019-03-21 15:56:41]: [-0.0, 0.5215757805660216, -0.3208912496166717, -0.0667588438887831, 0.005061454830783556, -0.015184364492350666]
[INFO /node_name 2019-03-21 15:56:41]: [-0.0, 0.5215757805660216, -0.3208912496166717, -0.0667588438887831, 0.005061454830783556, -0.015184364492350666]

查看空间状态

#!/usr/bin/evn python

import rospy
from sensor_msgs.msg import JointState
from gauss_msgs.msg import RobotState

def callback_robot_state(robot_state):
    rospy.loginfo("~~~~~~~~~~~~~~~~~~")
    rospy.loginfo("heard: x %f", robot_state.position.x)
    rospy.loginfo("heard: y %f", robot_state.position.y)
    rospy.loginfo("heard: z %f", robot_state.position.z)
    rospy.loginfo("heard: r %f", robot_state.rpy.roll)
    rospy.loginfo("heard: p %f", robot_state.rpy.pitch)
    rospy.loginfo("heard: y %F", robot_state.rpy.yaw)

def listener():
    rospy.init_node('node_name')
    robot_state_subscriber = rospy.Subscriber('/gauss/robot_state',
                RobotState, callback_robot_state)

    # spin() simply keeps python from exiting until this node is stopped
    rospy.spin()

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

执行结果如下：

[INFO /node_name 2019-03-21 16:11:19]: ~~~~~~~~~~~~~~~~~~
[INFO /node_name 2019-03-21 16:11:19]: heard: x 0.178259
[INFO /node_name 2019-03-21 16:11:19]: heard: y 0.000009
[INFO /node_name 2019-03-21 16:11:19]: heard: z 0.466048
[INFO /node_name 2019-03-21 16:11:19]: heard: r -0.082013
[INFO /node_name 2019-03-21 16:11:19]: heard: p -0.205735
[INFO /node_name 2019-03-21 16:11:19]: heard: y 0.000345
[INFO /node_name 2019-03-21 16:11:19]: ~~~~~~~~~~~~~~~~~~
[INFO /node_name 2019-03-21 16:11:19]: heard: x 0.178259
[INFO /node_name 2019-03-21 16:11:19]: heard: y 0.000009
[INFO /node_name 2019-03-21 16:11:19]: heard: z 0.466048
[INFO /node_name 2019-03-21 16:11:19]: heard: r -0.082013
[INFO /node_name 2019-03-21 16:11:19]: heard: p -0.205735
[INFO /node_name 2019-03-21 16:11:19]: heard: y 0.000345

5.7.示教模式切换

示教模式

gauss@gauss-ros:~$ rosservice call /gauss/activate_learning_mode "value: 1"
status: 200
message: "Activating learning mode"

非示教模式

gauss@gauss-ros:~$ rosservice call /gauss/activate_learning_mode "value: 0"
status: 200
message: "Deactivating learning mode"

参考：

1. http://www.downza.cn/soft/235505.html
2. http://www.onlinedown.net/soft/20088.htm
3. https://www.pythontab.com/
4. https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000
5. http://cn.linux.vbird.org/
6. https://bellard.org/jslinux/

6.使用ROS API开发机械臂

6.1.关节空间空间规划

#!/usr/bin/env python

import roslib
# roslib.load_manifest('actionlib_test')
import rospy
import actionlib

from gauss_msgs.msg import RobotMoveAction
from gauss_msgs.msg import RobotMoveGoal
from gauss_msgs.msg import RobotMoveResult
from gauss_commander.command_type import CommandType as MoveCommandType

if __name__ == '__main__':
    rospy.init_node('robot_action_client')

    client = actionlib.SimpleActionClient('/gauss/commander/robot_action', RobotMoveAction)
    if not client.wait_for_server(rospy.Duration(5.0)):
        exit
    goal = RobotMoveGoal()
    goal.cmd.cmd_type = MoveCommandType.JOINTS
    goal.cmd.joints = [0,0,0,0,0,0]
    client.send_goal(goal)
    client.wait_for_result(rospy.Duration.from_sec(10.0))
    result = client.get_result()

6.2.笛卡尔空间规划

#!/usr/bin/env python

import roslib
# roslib.load_manifest('actionlib_test')
import rospy
import actionlib

from gauss_msgs.msg import RobotMoveAction
from gauss_msgs.msg import RobotMoveGoal
from gauss_msgs.msg import RobotMoveResult
from gauss_commander.command_type import CommandType as MoveCommandType

if __name__ == '__main__':
    rospy.init_node('robot_action_client')

    client = actionlib.SimpleActionClient('/gauss/commander/robot_action', RobotMoveAction)
    if not client.wait_for_server(rospy.Duration(5.0)):
        exit
    goal = RobotMoveGoal()
    goal.cmd.cmd_type = MoveCommandType.POSE
    goal.cmd.position.x = 0.3005
    goal.cmd.position.y = 0.0004
    goal.cmd.position.z = 0.3383

    goal.cmd.rpy.roll = 0
    goal.cmd.rpy.pitch = 0
    goal.cmd.rpy.yaw = 0
    client.send_goal(goal)
    client.wait_for_result(rospy.Duration.from_sec(10.0))
    result = client.get_result()

7.Moveit!的介绍和简单使用

7.1.Moveit! 运动规划框架介绍

在实现机械臂的自主抓取中机械臂的运动规划是其中最重要的一部分，其中包含运动学正逆解算、碰撞检测、环境感知和动作规划等。Gauss机械臂的运动规划采用的是ROS系统提供的MoveIt! 规划。

MoveIt! 是ROS系统中集合了与移动操作相关的组件包的运动规划库。它包含了运动规划中所需要的大部分功能，同时其提供友好的配置和调试界面便于完成机器人在ROS系统上的初始化及调试，其具体架构如下图所示：

（1）move_group: move_group是MoveIt!的核心部分，它的功能在于集成机器人的各独立模块并为用户提供一系列的动作指令和服务。其本身并不具备太多的功能，起到的是积分器的作用，完成各功能包和插件的集成。

（2）场景规划（Planning Scene）: 通过场景规划，用户可以创建一个具体的工作环境或者加入障碍物。

（3）运动规划（motion panning): 在MoveIt!中，运动规划器起的作用是实现运动规划算法，其以插件的方式通过ROS的pluginlib接口完成信息的通讯，根据需求可制作或选用不同的规划算法。

（4）运动学（Kinematics）： 运动学算法是机械臂控制算法中的核心内容，其中包括正运动学算法和逆运动学算法，在MoveIt!中，运动学算法同样以插件的形式完成于ROS的集成，因此可根据实际需求，编写自己的运动学算法来控制机器人。

（5）碰撞检测（collision checking）： 为避免机器人自身或者和环境发生干涉导致意外的发生，在进行运动规划时碰撞检测是必不可少的一部分，在MoveIt!中，采用FCL（Flexible Collision Library）进行对象碰撞的运算。

（6）开源运动规划库（open motion planning library）: OMPL是一个的开源的C++库，主要用于运动规划，其中包含了大量用于运动规划的先进算法。该库中的算法以采样规划算法为主，通过其可以实现不同目标点之间的路径规划。

7.2.Moveit! 助手

Moveit！的配置助手可以将编写好的urdf文件生成srdf文件，并从而生成Moveit!的功能包。

启动Moveit!助手：

roslaunch moveit_setup_assistant setup_assistant.launch

Moveit!配置助手界面如下图所示：

选择编辑已存在的Moveit!配置包

配置加载完毕

生成碰撞矩阵

MoveIt！可以让我们设置一定数量的随机采样点，根据这些点生成配装参数，可想而知，过多的点会造成运算速度慢，过少的点会导致参数不完善，默认的采样点数量是10000个。

官方称经过实践，要获得不错的效果，10000是最低要求，我们就按照这个默认值生成碰撞矩阵。

碰撞矩阵列出了所有不能相互碰撞的杆件，例如，由于运动关系约束，机器人手腕不能与基座产生碰撞。当涉及到机器人运动规划的时候，不检查这些连接对于碰撞的影响，节省CPU运行时间，提高检测效率。

虚拟关节

虚拟关节主要是用来描述机器人在world坐标系下的位置，如果机器人是移动的，虚拟关节可以与移动基座关联，不过一般的机械臂都是固定不动的，所以也可以不需要虚拟关节。

规划组

这一步可以将机器人的多个组成部分（links，joints）集成到一个组当中，运动规划会针对一组links或joints完成运动规划，在配置个过程中还可以选择运动学解析器（ kinematic solver）。

定义机器人位姿

这里可以设置一些固定的位置，比如说机器人的零点位置、初始位置等等，当然这些位置是用户根据场景自定义的，不一定要和机器人本身的零点位置、初始位置相同。这样做的好处就是我们使用MoveIt！的API编程时，可以直接调用这些位置。

定义末端执行器

机械臂在一些实用场景下，会安装夹具等终端结构，可以在这一步中添加。

定义被动关节

机器人上的某些关节，可能在规划、控制过程中使用不到，可以先声明出来，这里没有就不用管了。

生成配置文件

7.3.Moveit! 的基本接口及使用

Moveit的接口在 move_group。

MoveGroupCommander 类常用的api列表如下：

• get_current_joint_values
• set_joint_value_target
• get_current_pose
• set_pose_target
• plan
• compute_cartesian_path
• go
• set_max_velocity_scaling_factor
• set_max_acceleration_scaling_factor
• execute
• set_path_constraints

#!/usr/bin/env python

import sys
import copy
import rospy
import moveit_commander
import moveit_msgs.msg
import geometry_msgs.msg

print "============ Starting tutorial setup"
moveit_commander.roscpp_initialize(sys.argv)
rospy.init_node('move_group_python_interface_tutorial',
                        anonymous=True)

robot = moveit_commander.RobotCommander()
group = moveit_commander.MoveGroupCommander("gauss_arm")
print "============ planning frame Reference frame: %s" % group.get_planning_frame()
print "============ end effector Reference frame: %s" % group.get_end_effector_link()

print "============ Printing robot state"
print robot.get_current_state()

group_variable_values = group.get_current_joint_values()
print "============ Joint values: ", group_variable_values

group_variable_values[0] = 1.0
group.set_joint_value_target(group_variable_values)

plan = group.plan()
rospy.sleep(5)
group.go(wait=True)

print "move complete"

参考：

1. https://moveit.ros.org/documentation/planners/
2. http://moveit.ros.org/documentation/
3. http://moveit.ros.org/documentation/concepts/
4. https://blog.csdn.net/kalenee/article/details/80818658
5. http://ompl.kavrakilab.org/planners.html
6. https://www.ncnynl.com/archives/201610/1030.html
7. https://blog.csdn.net/wxflamy/article/details/79171337
8. https://blog.csdn.net/wxflamy/article/details/79160781
9. https://github.com/ros-planning/moveit
10. http://docs.ros.org/kinetic/api/moveit_tutorials/html/
11. http://docs.ros.org/kinetic/api/moveit_commander/html/index.html
12. https://moveit.ros.org/robots/

第二天下午 机械臂的模型和仿真

目标：了解机械臂模型和仿真

8.Rviz仿真和URDF模型

8.1 ROS的URDF描述格式

在 ROS 中,用来描述机器人及其部件的为 URDF 模型,即“统一机器人描述格式 (URDF, Unified Robot Description Format)”。例如,将tr10底盘用下图所示的简易的 机器人底盘模型进行描述,该模型车身用立方体描述,三个轮子用圆柱体描述,这样用4 个基本形状就可以描述一个简易的机器人底盘。

采用 URDF 描述文件对上述简易版的 TR10 机器人模型进行描述,文件内容为：

<robot name="abel05">
  <link name="base_link">
    <visual>
       <geometry>
         <box size="0.2 .3 .1"/>
       </geometry>
       <origin rpy="0 0 0" xyz="0 0 0.05"/>
       <material name="white">
         <color rgba="1 1 1 1"/>
       </material>
    </visual>
  </link>

  <link name="wheel_1">
    <visual>
      <geometry>
        <cylinder length="0.05" radius="0.05"/>
      </geometry>
      <origin rpy="0 1.5 0" xyz="0 0.1 0"/>
      <material name="black">
        <color rgba="0 0 0 1"/>
      </material>
    </visual>
  </link>

  <link name="wheel_2">
    <visual>
      <geometry>
        <cylinder length="0.05" radius="0.05"/>
      </geometry>
      <origin rpy="0 1.5 0" xyz="-0.1 -0.1 0"/>
      <material name="black"/>
    </visual>
  </link>
  <link name="wheel_3">
    <visual>
      <geometry>
        <cylinder length="0.05" radius="0.05"/>
      </geometry>
      <origin rpy="0 1.5 0" xyz="0.1 -0.1 0"/>
      <material name="black"/>
    </visual>
  </link>

  <joint name="joint_base_wheel1" type="fixed">
    <parent link="base_link"/>
    <child link="wheel_1"/>
  </joint>

  <joint name="joint_base_wheel2" type="fixed">
    <parent link="base_link"/>
    <child link="wheel_2"/>
  </joint>

  <joint name="joint_base_wheel3" type="fixed">
    <parent link="base_link"/>
    <child link="wheel_3"/>
  </joint>
</robot>

其中，link表示一个形状(如圆柱、立方体或其它不规则几何体)。 joint为连接link之间的关节，并指定了旋转轴。

由于 ROS 开发时都需要在工作区下进行,所以先建立一个 ROS 工作区,之后所有 的文件都在此工作区下进行。打开终端,创建 ROS 工作区和包:

$ cd
$ mkdir -p sim_ws/src
$ cd sim_ws/src
$ catkin create pkg tr10_description
$ cd tr10_description
$ mkdir urdf
$ cd urdf

然后在 urdf 文件夹下新建 tr10.urdf 文件,内容如上述源代码的内容,描述了一个 简易版的 tr10 机器人底盘模型。

sim_ws                      #工作区目录
 |--src                     #源代码目录
    |--tr10_description     #tr10_description 包目录
        |--CMakeLists.txt
        |--package.xml
        |--urdf             #urdf 描述文件目录
            |--tr10.urdf

依次执行以下指令,编译工作区,并将工作区导出到环境变量:

$ cd ~/sim_ws
$ catkin_make
$ echo "source ~/sim_ws/devel/setup.bash" >> ~/.bashrc
$ source ~/.bashrc

此时,可利用 roslaunch 工具启动 RViz 工具,预览上述 URDF 模型:

$ roslaunch urdf_tutorial display.launch model:=`rospack find tr10_description`/urdf/tr10.urdf

调节关节位置，观察模型变化。

动手操作：修改URDF模型内容，并RViz可视化工具观察模型变化。

8.2 Gauss机械臂URDF

Gauss机械臂的URDF描述文件在gauss_description包中。 描述文件为urdf包下的gauss.urdf.xacro。

gauss_description包在gauss源代码仓库下，gauss托管下载地址为https://github.com/tonyrobotics/gauss。 下载后，将其中的gauss_description包拷贝到本地的~/sim_ws/src/源码文件夹下。

其中xacro文件与urdf文件类似，实质上是一样的。 xacro提供了一种更丰富的描述方式，比如可以定义宏，进行模块化便于重用。

可以看到，其中描述各个部件形状的<geometry>标签不再是圆柱、立方体等标准模型了， 而是描述机械臂每个模块的描述文件，通常用.stl文件或.dae文件描述，此处为.stl文件。

进入urdf文件，运行RViz可视化工具进行查看。

$ roslaunch urdf_tutorial display.launch model:=gauss.urdf.xacro

附录:RoboWare Studio安装及使用

RoboWare Studio介绍

RoboWare Studio是一个ROS集成开发环境。它使ROS开发更加直观、简单，并且易于操作。可进行ROS工作区及包的管理，代码编辑、构建及调试。

RoboWare Studio的主要特性有：

（1）易于安装及配置

下载后双击即可安装，RoboWare Studio可自动检测并加载ROS环境，无需额外配置。这种“开箱即用”的特性能够帮助开发者迅速上手。

（2）辅助ROS开发，兼容indigo/jade/kinetic版本

RoboWare Studio专为ROS (indigo/jade/kinetic)设计，以图形化的方式进行ROS工作区及包的创建、源码添加、message/service/action文件创建、显示包及节点列表。可实现CMakelists.txt文件和package.xml文件的自动更新。

（3）友好的编码体验

提供现代IDE的重要特性，包括语法高亮、代码补全、定义跳转、查看定义、错误诊断与显示等。支持集成终端功能，可在IDE界面同时打开多个终端窗口。支持Vim编辑模式。

（4）C++和Python代码调试

提供Release、Debug及Isolated编译选项。以界面交互的方式调试C++和Python代码，可设置断点、显示调用堆栈、单步运行，并支持交互式终端。可在用户界面展示ROS包和节点列表。

（5）远程部署及调试

可将本地代码部署到远程机器上，远程机器可以是X86架构或ARM架构。可在本地机器实现远程代码的部署、构建和实时调试。

（6）内置Git功能

Git使用更加简单。可在编辑器界面进行差异比对、文件暂存、修改提交等操作。可对任意Git服务仓库进行推送、拉取操作。

（7）遵循ROS规范

从代码创建、消息定义，到文件存储路径的创建及选择等，RoboWare Studio会引导开发者进行符合ROS规范的操作，协助开发者编写高质量、符合规范的ROS包。

RoboWare Studio软件安装

准备

安装前，请查看系统环境并确认：

（1）操作系统为Ubuntu。

（2）已完成ROS的安装配置。ROS安装步骤可参照官方网站：http://wiki.ros.org/kinetic/Installation/Ubuntu

（3）可使用catkin_make构建ROS包。（若无法构建，您可能需要运行

$ sudo apt install build-essential

来安装基本构建工具。）

（4）为支持Python相关功能，需要安装pylint。

$ sudo apt install python-pip
$ sudo python -m pip install pylint

（5）为支持clang-format相关功能，需要安装clang-format-3.8或更高版本。

$ sudo apt install clang-format-3.8

安装

下载RoboWare Studio最新版，在终端执行以下命令进行安装：

$ cd /path/to/deb/file/
$ sudo dpkg -i roboware-studio_<version>_<architecture>.deb

其中，<version>表示软件版本号，<architecture>表示机器的处理器架构（amd64为64位版本，i386为32位版本）。 将<version>和<architecture>替换为当前文件信息即可（小技巧：可在输入“sudo dpkg -i ”后按Tab键自动补全文件名）。 安装后，RoboWare Studio会自动检测并加载ROS环境，无需额外配置。

升级

下载最新的RoboWare Studio安装包deb文件，参照安装步骤直接安装即可，旧版本会被自动覆盖。

卸载

打开任一终端，执行以下指令卸载RoboWare Studio：

$ sudo apt remove roboware-studio

启动

方式一（推荐）： 点击屏幕左上角的Ubuntu图标，打开Dash，搜索“roboware-studio”，单击启动。

方式二： 通过终端启动，打开任一终端，执行：

$ roboware-studio

本地模式使用教程

(1)创建工作区

在欢迎界面，点击“新建工作区”按钮（或选择“文件 - 新建工作区”），选择路径并填写工作区名称，如“catkin_ws”，则会创建一个名为“catkin_ws”工作区，并显示在资源管理器窗口。

(2)打开/关闭工作区

在欢迎界面，点击“打开工作区”按钮（或选择“文件 - 打开工作区”），选择需要打开的ROS工作区，打开后即可显示在资源管理器窗口。

选择“文件 - 关闭工作区”，RoboWare Studio会关闭当前的工作区并返回欢迎界面。

(3)创建ROS包

右键点击ROS工作区下的“src”，选择“新建ROS包”，输入包名称及其依赖包的名称，如：

my_package roscpp std_msgs

回车后，会创建名为“my_package”、以“roscpp”和“std_msgs”为依赖的ROS包。

(4)添加新的动态链接库或可执行文件（ROS节点）

右键点击包名文件夹（如“my_package”），选择“新建Src文件夹”，会自动创建ROS标准的src源码目录，其它必要的目录也可通过此右键菜单来创建。

右键点击ROS包目录下的“src”，选择“新建CPP源文件”，输入文件名后，点击回车键，会弹出以下列表：

• 加入到新的库文件中
• 加入到新的可执行文件中

在列表中选择类型，则会创建一个与CPP文件同名的动态链接库或可执行文件（ROS节点），此时CMakeLists.txt文件会自动更新。

同理，右键点击ROS包目录下的“include/包名”，选择“新建头文件”，也可通过同样方式进行添加。

(5)添加C++源代码到动态链接库或可执行文件（ROS节点）

右键点击ROS包目录下的“src”，选择“新建CPP源文件”，输入文件名后，点击回车键，会弹出以下列表：

• my_library1
• my_library2
• my_executable1
• 加入到新的库文件中
• 加入到新的可执行文件中

其中my_library1、my_library2、my_executable1为已建立的库和可执行文件（节点），以列表的形式列出。 选择对应的条目（如my_executable1），CPP文件会添加到my_executable1可执行文件中。此时CMakeLists.txt文件会自动更新。

(6)编辑catkin ROS依赖包

右键点击包名文件夹（如“my_package”），选择“编辑依赖的ROS包列表”，加入新增的依赖包名称，如：

std_msgs

回车后，会自动修改CMakeLists.txt的依赖包列表，如依赖多个ROS包的时候需要用空格把每个依赖包隔开。

(7)添加message/service/action

右键点击包名文件夹（如“my_package”），选择“新建Msg文件夹”、“新建Srv文件夹”、 “新建Action文件夹”可分别创建message、service、action文件夹。 右键点击相应文件夹即可添加message、service、action文件。此时CMakeLists.txt文件会自动更新。

(8)构建工作区

RoboWare Studio支持catkin_make构建工具和catkin_tools构建工具。

选择菜单“文件 – 首选项 – 设置”可打开设置界面，点击“ROS - ros.buildTool”标签左侧的编辑标志，即可选择构建工具。

其中，Debug和Release选项分别表示构建调试版和发布版，默认构建方式为本地构建。 catkin make方式下，带有“isolated”的选项表示利用“catkin_make_isolated”命令进行构建。 带有“remote”的选项表示进行远程构建。“Remote Deploy”选项表示部署本地代码到远程计算机。 关于远程开发的具体步骤会在下一节“远程模式使用教程”介绍，在此以本地构建为例进行说明。

完成构建选项选择后，点击配置列表左侧的构建按钮，或选择“ROS”-“构建”即可构建对应版本的ROS包。构建完成后，资源管理器窗口下方的“ROS节点”子窗口会显示当前工作区下所有的ROS包及节点列表。

选择“查看 - 输出”可打开“输出”窗口，显示构建输出结果。若构建过程中出现错误，按住“CTRL”键并点击错误提示，即可跳转到源代码对应位置。

(9)构建工作区下的一个或多个包

默认情况下，点击“构建”按钮会构建当前工作区下的所有包。如果只想构建其中的一个或多个包，可右键点击包名，将其设置为活动状态。可同时将一个或多个包设置为活动状态。此时，不被编译的包即称为“非活动包”，在目录列表中将会以删除线标记出来。点击“构建”按钮，RoboWare Studio只会对处于活动状态的包进行构建。

(10)清理构建结果

构建完成后，资源管理器窗口下方的“ROS节点”子窗口会显示当前工作区下所有的ROS包及节点列表。

点击“ROS节点”子窗口上的“清理”按钮，则会对构建结果进行清理。

(11)集成终端使用

选择“查看 - 集成终端”选项，可在编辑窗口下方打开集成终端窗口。集成终端默认打开路径为当前ROS工作区根目录。可在集成终端中执行任意命令行指令。

可以点击集成终端窗口右上方的“+”按钮打开新的集成终端，并在下拉列表中进入对应的集成终端。

(12)添加并启动launch文件

首先，右键点击包名文件夹（如“my_package”），选择“新建Launch文件夹”可创建launch文件夹。然后，右键点击launch文件夹，输入文件名添加launch文件。

编辑完后，右键launch文件，选择“运行Launch文件”即可，RoboWare Studio会自动打开集成终端并运行launch文件。

(13)编辑~/.bashrc文件

选择菜单“ROS – 打开~/.bashrc文件”即可打开并编辑.bashrc文件。

远程模式使用教程

(1)配置SSH公钥无密登录

首先，在本地计算机生成公钥和私钥。打开终端，执行命令：

$ ssh-keygen

一直按回车键选择默认选项，会在~/.ssh目录下生成id_rsa和id_rsa.pub两个文件。然后将id_rsa.pub文件复制到远程计算机：

$ scp ~/.ssh/id_rsa.pub username@ip_address:/home/username

其中username为远程计算机用户名，ip_address为远程计算机的IP地址，示例如下所示。

将公钥文件id_rsa.pub拷贝到远程计算机后，SSH登录到远程计算机：

$ ssh username@ip_address

其中username为远程计算机用户名，ip_address为远程计算机的IP地址。

登录后，将id_rsa.pub的文件内容追加写入到远程计算机的~/.ssh/authorized_keys文件中，并修改authorized_keys文件的权限：

$ cat id_rsa.pub >> ~/.ssh/authorized_keys
$ chmod 600 ~/.ssh/authorized_keys

配置完成后，再登录远程计算机就无需输入密码。接下来，即可配置RoboWare Studio的远程调试参数进行远程调试。

(2)修改远程计算机/etc/profile

首先，登录远程计算机：

$ ssh username@ip_address

其中username为远程计算机用户名，ip_address为远程计算机的IP地址。

登录后，切换到root用户权限，将ROS环境变量信息写入到/etc/profile文件中：

$ sudo su
$ echo "source /opt/ros/kinetic/setup.bash" >> /etc/profile

在此需要注意，示例中的ROS版本为“kinetic”，对于其它版本替换为对应名称即可。

(3)远程参数配置

启动RoboWare Studio后，点击“远程参数配置”按钮，依次配置远程计算机IP地址、远程计算机用户名、本地计算机密钥文件、远程计算机部署路径参数。

(4)远程部署

完成远程参数配置后，再进行远程部署。

首先，在资源管理器视图下，选择“Remote Deploy”远程部署选项，点击列表左侧的按钮进行远程部署。RoboWare Studio会将当前整个工作区的源代码部署到远程计算机的指定路径下（请参照上一节的“远程参数配置”进行远程部署路径的设置）。

在远程部署过程中，左下角状态栏图标会跳动。部署完成后，会在“输出”窗口显示部署成功的信息（Deploy Finished!）。

(5)远程构建

完成远程部署后，即可进行远程构建。远程构建与本地构建一样，可以选择catkin_make和catkin_tools两种构建方式，若选择catkin_tools构建方式，需要在远程机器上安装catkin_tools工具。在此仅以catkin_make构建方式进行说明。

首先，在资源管理器视图下，选择“Debug (remote)”构建选项，点击列表左侧的按钮进行远程构建。RoboWare Studio会将构建指令发送到远程计算机，并在“输出”窗口显示构建信息。

(6)远程清理

远程构建完成后，资源管理器窗口下方的“ROS节点”子窗口会显示远程工作区下所有的ROS包及节点列表。

点击“ROS节点”子窗口上的“清理”按钮，则会对远程构建结果进行清理。

在此需要注意，点击“清理”按钮，左上角的配置构建选项中如果为“remote”选项，则会清除远程构建结果，否则，则清除本地构建结果。

(7)远程部署/构建一个或多个包

默认情况下，部署时会将当前工作区下的所有包部署到远程主机。如果只想部署其中的一个或多个包，可右键点击包名，将其设置为活动状态。可同时将一个或多个包设置为活动状态。此时，进行部署时，RoboWare Studio只会将处于活动状态的包部署到远程主机。

与本地构建方式相同，当设置一个或多个活动包时，点击“构建”按钮，只会对处于活动状态的包进行构建。当清除所有包的活动状态后，则会回到初始状态（即所有包都处于非活动状态）。当所有包都处于非活动状态时，点击“构建”按钮，则会对当前工作区内的所有包进行构建。

(8)远程启动launch文件

右键launch文件，选择“在远程主机上运行Launch文件”，RoboWare Studio会在集成终端中启动远程主机的launch文件。在集成终端中使用“Ctrl + c”快捷键可终止运行。

软件首选项配置

RoboWare Studio软件可方便地进行的首选项配置，以点选的方式实现用户配置、工作区配置以及主题配置等。选择“文件 – 首选项 – 设置”即可打开配置界面。

FAQ

(1)如何导入已有的ROS工作区？

分两种情况：

• 对于普通的ROS工作区，直接在欢迎界面点击“打开工作区”按钮（或在菜单中选择“文件 - 打开工作区”），选择工作区路径打开即可。
• 对于旧版本RoboWare Studio打开过的ROS工作区，需要将工作区根目录下的“.vscode”文件夹删除，再打开工作区即可。

(2)如何进行软件升级？

下载最新的RoboWare Studio安装包deb文件，参照安装步骤直接安装即可，旧版本会被自动覆盖。

(3)如何修改界面语言？

在菜单栏中，选择“文件-首选项-语言设置”，打开配置文件。

"locale":"zh-CN" 表示设置为中文界面，
"locale":"en" 表示设置为英文界面，

可用“//”进行注释。修改完成后，重启RoboWare Studio即可生效。

(4)新建工作区时提示“路径不是ROS工作区”。

可能原因为ROS环境变量未导出。安装完ROS后，需要在当前用户家目录下的.bashrc文件中添加以下内容：

source /opt/ros/indigo/setup.bash #（indigo版）

或

source /opt/ros/kinetic/setup.bash #（kinetic版）

ROS的安装及配置说明可参照官网教程：

http://wiki.ros.org/indigo/Installation/Ubuntu （indigo版）

http://wiki.ros.org/kinetic/Installation/Ubuntu （kinetic版）

(5)提示错误“Linter pylint is not installed”。

需要安装pylint，请参照本手册“软件安装”-“准备”中的步骤。打开命令行终端，执行以下命令：

$ sudo apt install python-pip

在集成终端中安装python插件时会提示输入root密码，请按照提示输入。

(6)提示系统git版本低的问题。

需要升级git。打开命令行终端，执行以下命令：

$ sudo apt-add-repository ppa:git-core/ppa
$ sudo apt update
$ sudo apt install git

(7)名为“test”的节点无法生成问题。

不要将ROS节点名称命名为test，否则会无法生成节点。

(8)构建过程中卡住问题。

对于内存太小的机器，如果当前工作区内的ROS包数量太多，在构建整个工作区时，会因内存不足导致构建卡住。此时，可采用单独构建的方式依次对每个包构建。

(9)新建、删除文件时资源管理器不能自动刷新。

RoboWare Studio依靠ubuntu的文件系统监视功能实现资源管理器的自动刷新， 但ubuntu的文件监视数量限制可能设置的太小，导致资源管理器没有自动刷新。 为解决这个问题需要设置ubuntu的文件监视数量限制。方法如下：

使用root权限打开文件/etc/sysctl.conf进行编辑。

$ sudo gedit /etc/sysctl.conf

也可用其它文本编辑器。

找到fs.inotify.max_user_watches选项，适当增加等号后面的数值，比如改为100000。重启ubuntu即可。

(10)编辑器无法输入、选择、复制问题。

这是因为RoboWare Studio处于Vim编辑模式，切换到普通模式即可，在菜单栏选择“编辑-切换VIM编辑模式”可切换到普通编辑模式。

(11)编辑时如何进行前进、后退？能否自定义其快捷键？

默认的前进快捷键为“Ctrl+Shift+-”，后退快捷键为“Ctrl+Alt+-”。 可以进行快捷键自定义，点击菜单栏的“文件 - 首选项 – 键盘快捷方式”，找到“前进”、“后退”选项进行修改即可，也可对其它快捷键进行自定义。

(12)CMakelists.txt错误无法定位问题。

先删除工作区根目录.vscode文件夹下的tasks.json文件，然后重新打开工作区。

(13)Meta Package无法编辑依赖、无法新建节点问题。

目前尚不支持meta package编辑依赖和新建节点，将meta package下的所有包拷贝到src目录下即可。