ROS机器人036-机器人ssh远程登陆+机器人端/计算机端全程控制实现slam建图，导航，rviz显示，目标识别，键盘控制

一、安装shh

ssh apt-get install openssh-client

查看TX2工控机端的ip地址:

查看计算机端IP地址:

登陆工控机端:

ssh nvidia@192.168.1.41

ssh远程登陆完成

二、设置机器人端自启动

设置机器人base,slam,move_base,rviz启动文件

1.设置地盘结点，gmapping结点，move_base结点，人脸识别结点启动.sh文件

nvidia@tegra-ubuntu:~/roborts_ws/src/roborts_bringup/launch$ 
./Automap_move_face1.sh 

Automap_move_face1.sh文件

#! /bin/bash
# 开头这句话必不可少
source /opt/ros/kinetic/setup.bash    # 启动ros环境
source ~/catkin_ws/devel/setup.bash
source ~/roborts_ws/devel/setup.bash

sleep 2

gnome-terminal -x bash -c "roslaunch roborts_bringup Ymap_move_face1.launch" &

Ymap_move_face1.launch文件

nvidia@tegra-ubuntu:~/roborts_ws/src/roborts_bringup/launch$ 
roslaunch roborts_bringup Ymap_move_face1.launch

<launch>
  <master auto="start"/>
  <rosparam command="load" file="$(find roborts_base)/config/roborts_base_parameter.yaml" />

  <!-- Run the Base Node -->
  <node pkg="roborts_base" type="roborts_base_node" name="roborts_base_node" output="screen" respawn="true" />
  
  <!-- Run the rplidar Node -->
  <node name="rplidarNode"          pkg="rplidar_ros"  type="rplidarNode" output="screen">
  <param name="serial_port"         type="string" value="/dev/ttyUSB4"/>
  <param name="serial_baudrate"     type="int"    value="115200"/><!--A1/A2 -->
  <!--param name="serial_baudrate"     type="int"    value="256000"--><!--A3 -->
  <param name="frame_id"            type="string" value="base_laser_link"/>
  <param name="inverted"            type="bool"   value="false"/>
  <param name="angle_compensate"    type="bool"   value="true"/>
  </node>
  
  <!--static_transform_publisher x y z yaw pitch roll frame_id child_frame_id-->
  <node pkg="tf2_ros" type="static_transform_publisher" name="base_link_base_laser_link_broadcaster"
       args="0.0 0.0 0.00 0.0 0.0 0.0 base_link base_laser_link" />

  <!-- Run the slam gmapping -->
  <include file="$(find roborts_bringup)/launch/slam_gmapping.xml"/>

  <!-- Run the Rmove_base -->
  <include file="$(find roborts_bringup)/launch/Rmove_base.launch"/>

  <!-- Run the usb_cam -->
  <include file="$(find roborts_bringup)/launch/usb_cam.launch"/>
  
  <!-- Run the face_detector -->
  <include file="$(find roborts_bringup)/launch/face_detector.launch"/>

  <!-- 运行rviz -->
  <node pkg="rviz" type="rviz" name="rviz" args="-d $(find roborts_bringup)/rviz/Rmapping.rviz"/>

</launch>

nvidia@tegra-ubuntu:~/$ 
./Autokeyboard.sh 

Autokeyboard.sh 文件

#! /bin/bash
# 开头这句话必不可少
source /opt/ros/kinetic/setup.bash    # 启动ros环境
source ~/catkin_ws/devel/setup.bash
source ~/roborts_ws/devel/setup.bash

sleep 2

gnome-terminal -x bash -c "./keyboard.py" &

keyboard.py 键盘控制文件

./keyboard.py

#!/usr/bin/env python
import roslib; roslib.load_manifest('teleop_twist_keyboard')
import rospy

from geometry_msgs.msg import Twist

import sys, select, termios, tty

msg = """
Reading from the keyboard  and Publishing to Twist!
---------------------------
Moving around:
   u    i    o
   j    k    l
   m    ,    .

For Holonomic mode (strafing), hold down the shift key:
---------------------------
   U    I    O
   J    K    L
   M    <    >

t : up (+z)
b : down (-z)

anything else : stop

q/z : increase/decrease max speeds by 10%
w/x : increase/decrease only linear speed by 10%
e/c : increase/decrease only angular speed by 10%

CTRL-C to quit
"""

