DASL Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====Operating DRC-Hubo inside the Simulator====
**Author:**[[unlv_nishimura|Keitaro Nishimrua]] E-mail:<katnimura@gmail.com>
\\
**Date Last Edited:**08/15/16
\\
**Keywords:** Gazebo, PODO, ROS, R-viz
===How to use this tutorial===
\\
This tutorial will take the user through how to use the PODOGUI together with Gazebo to simulate real world use of the DRC-hubo robot. For certain movements the usage of ROS will be needed. The reader is expected to have already gone through the previous tutorials and be comfortable using terminal and ROS. This tutorial will follow this flow:

   *[[operating_drc-hubo_inside_the_simulator#How to open simulators with DRC-Hubo model and GUI|How to open simulators with DRC-Hubo model and GUI]]
   *[[operating_drc-hubo_inside_the_simulator#PODOGUI|PODOGUI]]
   *[[operating_drc-hubo_inside_the_simulator#Using ROS together with the GUI and simulators|Using ROS together with the GUI and simulators]]
\\
This tutorial will take the reader between 3-4hrs. The operating with ROS section will take the longest time. I expect it to take by itself 2hrs.
\\
===How to open simulators with DRC-Hubo model and GUI===
\\
1. Open a new terminal and run:
----
<fc purple>
roscore
</fc>
----
\\
{{:tut13.png?400}}
\\
2. Open a new terminal and run:
----
<fc purple>
cd ~/catkin_ws/src/drc_hubo/podo/Execute\ Daemon/
</fc>
----
then run:
----
<fc purple>
./PODOLauncher
</fc>
----
\\
{{:tut19.png?400}} {{:tut20.png?400}}
\\
3. Once the PODOLauncher is open make sure that the Daemon.exe file is from the drc_hubo folder and that gazebo and use ROS are selected. Then click Start Daemon. 
\\
{{:tut18.png?400}}
\\
4. Open a new terminal and run the following commands:
----
<fc purple>
roslaunch drc_podo_connector drc_hubo.launch
</fc>
----
This will run both R-viz and gazebo at the same time. 
\\
{{:tut14.png?400}}
\\
5. Open qt and find the session you used for the PODOGUI and ALPrograms from inside the drc-hubo folder. Run the PODOGUI and connect it to Daemon.
\\
{{:tut26.png?400}} {{:tut27.png?400}} 
\\
6. Once inside the tab you will notice that there are 5 different sections. Tutorial, Pose Change, Head Control, Wheel Control, and Object Picking. 
\\
{{:tut200.png?400}} 
\\
===PODOGUI===
I will take you through what some of these buttons do and what to expect when you press them. I will go over these sections in this order:
 
   * Tutorial
   * Pose Change
   * Wheel Control
   * Head Control

==Tutorial==

This is just a test button that you can use confirm if the GUI and simulators are connected. It will turn the waist to the right a little. 

Open the module tab and double click the ALTutorial AL to turn it on.
\\
{{:tut_almenu.png?400}}
\\
The 'test' button in the Tutorial frame.  
\\
{{:tut300.png?400}}
\\
3. You should now see the model in both rviz and gazebo move to it's final position.
\\
{{:tut_test.png?400}}
\\
==Pose Change==

These are a set of buttons that will move the model into pre-set poses.
\\
Open the module tab and double click both the WalkReady and OmniWheel ALs to turn them on. Then double click the ALTutorial AL to turn it off. If you have trouble turning and AL on or off close the GUI and re-run it from qt.
\\
{{:tut_almenu.png?400}}
\\
The Home Pos button to return the model to it's original position after the test movement. This is also the position that the model uses when uploaded into the simulators. 
\\
{{:tut_homepos.png?400}}
\\
The Walk Ready button. This will put the model into it's initial walking position. 
\\
{{:tut_walkreadypos.png?400}}
\\
The To Wheel button. This will put the model into it's wheel mode and be able to roll around using the wheels on it's legs.
\\
{{:tut_towheelpos.png?400}}
\\
The To Walk button. This will bring the model back to it's walk ready position. 
\\
{{:tut_walkreadypos.png?400}}
\\
Please put the model into walk ready before going into wheel mode. If you don't the arms will hit the ground and possible break the model in rviz. 
\\
==Wheel Control==

I will only talk about the bottom part of this frame. I will explain the ROS Mode and AL Mode buttons in the next section. For now ROS Mode turn on ROS mode and AL Mode turns off ROS mode. 
\\
If you haven't already turn on the OmniWheel AL. 
\\
{{:tut_almenu.png?400}}
\\
The x, y, z, and angle inputs are what tells the model how far it needs to move. In this tutorial we will only use x and angle. If you put .5 into the x input and -25 into the angle input and click Goto Point the model will move .5m forward then turn 25 units to the right. The angle input is not in degrees or radians so please play around with different inputs to see for yourself. Also the model will always move forward first then turn, so if you want to turn the model first you will need to command it to only turn first then move.  
\\
{{:tut_gotowheel.png?400}} {{:tut_wheelgoto.png?400}}
\\
When doing more than one movement you will have to keep an eye on the daemon terminal. Only after it is done processing one movement can you start the next one.
\\
{{:tut_daemonsteps.png?400}}
\\
==Head Control==
\\
This frame allows you to scan the area in front of the model and also to move a camera to a specified position. 
\\
{{:tut_headcontrol.png?400}}
\\
The Scan button scans the area in front of the model using the laser scanner on it's head. The inputs on the left give you the freedom to choose from what angle to what angle you want to scan and how for how long. 
\\
{{:tut_scan.png?400}}
\\
The GO TO button allows you to move the camera on the models head to a specific angle.
\\
{{:tut_headgoto.png?400}} {{:tut_gotoscan.png?400}}
\\

===Using ROS together with the GUI and simulators===

In this section I will teach the reader how to use ROS together with PODO to control the model inside the simulators. This will not be an extensive tutorial and the reader is advised to learn further. I will go over two specific implementations:

   *[[operating_drc-hubo_inside_the_simulator#Using a game controller to control the DRC-Hubo model in wheel]] mode
   *[[operating_drc-hubo_inside_the_simulator#Simple navigation of DRC-Hubo in wheel mode]]

The reader is expected to be comfortable with terminal and ROS.

===Using a game controller to control the DRC-Hubo model in wheel mode===

As I stated in the Wheel Control part of the earlier section we will be using the ROS Mode and AL Mode buttons in this section. 
\\
We are going to use a Linux compatible game controller(like the one shown below) and use the left joystick to move the DRC-Hubo model through the structure that it launches in. The controller connects via-usb so keep a usb port open for it. I will not go in-depth into the code so please read the documentation. We will be using the ROS-Joy package to accomplish this task.
   *[[http://wiki.ros.org/joy|ROS-Joy Package Summary]]
   *[[http://wiki.ros.org/joy/Tutorials|ROS-Joy Tutorials]]
-Please note for the second tutorial (as of 08/08/16) the code isn't up to date and will not work on any distro past Indigo. But the explanation of the code is still correct. Note that the tutorial uses rosbuild instead of catkin. Compare the explanations to [[https://github.com/ros-drivers/joystick_drivers_tutorials/pull/4/files?short_path=04c6e90|this code instead]].   
\\
{{:img_20160808_110839.jpg?400}}
\\
This will be split up into two parts:
  *Configuring the Controller and Joy
  *Implementing Joy with PODO 
  *How PODO works with ROS-Joy

==Configuring the Controller and Joy==
1. Open a new terminal and install the ROS-Joy package:
----
<fc purple>
sudo apt-get install ros-<YOUR DISTRO>-joy
</fc>
----
\\
{{:tut400.png?400}}
\\
2. Now connect your controller to your computer and run the command:
----
<fc purple>
ls /dev/input/
</fc>
----
A list of all the input devices on your computer will show up. Look for the jsX input (X stands for an arbitrary number). This is your joystick. 
\\
{{:tut401.png?400}}
\\
3. Use the following command to confirm that the joystick is working:
----
<fc purple>
sudo jstest /dev/input/jsX
</fc>
----
You should see the input values change as you move the joysticks around and press buttons.
\\
{{:tut402.png?400}} {{:tut403.png?400}}
\\
4. Now that you have confirmed that the controller works use this command to check the permissions of the joystick:
----
<fc purple>
ls -l /dev/input/jsX
</fc>
----
\\
{{:tut404.png?400}}
\\
If you see rw where the red box is then it is configured properly. If not run the following command to change the permission:
----
<fc purple>
sudo chmod a+rw /dev/input/jsX
</fc>
----
\\
{{:tut405.png?400}}
\\
Now open a new terminal and run:
----
<fc purple>
roscore
</fc>
----
\\
5. Now we need to tell the joy node where to look for the joystick. The default setting is js0 so if your joystick is already js0 you don't have to do this step but doing it won't hurt. Run the command to tell the node where to look:
----
<fc purple>
rosparam set joy_node "/dev/input/jsX"   
</fc>
----
\\
6. Now run these commands to check that the node and the joystick are properly communicating:
----
<fc purple>
rosrun joy joy_node
</fc>
----
\\
{{:tut406.png?400}}
\\
Then in a new terminal:
----
<fc purple>
rostopic echo joy
</fc>
----
You should see the output of joy change as you play with the controller. Note: you won't see anything in the terminal until you start playing with the controller. 
\\
{{:tut407.png?400}} {{:tut408.png?400}}
\\

==Implementing Joy with PODO==
1. Open a new terminal and create a new package inside your ROS workspace. First:
----
<fc purple>
cd ~/catkin_ws/src
</fc>
----
then:
----
<fc purple>
catkin_create_pkg hubo_joy roscpp joy
</fc>
----
\\
2. Now create a cpp file inside the src folder of your new package. 
----
<fc purple>
gedit hubo_joy/src/hubo_teleop.cpp
</fc>
----
and copy the following code into it:

<code cpp>
#include <ros/ros.h>
#include <geometry_msgs/Twist.h>
#include <sensor_msgs/Joy.h>


class TeleopHubo
{
public:
  TeleopHubo();

private:
  void joyCallback(const sensor_msgs::Joy::ConstPtr& joy);
  
  ros::NodeHandle nh_;

  int linear_, angular_;
  double l_scale_, a_scale_;
  ros::Publisher vel_pub_;
  ros::Subscriber joy_sub_;
  
};


TeleopHubo::TeleopHubo():
  linear_(1),
  angular_(2)
{

  nh_.param("axis_linear", linear_, linear_);
  nh_.param("axis_angular", angular_, angular_);
  nh_.param("scale_angular", a_scale_, a_scale_);
  nh_.param("scale_linear", l_scale_, l_scale_);


  vel_pub_ = nh_.advertise<geometry_msgs::Twist>("/cmd_vel", 1);


  joy_sub_ = nh_.subscribe<sensor_msgs::Joy>("joy", 10, &TeleopHubo::joyCallback, this);

}

void TeleopHubo::joyCallback(const sensor_msgs::Joy::ConstPtr& joy)
{
  geometry_msgs::Twist twist;
  twist.linear.x = l_scale_*joy->axes[linear_];
  twist.angular.z = a_scale_*joy->axes[angular_];
  vel_pub_.publish(twist);
}


int main(int argc, char** argv)
{
  ros::init(argc, argv, "teleop_hubo");
  TeleopHubo teleop_hubo;

  ros::spin();
}
</code>
The second ROS-joy tutorial will go over this code. Please refer to that for more information.
\\
6. Now open the CMakeLists.txt file inside your package using gedit:
----
<fc purple>
gedit [Path to your package]/CMakeLists.txt
</fc>
----
Once open you will need to find the 
----
<fc purple>
CATKIN_DEPENDS roscpp joy 
</fc>
----
line and uncomment it by deleting the '#' in front of it.
\\
{{:tut409.png?400}}
\\
Then add these two lines at the very end:
<code html>
add_executable(hubo_teleop src/hubo_teleop.cpp)
target_link_libraries(hubo_teleop ${catkin_LIBRARIES})
</code>
\\
{{:tut410.png?400}}
\\
7. Now go to your workspace:
----
<fc purple>
cd ~/catkin_ws
</fc>
----
and run:
----
<fc purple>
catkin_make
</fc>
----
\\
8. Now create a new launch folder and file. First the folder:
----
<fc purple>
mkdir [path to hubo_joy]/launch
</fc>
----
Then the file:
----
<fc purple>
gedit [path to hubo_joy]/launch/hubo_joy.launch
</fc>
----
Once opened copy this code into it:
<code html>
<launch>

 <!-- joy node -->
  <node respawn="true" pkg="joy"
        type="joy_node" name="hubo_joy" >
    <param name="dev" type="string" value="/dev/input/js0" />
    <param name="deadzone" value="0.1" />
  </node>

 <!-- Axes -->
  <param name="axis_linear" value="1" type="int"/>
  <param name="axis_angular" value="0" type="int"/>
  <param name="scale_linear" value="1.0" type="double"/>
  <param name="scale_angular" value="1.0" type="double"/>

  <node pkg="hubo_joy" type="hubo_teleop" name="teleop"/>

</launch>
</code>
Note: Inside the joy node the value is set to jsX. Please make sure that it is the correct jsX.
\\
--The deadzone value in the joy node section is how far you need to change the input controller value before the model actually moves.
\\  
--The values in the Axes section are all variable. The axis_linear/angular are what controller input it looks for. The values are the same as those you was when you used rostopic echo joy. 
\\
--The Scale values in the Axes section is how the code scales the controller input to the movement of the model. A larger scale value mean quicker movement, and lower value means slower. 
\\

9. Now open a new terminal and start the PODOLauncher to start Daemon. Launch the DRC-model in rviz and gazebo and open qt to run the PODOGUI.
\\

10. Once the gui is open connect it to Daemon and start the walk ready and omniwheel als. Go to the tutorial tab and click ROS Mode in the wheel control frame. You should see the message OMNIWHEEL ROS...!!! in Deamon three times. 
\\
{{:tut411.png?400}}
\\
11. Now you will be able to move the model using the joystick. The default is set to the left joystick forwards and back make the model move forwards and back while left and right will rotate the model left and right.  
\\

Here is a video of me opening all the needed software and code to control the model using the controller. 
\\
<fc red>Note: I didn't know that it was recording sound from my microphone as well so please mute the sound when playing.</fc>
\\
{{youtube>NdRKjCkB8aU?medium}}
\\

This is a separete page that I made for those who are interested in the PODO side of the code. The explanation is based off of the controller example you just finished. Again this is a short explanation but will hopefully help you understand better what is happening.  
\\
[[How PODO Works with ROS-Joy]] 

===Simple navigation of DRC-Hubo in wheel mode===

In this section we will use pre-prepaired code already inside the drc-hubo file. This section will take you through the various packages and stacks that you will need to download to get these files to work. I will also add videos at the end showing what you should see with the code running properly.
\\
There are two sets of code I will explain:
   *drc_slam
   *drc_navi

**==drc_slam==**
\\
{{:tut601.png?400}}
\\
As the name suggests this code will create start slam (Simultanious Locolization and Mapping) using DRC-Hubo's lidar. This code will allow the user to explore the simulated environment with the controller, relying on data retried from the lidar.
This code however will not allow autonomous navigation inside the simulator. Instead this code will use the ros-joy code used in the the previous example.

==Package installation== 

If you go into the launch file inside the drc_slam folder you will see the packages that the code needs to work. 
\\
You will notice that there are three packages needed. The twist-teleop-joy pkg, the gmapping pkg, and the rviz pkg. 
\\
{{:tut606.png?400}}
\\
**twist-teleop-joy**
\\
We have a substitute for the twist-teleop-joy pkg, the joy pkg. Go into the launch file and change the launch path to open the hubo_joy.launch file created in the previous example. Change to code: 
<code sdf>          
<include file="$(find teleop_twist_joy)/launch/teleop.launch"/>
</code>
into:
<code sdf>
<include file="$(find hubo_joy)/launch/hubo_joy.launch"/>
</code>
\\
{{:tut604.png?400}} {{:tut605.png?400}}
\\

**gmapping**
\\
You will need to download the gmapping pkg. If you are interested this is the [[http://wiki.ros.org/gmapping|documentation]] on the package.  
\\
1. First move into the src folder of your workspace
----
<fc purple>
cd ~/catkin_ws/src
</fc>
----
\\
2. Then download the stack from github and clone there.
----
<fc purple>
sudo git clone -b hydro-devel https://github.com/ros-perception/slam_gmapping.git 
</fc>
----
\\
{{:tut607.png?400}}
\\
3. Move back to the workspace:
----
<fc purple>
cd ..
</fc>
----
then make it:
----
<fc purple>
catkin_make
</fc>
----
\\
4. If you do not recieve any errors while making you have successfully downloaded the package. However if you did get some error please go through the error message to figure it out.  
\\

**rviz**
\\
You already have the rviz pkg as it came with the ROS installation. 

==Operation of drs_slam==
1. Run the PODOLauncher from the podo folder in drc_hubo.
----
<fc purple>
cd ~/catkin_ws/src/drc_hubo/podo/Execute\ Daemon
</fc>
----
then:
----
<fc purple>
./PODOLauncher
</fc>
----
\\
{{:tut18.png?00}} {{:tut20.png?400}}
\\
2. Run roscore and roslaunch the hubo silmulators.
----
<fc purple>
roscore
\\
roslaunch drc_podo_connector drc_hubo.launch 
</fc>
----
\\
{{tut13.png?400}} {{:tut22.png?400}}
\\
3. Run the GUI from qt
\\
{{:tut27.png?400}} {{:tut28.png?400}}
\\
4. Turn on the walkready and omniwheel ALs and get the model into walk ready -> wheel mode. Once the model has finished changing to wheel mode turn on ROS Mode for wheel control. 
\\
{{:tut_walkreadypos.png?400}} {{:tut_towheelpos.png?400}}
\\
5. Now launch the drc_slam code
----
<fc purple>
roslaunch drc_slam slam.launch
</fc>
----
6. You can now see that the rviz window used by the simulator launch closes and opens again showing the slam created by the code and the lidar information from gazebo. As you move around the map using the controller the slam will create new features as the lidar hits new terrain.  
\\
{{:tut601.png?400}}
\\
<fc red>
NOTE: The code will not work if the hubo simulator is not already open and the head is at 0 degrees. If the you moved the head position before opening the drc_slam code put it back to 0 degrees using the goto button. 
</fc>
\\
{{:tut600.png?400}}
\\
{{youtube>UVBvqP85h5M?medium}}
\\

**==drc_navi==**
\\
{{:tut610.png?400}}
\\
Similar to drc_slam if you take a look at the launch file for drc_navi you can see the needed packages needed for this code. The packages in this case being the map_server pkg, amcl pkg, move_base pkg, and rviz pkg. 
\\

==Package Installation==
**map_server, amcl, move_base**
\\
map_server, amcl, and move_base are all packages that come with the navigation stack. You will need to download this stack and the dependencies needed to catkin_make it.
\\
1. cd into your workspace src folder and download the navigation stack
----
<fc purple>
cd ~/catkin_ws/src
\\
git clone -b jade-devel https://github.com/ros-planning/navigation.git
</fc>
----
\\
{{:tut700.png?400}} {{:tut608.png?400}}
\\
Open the navigation stack folder and you will the various packages that the stack comes with. 
\\
{{:tut609.png?400}}
\\
2. You will need to go into each of the CMakeLists.txt files and change all instances of <fc red>eigen</fc> to <fc blue>eigen3</fc>. It doesn't matter if eigen is capitalized or not. You will need to do this for all packages except for :
   *amcl
   *fake_localization
   *global_planner
   *map_server
   *nav_core
   *navigation
   *robot_pose_ekf
   *voxel_grid
\\ 
{{:tut703.png?400}}
\\
Now you need to download/install other dependencies because if you try to make the navigation stack as it is, it will result in an error. 
\\
{{:tut702.png?400}}
\\
3. Open the Synaptic Package Manager find the <fc purple>libsdl-image1.2-dev</fc> and install it along with all of its dependencies. Once installed close the manager.
\\
{{:tut612.png?400}}
\\
4. In a new terminal install the bfl and move_base_msgs packages. However do not install these into the src of the workspace as this will cause the catkin_make to fail.
----
<fc purple>
sudo apt-get install ros-jade-bfl
\\
sudo apt-get instll ros-jade-move-base-msgs
</fc>
----
\\
5. Now cd into the workspace and make it.
----
<fc purple>
cd ~/catkin_ws
\\
catkin_make
</fc>
----
\\
==Operation of drc_navi==

1. Run the PODOLauncher from the podo folder in drc_hubo.
----
<fc purple>
cd ~/catkin_ws/src/drc_hubo/podo/Execute\ Daemon
</fc>
----
then:
----
<fc purple>
./PODOLauncher
</fc>
----
\\
{{:tut18.png?00}} {{:tut20.png?400}}
\\
2. Run roscore and roslaunch the hubo silmulators.
----
<fc purple>
roscore
\\
roslaunch drc_podo_connector drc_hubo.launch 
</fc>
----
\\
{{tut13.png?400}} {{:tut22.png?400}}
\\
3. Run the GUI from qt
\\
{{:tut27.png?400}} {{:tut28.png?400}}
\\
4. Turn on the walkready and omniwheel ALs and get the model into walk ready -> wheel mode. Once the model has finished changing to wheel mode turn on ROS Mode for wheel control.  
\\
{{:tut_walkreadypos.png?400}} {{:tut_towheelpos.png?400}}
\\
5. Now roslaunch the navi code:
----
<fc purple>
roslaunch drc_navi navi.launch
</fc>
----
\\
6. You will see the rviz window from the simulator launch code collapse and re-open with the navi map. Now you can take the 2-d navigation arrow to tell the model to move to a specified spot autonomously. However if you have a computer without a lot of computing power keep the distances between 2 points close. 
\\
{{youtube>7Txe-9tHzYA?medium}}