In this video we are going to see how to create a Python script that stops a robot if no message is received in the /cmd_vel topic after a certain period of time.
This is a video trying to answer the following question posted at the ROS answers forum.
In this video we are going to see how to configure the differential drive ROS controller for a wheeled robot using a Gazebo simulation.
This is a video trying to answer the question of Jaime posted at the ROS answers forum about how he cannot make the controller work, and receiving the error:
Controller Spawner couldn’t find the expected controller_manager ROS interface
Step1. Create Project
Let’s start with creating a new project in ROS development studio.
Notice: If you haven’t had an account yet. You can register one here for free.
Step2. Spawn a robot
As an example, we’ll use a self-build two-wheel differential drive robot.
You can test the code with your own robot with differential drive configuration.
Step3. Add the controller configuration file for your robot
Put the configuration file(e.g. the my_diff_drive.yaml file shows here) under the config folder, your source tree may look like this.
Let’s start by pasting the whole code from the question into the my_diff_drive.yaml file.
mobile_base_controller:
type : "diff_drive_controller/DiffDriveController"
left_wheel : 'wheel_left_joint'
right_wheel : 'wheel_right_joint'
publish_rate: 50.0 # default: 50
pose_covariance_diagonal : [0.001, 0.001, 1000000.0, 1000000.0, 1000000.0, 1000.0]
twist_covariance_diagonal: [0.001, 0.001, 1000000.0, 1000000.0, 1000000.0, 1000.0]
# Wheel separation and diameter. These are both optional.
# diff_drive_controller will attempt to read either one or both from the
# URDF if not specified as a parameter
wheel_separation : 1.0
wheel_radius : 0.3
# Wheel separation and radius multipliers
wheel_separation_multiplier: 1.0 # default: 1.0
wheel_radius_multiplier : 1.0 # default: 1.0
# Velocity commands timeout [s], default 0.5
cmd_vel_timeout: 0.25
# Base frame_id
base_frame_id: base_footprint #default: base_link
# Velocity and acceleration limits
# Whenever a min_* is unspecified, default to -max_*
linear:
x:
has_velocity_limits : true
max_velocity : 1.0 # m/s
min_velocity : -0.5 # m/s
has_acceleration_limits: true
max_acceleration : 0.8 # m/s^2
min_acceleration : -0.4 # m/s^2
has_jerk_limits : true
max_jerk : 5.0 # m/s^3
angular:
z:
has_velocity_limits : true
max_velocity : 1.7 # rad/s
has_acceleration_limits: true
max_acceleration : 1.5 # rad/s^2
has_jerk_limits : true
max_jerk : 2.5 # rad/s^3
Step4. Create Launch file
For our case, the launch file should look something similar like this.
The args for the controller should have the same name in the .yaml file which is “mobile_base_controller”
According to the .yaml file, there is no namespace /robot here, so we don’t need to add this to the controller node.
Things to make sure:
The left wheel and right wheel in the .yaml file should be the same as your robot’s URDF definition.
The gazebo controller should be added to the URDF definition as well as the transmission tag which will be used for the gazebo controller. In our case, we add the following code in the .urdf to add gazebo control in it.
If you see the following topics, then your controller is up and run correctly.
Takeaway today:
The arg name of the controller node should be the same as in the controller configuration file.
Don’t specify robot namespace if you are not using it.
The joint name in the controller configuration file should be the same as the name in urdf
The gazebo_ros_control plugin should also be added to the urdf file.
Remember to compile again before you run.
If you want to learn more about ROS control and how to build a two-wheel robot in ROS from scratch, please visit Robot Ignite Academy for more information.
To visualize the robot model and laser scan, click add at the left bottom corner and select robot model and laser scan. Select topic /scan in the laser scan and make sure you choose a proper size.
Then we add two map visualization by clicking add and set one to visualize the global cost map and another to visualize the local cost map.
To visualize the path plan, we add two Path visualization. Notice: choose correct topics
Now if you close the Rviz, every setting you’ve done will disappear!
Step 3. Save Rviz settings
let’s create a package named husky_nav_rviz by type the following command under ~/catkin_ws/src directory
$ catkin_create_pkg husky_nav_rviz
and create a rviz folder under it.
Then we back to rviz and select File -> save config as to save the path_planning.rviz config file under the folder we just created.
You can close RViz once you are sure the path_planning.rviz is in the folder.
Step 4. Load Rviz settings
By select the path_planning.rviz file from File -> Open Config you can get all your settings back, or you can use the following command
In this video, we are answering a question about why the range sensor plugin for Gazebo is not detecting obstacles. The answer to that problem will surprise you !!! (ha, ha, ha).
In this posting, we will go through a demo of laser data visualization
NOTE: This article assumes that the audience is familiar with the following:
Running scripts on the terminal
Ros filesystem layout (what goes where launch dir, src dir etc)
RDS Environment (How to launch a project, how to navigate the directories.
Step – 3. Briefly skim through the code and run it
First, we go through the contents of package.xml (located inside the fakeLaserScan directory) which has the following content
(NOTE comments are removed in this reproduced code snippet for brevity)
This file contains various pieces of information about the project such as the package dependencies (roscpp, rospy, sensor_msgs, std_msgs) project name, version, license, maintainer etc. Some of this information is vital for building the project (like the dependencies). While other information is important from the perspective of sharing one’s work with the community.
In the given contents of the package.xml file, we notice that the project name specified in the file (beginner_tutorials) is different from the directory name (fakeLaserScanner). While this will not cause the project to crash but it is inconsistent with the project naming guideline.
Next, we take a look at the code inside fakeLaserScan.cpp
This code creates a publisher with the name fakeScan
The scan values are being generated inside a for loop (line 15-18 (excluding the blank lines))
These scan values are then copied to a LaserScan message (line 20, 32-35)
The message is being published at line 36. Also, note that the publish rate is 1 Hz (line 12)
As all seems okay we will go ahead and build the project. On the console browse to the catkin_ws directory and then run
$ catkin_make
This should proceed without any errors.
Next, we launch the project with the following command
$ roslaunch beginner_project fakeLaserScan.launch
This also should proceed without any errors.
Now we will open another console from the Tools menu and verify the topics with following commands
$ rostopic list
Outputs :
/fakeScan
/rosout
/rosout_agg
In the result, we see out topic /fakeScan appears. Further, we can check if the topic is publishing the correct information or not with the following command
Let’s try this out and solve this problem in ROS Development Studio. You can register a free account and follow the tutorial below!
Step1: create a package
After creating a new project in RDS, open a new shell from the tools tab and type the following command into the shell to create a ROS package.
cd catkin_ws/src/
catkin_create_pkg video_qa rospy
Step2: create a test file for the code.
It’s easier to do this with an IDE. You can find IDE in the tools tab.
Now right click and select the new file to open a new file testunder the folder /video_qa/src
Paste the following code into the test file.
#! /usr/bin/env python
import rospy
rospy.init_node('test')
rate = rospy.Rate(1)
while not rospy.is_shutdown():
print "Hello there"
rate.sleep()
Step3: create a launch file
According to ROS’s file structure, the launch file should be created under the launch directory. Let’s create it with the IDE and add a test.launch file under the /video_qa/launch folder.
To run the code with roslaunch, we need to start roscore. You can either do that by typing roscore into the shell or start a simulation from the Simulations tab.
Step5: rosrun and roslaunch
Firstly, we try to directly execute the test file using rosrun video_qa test, but we got some error message.
[rosrun] Couldn’t find executable named test below /home/user/catkin_ws/src/video_qa
…
That’s because of the lack of permission for this file. We can give the file permission by typing:
chmod +x video_qa/src/test
then we do rosrun video_qa test again. It works!
Then we try roslaunch video_qa test.launch. Strangely, it also works…WHY?
It turns out if we name the file test.py instead of test, we will have the same problem. To solve it, we rename the file to test.py and also in the launch file we use test.py instead of test.
TAKEAWAY:
Always name the file with extension(e.g. test.py). However, the type in the launch file takes the executable during the compiling process. Since there is no need for compiling .py file. If you use python, just put the file name with the extension(e.g. test.py) in the type section.
I hope you enjoy the ROS Q&A video today. If you are interested in learning ROS, please check the links below for the Robot ignite academy.
In this video, we are going to answer a question found at ROS answers (https://goo.gl/ws2Whw). The person is asking why he cannot show the laser data of a fake laser given that he is publishing the proper frame and even a static transform from the laser to map. Very simple and surprise answer!
Step 1. Create project
Instead of installing and configuring a ROS environment locally, we can easily reproduce this question in ROS Development Studio. You can register an account for free now! After signing up and creating a new project, we can clone the repo provided in the question into the workspace. Open a Shell window in the Tools tab and type the following command:
Step 3. Check if the topic is publishing correctly
To check if the node we just launched really publishing something, we open another shell and type
$ rostopic echo -n1 /fakeScan
The fakeScan topic is publishing.
Let’s check it further with Rviz by typing.
$ rosrun rviz rviz
1.In order to see Rviz running in the RDS, open the Graphical Tools in the Tools Tab.
2.Add a LaserScan visualization.
3. The visualization is not showing due to some problems with the frame.
4. Let’s change the fixed frame to the fake_laser_frame
Now everything looks fine but the laserscan still not showing.
How come?
It turns out, in this particular example, it’s not showing simply because the size of the visualization is too small to be seen. Let’s change the size.
Takeaway Today:
You can check if one topic is publishing correctly by typing rostopic echo /TOPICNAME
If you want to check the topic in RViz, remember to select correct topic type, correct frame and choose a proper size!
If you want to learn more about ROS, we have ROS courses for different levels available in Robot Ignite Academy. You can preview any of them for free.
Edit by Tony Huang
[irp posts=”7406″ name=”ROS Q&A | How to merge data from two different lasers”]
![[ROS Q&A] 126 – How to configure the differential drive ROS controller](https://www.theconstruct.ai/wp-content/uploads/2018/05/How-to-configure-the-differential-drive-ROS-controller.png)
![[ROS Q&A] 125 – Save and load RViz configuration](https://www.theconstruct.ai/wp-content/uploads/2018/05/Save-and-load-RViz-configuration.png)
![[ROS Q&A] 124 – Range sensor does not detect obstacles in Gazebo](https://www.theconstruct.ai/wp-content/uploads/2018/05/Range-sensor-does-not-detect-obstacles-in-Gazebo.png)
![[ROS Q&A] 123 – Roslaunch can’t locate node, but rosrun works fine](https://www.theconstruct.ai/wp-content/uploads/2018/05/ROS-QA-123-Why-roslaunch-cant-locate-node-but-rosrun-works-fine-.png)
![[ROS Q&A] 122 – How to show laser data on Rviz](https://www.theconstruct.ai/wp-content/uploads/2018/05/laser_data_on_Rviz_capture.png)