moveBindings = {
		'i':(1,0,0,0),
		'o':(1,0,0,-1),
		'j':(0,0,0,1),
		'l':(0,0,0,-1),
		'u':(1,0,0,1),
		',':(-1,0,0,0),
		'.':(-1,0,0,1),
		'm':(-1,0,0,-1),
		'O':(1,-1,0,0),
		'I':(1,0,0,0),
		'J':(0,1,0,0),
		'L':(0,-1,0,0),
		'U':(1,1,0,0),
		'<':(-1,0,0,0),
		'>':(-1,-1,0,0),
		'M':(-1,1,0,0),
		't':(0,0,1,0),
		'b':(0,0,-1,0),
	       }

speedBindings={
		'q':(1.1,1.1),
		'z':(.9,.9),
		'w':(1.1,1),
		'x':(.9,1),
		'e':(1,1.1),
		'c':(1,.9),
	      }

def getKey():
	tty.setraw(sys.stdin.fileno())
	select.select([sys.stdin], [], [], 0)
	key = sys.stdin.read(1)
	termios.tcsetattr(sys.stdin, termios.TCSADRAIN, settings)
	return key


def vels(speed,turn):
	return "currently:\tspeed %s\tturn %s " % (speed,turn)

if __name__=="__main__":
    	settings = termios.tcgetattr(sys.stdin)
	
	pub = rospy.Publisher('cmd_vel', Twist, queue_size = 1)
	rospy.init_node('teleop_twist_keyboard')

	speed = rospy.get_param("~speed", 0.3)
	turn = rospy.get_param("~turn", 0.5)
	x = 0
	y = 0
	z = 0
	th = 0
	status = 0

	try:
		print msg
		print vels(speed,turn)
		while(1):
			key = getKey()
			if key in moveBindings.keys():
				x = moveBindings[key][0]
				y = moveBindings[key][1]
				z = moveBindings[key][2]
				th = moveBindings[key][3]
			elif key in speedBindings.keys():
				speed = speed * speedBindings[key][0]
				turn = turn * speedBindings[key][1]

				print vels(speed,turn)
				if (status == 14):
					print msg
				status = (status + 1) % 15
			else:
				x = 0
				y = 0
				z = 0
				th = 0
				if (key == '\x03'):
					break

			twist = Twist()
			twist.linear.x = x*speed; twist.linear.y = y*speed; twist.linear.z = z*speed;
			twist.angular.x = 0; twist.angular.y = 0; twist.angular.z = th*turn
			pub.publish(twist)

	except:
		print e

	finally:
		twist = Twist()
		twist.linear.x = 0; twist.linear.y = 0; twist.linear.z = 0
		twist.angular.x = 0; twist.angular.y = 0; twist.angular.z = 0
		pub.publish(twist)

    		termios.tcsetattr(sys.stdin, termios.TCSADRAIN, settings)

Autoslam.sh文件

nvidia@tegra-ubuntu:~/$ 
./Autoslam.sh  

#! /bin/bash
# 开头这句话必不可少
source /opt/ros/kinetic/setup.bash    # 启动ros环境
source ~/catkin_ws/devel/setup.bash
source ~/roborts_ws/devel/setup.bash

sleep 2
gnome-terminal -x bash -c "./slam.py" &

slam.py自主巡航文件

nvidia@tegra-ubuntu:~/$ 
./slam.py  

#!/usr/bin/env python 
# -*- coding: utf-8 -*-
 
import roslib;
import rospy  
import actionlib  
from actionlib_msgs.msg import *  
from geometry_msgs.msg import Pose, PoseWithCovarianceStamped, Point, Quaternion, Twist  
from move_base_msgs.msg import MoveBaseAction, MoveBaseGoal  
from random import sample  
from math import pow, sqrt  

class NavTest():  
    def __init__(self):  
        rospy.init_node('exploring_slam', anonymous=True)  
        rospy.on_shutdown(self.shutdown)  

        # 在每个目标位置暂停的时间 (单位：s)
        self.rest_time = rospy.get_param("~rest_time", 2)  

        # 是否仿真？  
        self.fake_test = rospy.get_param("~fake_test", True)  

        # 到达目标的状态  
        goal_states = ['PENDING', 'ACTIVE', 'PREEMPTED',   
                       'SUCCEEDED', 'ABORTED', 'REJECTED',  
                       'PREEMPTING', 'RECALLING', 'RECALLED',  
                       'LOST']  
 
        # 设置目标点的位置  
        # 在rviz中点击 2D Nav Goal 按键，然后单击地图中一点  
        # 在终端中就会看到该点的坐标信息  
        locations = dict()  

        locations['1'] = Pose(Point(4.589, -0.376, 0.000),  Quaternion(0.000, 0.000, -0.447, 0.894))  
        locations['2'] = Pose(Point(4.231, -6.050, 0.000),  Quaternion(0.000, 0.000, -0.847, 0.532))  
        locations['3'] = Pose(Point(-0.674, -5.244, 0.000), Quaternion(0.000, 0.000, 0.000, 1.000))  
        locations['4'] = Pose(Point(-5.543, -4.779, 0.000), Quaternion(0.000, 0.000, 0.645, 0.764))  
        locations['5'] = Pose(Point(-4.701, -0.590, 0.000), Quaternion(0.000, 0.000, 0.340, 0.940))  
        locations['6'] = Pose(Point(2.924, 0.018, 0.000),   Quaternion(0.000, 0.000, 0.000, 1.000))  

        # 发布控制机器人的消息  
        self.cmd_vel_pub = rospy.Publisher('cmd_vel', Twist, queue_size=5)  

        # 订阅move_base服务器的消息  
        self.move_base = actionlib.SimpleActionClient("move_base", MoveBaseAction)  

        rospy.loginfo("Waiting for move_base action server...")  

        # 60s等待时间限制  
        self.move_base.wait_for_server(rospy.Duration(60))  
        rospy.loginfo("Connected to move base server")  
  
        # 保存机器人的在rviz中的初始位置  
        initial_pose = PoseWithCovarianceStamped()  

        # 保存成功率、运行时间、和距离的变量  
        n_locations = len(locations)  
        n_goals = 0  
        n_successes = 0  
        i = n_locations  
        distance_traveled = 0  
        start_time = rospy.Time.now()  
        running_time = 0  
        location = ""  
        last_location = ""    
 
        # 确保有初始位置  
        while initial_pose.header.stamp == "":  
            rospy.sleep(1)  

        rospy.loginfo("Starting navigation test")  

        # 开始主循环，随机导航  
        while not rospy.is_shutdown():  
            # 如果已经走完了所有点，再重新开始排序  
            if i == n_locations:  
                i = 0  
                sequence = sample(locations, n_locations)  
 
                # 如果最后一个点和第一个点相同，则跳过  
                if sequence[0] == last_location:  
                    i = 1  

            # 在当前的排序中获取下一个目标点  
            location = sequence[i]  

            # 跟踪行驶距离  
            # 使用更新的初始位置  
            if initial_pose.header.stamp == "":  
                distance = sqrt(pow(locations[location].position.x -   
                                    locations[last_location].position.x, 2) +  
                                pow(locations[location].position.y -   
                                    locations[last_location].position.y, 2))  
            else:  
                rospy.loginfo("Updating current pose.")  
                distance = sqrt(pow(locations[location].position.x -   
                                    initial_pose.pose.pose.position.x, 2) +  
                                pow(locations[location].position.y -   
                                    initial_pose.pose.pose.position.y, 2))  
                initial_pose.header.stamp = ""  

            # 存储上一次的位置，计算距离  
            last_location = location  

            # 计数器加1  
            i += 1  
            n_goals += 1  

            # 设定下一个目标点  
            self.goal = MoveBaseGoal()  
            self.goal.target_pose.pose = locations[location]  
            self.goal.target_pose.header.frame_id = 'map'  
            self.goal.target_pose.header.stamp = rospy.Time.now()  

            # 让用户知道下一个位置  
            rospy.loginfo("Going to: " + str(location))  

            # 向下一个位置进发  
            self.move_base.send_goal(self.goal)  

            # 五分钟时间限制  
            finished_within_time = self.move_base.wait_for_result(rospy.Duration(300))   

            # 查看是否成功到达  
            if not finished_within_time:  
                self.move_base.cancel_goal()  
                rospy.loginfo("Timed out achieving goal")  
            else:  
                state = self.move_base.get_state()  
                if state == GoalStatus.SUCCEEDED:  
                    rospy.loginfo("Goal succeeded!")  
                    n_successes += 1  
                    distance_traveled += distance  
                    rospy.loginfo("State:" + str(state))  
                else:  
                  rospy.loginfo("Goal failed with error code: " + str(goal_states[state]))  

            # 运行所用时间  
            running_time = rospy.Time.now() - start_time  
            running_time = running_time.secs / 60.0  

            # 输出本次导航的所有信息  
            rospy.loginfo("Success so far: " + str(n_successes) + "/" +   
                          str(n_goals) + " = " +   
                          str(100 * n_successes/n_goals) + "%")  

            rospy.loginfo("Running time: " + str(trunc(running_time, 1)) +   
                          " min Distance: " + str(trunc(distance_traveled, 1)) + " m")  

            rospy.sleep(self.rest_time)  

    def update_initial_pose(self, initial_pose):  
        self.initial_pose = initial_pose  

    def shutdown(self):  
        rospy.loginfo("Stopping the robot...")  
        self.move_base.cancel_goal()  
        rospy.sleep(2)  
        self.cmd_vel_pub.publish(Twist())  
        rospy.sleep(1)  

def trunc(f, n):  
    slen = len('%.*f' % (n, f))  

    return float(str(f)[:slen])  

if __name__ == '__main__':  
    try:  
        NavTest()  
        rospy.spin()  

    except rospy.ROSInterruptException:  
        rospy.loginfo("Exploring SLAM finished.")

命令合集:
图标：工控机端启动后需要依次在工控机端点开:
1.map_move_face1
2.robort_keyboard
3.Auto_slam（需要时候点开）
命令行：

nvidia@tegra-ubuntu:~$roslaunch roborts_bring Ymap_move_face1.launch
nvidia@tegra-ubuntu:~$./keyboard
nvidia@tegra-ubuntu:~$./slam.py

三、设置笔记本端自启动

电机桌面的图标两个，等到机器人完全启动并且工控机的rviz显示出来后再启动笔记本端的robort-rviz，rviz,然后点击第二个图标robort-key-slam-move-face，
0.输入工控机端的密码:nvidia
1.输入./keyboard.py启动键盘控制
2.输入./slam.py启动自主巡航

一、新建计算机端.sh rviz自启动文件

CLB@CLB:~/roborts_ws/src/roborts_bringup$ 
vim Auto.sh

Auto.sh 自启动文件

#! /bin/bash
# 开头这句话必不可少
source /opt/ros/kinetic/setup.bash    # 启动ros环境
source ~/catkin_ws/devel/setup.bash
source ~/roborts_ws/devel/setup.bash

sleep 2
gnome-terminal -x bash -c "rviz" &    # 启动rviz

二、新建计算机端.sh 登陆工控机自启动文件

CLB@CLB:~/roborts_ws/src/roborts_bringup$ 
vim Auto_roborts.sh

Auto_roborts.sh 自启动文件

这句话必不可少
source /opt/ros/kinetic/setup.bash    # 启动ros环境
source ~/catkin_ws/devel/setup.bash
source ~/roborts_ws/devel/setup.bash
echo "pass:nvidia"
echo "1:roslaunch Ymap_move_face1.launch"
echo "2:./keyboard.py"
echo "3:./slam.py"
sleep 2
gnome-terminal -x bash -c "ssh nvidia@192.168.1.41 " &    # 启动 roslaunch Ymap_move_face1.launch
sleep 1
gnome-terminal -x bash -c "ssh nvidia@192.168.1.41 " &    # 启动 keyboard.py
sleep 1
gnome-terminal -x bash -c "ssh nvidia@192.168.1.41 " &    # 启动 slam.py

工控机登陆后输入：三条指令，但是，机器人地盘，slam,move,face**(Ymap_move_face1.launch)**需要在工控机端启动

roslaunch Ymap_move_face1.launch
./keyboard.py
./slam.py

基础课题完结篇

机器人
工控机端实现:
1.slam 键盘控制建图
2.rviz自主鼠标点击地图自主导航和建图
3.机器人自主巡航建图
计算机端实现：
1.slam键盘控制建图
2.rviz自主鼠标点击地图自主导航和建图
3.机器人自主巡航建图

需要注意：
1.工控机机器人端先启动
2.然后点击工控机桌面map_move_face1图标/或者命令行roslaunch roborts_bring Ymap_move_face1.launch

3.再启动计算机端的桌面rviz显示(robort-rviz图标)
或命令行:rosrun rviz rviz

4.然后启动桌面(robort-key-slam-move-face图标),实现远程登陆
或命令行**:ssh nvidia@192.168.1.41**
5.远程登陆密码nvidia

6.登陆机器人后执行nvidia@tegra-ubuntu:~$ ./keyboard.py (实现键盘控制)
7.登陆机器人后执行nvidia@tegra-ubuntu:~$ ./slam.py(实现机器人巡航slam建图)

机器人端工控机ip:192.168.1.41
计算机端 ip:192.168.1.85

摄像头，STM32，激光雷达安装位置