This is a search for all Tutorials on ROS.org:
All Tutorials
- Building a ROS Package
This tutorial covers using rosmake to build a package, and rosdep to install system dependencies.
- Creating a ROS msg and srv
This tutorial covers how to create and build msg and srv files as well as the rosmsg, rossrv, roscp, and rosmake commandline tools.
- Creating a ROS Package
This tutorial covers using roscreate-pkg to create a new package, and rospack to list package dependencies.
- Examining the Simple Publisher and Subscriber
This tutorial examines running the simple publisher and subscriber.
- Examining the Simple Service and Client
This tutorial examines running the simple service and client.
- Getting started with roswtf
Basic introduction to the roswtf tool.
- Running ROS across multiple machines
This tutorial explains how to start a ROS system using two machines. It explains the use of ROS_MASTER_URI to configure multiple machines to use a single master.
- Navigating the ROS Filesystem
This tutorial introduces ROS filesystem concepts, and covers using the roscd, rosls, and rospack commandline tools.
- Navigating the ROS wiki
This tutorial discusses the layout of the ROS wiki (ros.org) and talks about how to find what you want to know.
- Recording and playing back data
This tutorial will teach you how to record data from a running ROS system into a .bag file, and then to play back the data to produce similar behavior in a running system
- Understanding ROS Nodes
This tutorial introduces ROS graph concepts and discusses the use of roscore, rosnode, and rosrun commandline tools.
- Understanding ROS Services and Parameters
This tutorial introduces ROS services, and parameters as well as using the rosservice and rosparam commandline tools.
- Understanding ROS Topics
This tutorial introduces ROS topics as well as using the rostopic and rxplot commandline tools.
- Using rosed to edit files in ROS
This tutorial shows how to use rosed to make editing easier.
- Using rxconsole and roslaunch
This tutorial introduces ROS using rxconsole and rxloggerlevel for debugging and roslaunch for starting many nodes at once.
- Writing a Simple Publisher and Subscriber (C++)
This tutorial covers how to write a publisher and subscriber node in C++.
- Writing a Simple Publisher and Subscriber (Python)
This tutorial covers how to write a publisher and subscriber node in python.
- Writing a Simple Service and Client (C++)
This tutorial covers how to write a service and client node in C++.
- Writing a Simple Service and Client (Python)
This tutorial covers how to write a service and client node in python.
- How to Roslaunch Nodes in Valgrind or GDB
When debugging roscpp nodes that you are launching with roslaunch, you may wish to launch the node in a debugging program like gdb or valgrind instead. Doing this is very simple.
- Roslaunch tips for large projects
This tutorial describes some tips for writing roslaunch files for large projects. The focus is on how to structure launch files so they may be reused as much as possible in different situations. We'll use the 2dnav_pr2 package as a case study.
- Producing filtered bag files using rosrebag
This tutorial will cover using rosrebag to filter bag files into new bag files using topic and data information
- Recording and playing back data
This tutorial will teach you how to record data from a running ROS system into a so-called bag file, and then to play back the data to produce similar behavior in a running system
- Producing filtered bag files
This tutorial will cover using rosbag filter to filter bag files into new bag files using topic and data information
- Recording and playing back data
This tutorial will teach you how to record data from a running ROS system into a .bag file, and then to play back the data to produce similar behavior in a running system
- How to add support for an OS into rosdep
This will walk you through what is needed to do to add detection support for a new OS to rosdep.
- How to add an OS tag for a rosdep.yaml entry
This will walk you through adding an entry for rosdep.yaml for a new OS
- Add support for a new system dependency
This will show you how to add support for a new system dependency.
- How to add a system dependency to a package.
This shows how to add a system dependency to a package.
- Running the object pickup pipeline
- Getting started with arm navigation
This tutorial describes how to get started with using the arm navigation stack to plan and control a robot arm.
- Moving the arm to a joint goal
In this tutorial, we will use a simple action client to get the move_arm node to move the arm to a joint goal.
- Moving the arm to a pose goal
In this tutorial, we will use the action client to send a pose goal for the move_arm node to move the arm to.
- Specifying complex pose goal constraints
In this tutorial, we will use the action client to send a pose goal for the move_arm node to move the arm to. We will also learn how to specify a region of tolerance for the pose goal using a geometric shape.
- Specifying path constraints for motion planning
This tutorial will show you how to specify path constraints for move_arm. This is useful, e.g., if you want to execute tasks like moving a glass with water in it. You can use the path constraints to specify that the glass should stay approximately upright.
- ''Safe'' arm trajectory control
This package implements a simple action interface to a safe arm trajectory controller. The controller will execute a desired trajectory only if the trajectory will not result in self collisions or a collision with the environment.
- Configuring the Prosilica GigE for a Desktop
This tutorial covers configuring the Prosilica camera for a desktop and viewing images.
- How to Determine Your Prosilica GigE Camera's IP Address
This tutorial will show you how to determine the prosilica camera's IP address if you do not remember it.
- Configuring the Prosilica GigE for the PR2
This tutorial covers configuring the Prosilica camera for a PR2 and viewing images.
- Introduction to working with the Prosilica camera.
This introduction will teach you how to work with a pre-configured Prosilica camera.
- How to Configure and Use the WGE100 Camera
This tutorial is an introduction to using the WGE100 camera connected to a desktop. After reading it you should be able to bring up the WGE100 camera, configure the camera, and display the images.
- How to Configure and Use the WGE100 Stereo Camera on a PR2
This tutorial is an introduction to using the WGE100 stereo camera connected to a PR2 robot. After reading it you should be able to bring up the WGE100 stereo camera and display the images.
- Running the WGE100 camera in externally triggered mode
This tutorial covers using an external trigger with the WGE100 camera on the PR2.
- Implementing a simple filter
This will describe how to implement a simple filter. This filter will simply add 1 to any incoming value. This filter exists in the filter package. The version for this tutorial has been isolated from other example files in the filters package.
- Analyzing Diagnostic Logs Off-Line
This tutorial uses the diagnostic_analysis package to analyze a robot log file. These files are generated automatically by the robots when they're running and contain the entire diagnostics history of the robot. You can convert these log files into CSV files (comma separated value) that can be opened with any spreadsheet editor. This only works with diagnostic_msgs/DiagnosticArray messages on the /diagnostics topic, used in the PR2 diagnostic toolchain.
- Configuring a Robot's Diagnostic Aggregator
This tutorial will help you set up and configure a diagnostic aggregator, using the PR2 as an example. The Aggregator can be configured for a robot or type of robot to perform basic analysis on the diagnostics.
- Creating a Diagnostic Analyzer
An example of how to write your own diagnostic analyzer plug-in for the diagnostic_aggregator.
- Starting the Runtime Monitor
The runtime_monitor is a useful tool for monitoring the state of your robot. It subscribes to the "/diagnostics" topic and displays the data into a simple, easy to use, format.
- Using the GenericAnalyzer
Uses the GenericAnalyzer to analyze diagnostics from EtherCAT devices, hardware drivers and robot computers. Shows the complete feature set of the GenericAnalyzer.
- Using the Robot Monitor
The Robot Monitor is used to view the aggregated diagnostics of a robot. It's useful to view diagnostics data to diagnose and debug hardware and driver problems.
- An introduction to Agent Actions
In this tutorial you will learn about a standard T-REX model element (an AgentAction) for encapsulating modular, goal-achieving behaviors.
- Create your first action
In this tutorial you will create an action and build a simple NDDL simulator for testing. This makes it easy to see how things work in the executive without getting into more complicated integration.
- Create and explore a simple Hello World project
In this tutorial you will create a T-REX demo project and execute a test case.
- Obtain, compile and test T-REX.
This tutorial will get you started using T-REX.
- Interactive execution and visualization
In this tutorial you will learn the basics of incremental, interactive execution and visualization of trex.
- Using the test harness
In this tutorial you will learn about the test harness structure put in place for testing the executive
- Visualize prior execution
In this tutorial you will learn the basics of using the trexmonitor tool to visualize execution
- Adding a dynamic frame (C++)
This tutorial teaches you how to add an extra dynamic frame to tf.
- Adding a dynamic frame (Python)
This tutorial teaches you how to add an extra dynamic frame to tf.
- Adding a frame (C++)
This tutorial teaches you how to add an extra fixed frame to tf.
- Adding a frame (Python)
This tutorial teaches you how to add an extra fixed frame to tf.
- Debugging tf problems
This tutorial gives a systematic approach for debugging tf related problems.
- Introduction to tf
This tutorial will give you a good idea of what tf can do for you. It shows off some of the tf power in a multi-robot example using turtlesim. This also introduces using tf_echo, view_frames, and rviz.
- Sensor messages in tf
This tutorial describes how to use sensor data with tf.
- Time travel with tf (C++)
This tutorial teaches you about advanced time travel features of tf
- Time travel with tf (Python)
This tutorial teaches you about advanced time travel features of tf
- Writing a tf broadcaster (C++)
This tutorial teaches you how to broadcast coordinate frames of a robot to tf.
- Writing a tf broadcaster (Python)
This tutorial teaches you how to broadcast the state of a robot to tf.
- Writing a tf listener (C++)
This tutorial teaches you how to use tf to get access to frame transformations.
- Writing a tf listener (Python)
This tutorial teaches you how to use tf to get access to frame transformations.
- Learning about tf and time (C++)
This tutorial teaches you to use the waitForTransform function to wait for a transform to be available on the tf tree.
- Learning about tf and time (Python)
This tutorial teaches you to use the waitForTransform function to wait for a transform to be available on the tf tree.
- Running the Simple Image Publisher and Subscriber with Different Transports
This tutorial discusses running the simple image publisher and subscriber using multiple transports.
- Managing Transport Plugins
This tutorial covers how to discover which transport plugins are included in your system and make them available for use. No programming required!
- Writing a Simple Image Publisher (C++)
This tutorial shows how to publish images using all available transports.
- Writing a Simple Image Subscriber (C++)
This tutorial shows how to subscribe to images using any available transport. By using the image_transport subscriber to subscribe to images, any image transport can be used at run-time. To learn how to actually use a specific image transport, see the next tutorial.
- Writing a New Transport
This tutorials covers how to write publisher and subscriber plugins for a new image transport option.
- How to Calibrate a Monocular Camera
This tutorial cover using the camera_calibration's cameracalibrator.py node to calibrate a monocular camera with a raw image over ROS.
- How to Calibrate a Stereo Camera
This tutorial cover using the camera_calibration's cameracalibrator.py node to calibrate a stereo camera with a left and right image over ROS.
- How to Use Inertial-Link IMUs with the imu_node
This tutorial is an introduction to using the MicroStrain Inertial-Link IMU connected to a desktop. After reading the tutorial, you should be able to bring up the imu_node and display the IMU data.
- How to Write a Generic Teleoperation Node
This tutorial goes over generic teleoperation code that is used as an example in many of the teleoperation tutorials.
- How to Use a SpaceNavigator with the spacenav_node
This tutorial is an introduction to using the 3DConnexion SpaceNavigator connected to a desktop. After reading this, you should be able to bring up the spacenav_node and display the data.
- Writing a Teleoperation Node for the SpaceNavigator
This tutorial covers how to write a teleoperation node and use it to drive the turtle in the turtlesim.
- Configuring and Using a Linux-Supported Joystick with ROS
This tutorial is an introduction to using the joystick connected to a desktop computer. After reading it, you should be able to bring up the joy node and display the data coming from the joystick over ROS.
- Writing a Teleoperation Node for a Linux-Supported Joystick
This tutorial covers how to write a teleoperation node and use it to drive the turtle in the turtlesim.
- How to Pair the PS3 Joystick with a Bluetooth Dongle
This tutorial is an introduction to using the PS3 DualShock 3 Joystick connected via bluetooth to a desktop computer. After reading it, you should be able to bring up the ps3joy node and display the data coming from the joystick.
- How to Recharge the PS3 Joystick
This tutorial explains how to recharge the PS3 DUALSHOCK 3 or SIXAXIS Joystick. The tutorial includes details on how to simultaneously use the joystick over Bluetooth and recharge it.
- Connecting the PS3 Joystick to the PR2
This tutorial is an introduction to using the PS3 DualShock 3 Joystick connected via bluetooth to a PR2.
- Writing a Teleoperation Node for the PS3 Joystick
This tutorial covers how to write a teleoperation node and use it to drive the turtle in the turtlesim.
- Making the Wiimote Blink and Rumble
How to use ROS messages to make a Wiimote device rumble (vibrate), and blink its LEDs. With this tutorial you will be able to use ROS command line tools to control rumble and LED states of a Wiimote device.
- Pairing and Using a Wiimote with ROS
Explains how to start a ROS Wiimote node, pair the wiimote with your computer, how the Wiimote device is calibrated, and how to test whether the node functions properly.
- Writing a Teleoperation Node for the Wiimote
This tutorial covers how to write a teleoperation node and use it to drive the turtle in the turtlesim.
- Configuring a Multiple Joystick System
This tutorial uses the joystick remapping node to allow two different joysticks to control a single robot.
- How to dynamically reconfigure the hokuyo_node from the command line or code.
After completing this tutorial, you will be able to reconfigure the parameters of the hokuyo_node from the command line or python code.
- How to Dynamically Reconfigure the hokuyo_node
This tutorial covers using the reconfigure_gui to dynamically reconfigure the hokuyo_node to run with different parameters. After reading this tutorial, you should be able to bring up the reconfigure_gui and change the hokuyo_node parameters.
- How to use Hokuyo Laser Scanners with the hokuyo_node
This tutorial is an introduction to using a Hokuyo laser scanner connected to a desktop. After reading this tutorial, you should be able to bring up the hokuyo_node and display the laser data.
- Using SICK Laser Scanners with the sicktoolbox_wrapper
This tutorial is an introduction to using a SICK laser scanner connected to a desktop. After reading this tutorial, you should be able to bring up the sicklms node and display the laser data.
- Introduction to Working With Laser Scanner Data
This tutorial guides you through the basics of working with the data produced by a planar laser scanner (such as a Hokuyo URG or SICK laser). To learn how to actually produce or change data from laser scanners, please see the laser_drivers stack.
- Laser filtering in C++
Raw laser scans contain all points returned from the scanner without processing. Many applications, however, are better served by filtered scans which remove unnecessary points (such as unreliable laser hits or hits on the robot itself), or pre-process the scans in some way (such as by median filtering). This tutorial will teach you how to apply pre-existing filters to laser scans.
- Using the laser filtering nodes
Raw laser scans contain all points returned from the scanner without processing. Many applications, however, are better served by filtered scans which remove unnecessary points (such as unreliable laser hits or hits on the robot itself), or pre-process the scans in some way (such as by median filtering). This tutorial will teach you how to apply pre-existing filters to laser scans.
- How to assemble laser scan lines into a composite point cloud
In this tutorial you will learn how to assemble individual laser scan lines into a composite point cloud. One particular use case is to assemble individual scan lines from a laser on a tilting stage into a single point cloud to form a full 3D laser sweep.
- Checking collisions for a given robot state
This tutorial will show you how to use the environment server to check whether a given robot state is collision free, within the joint limits and satisfies joint or cartesian constraints
- Checking collisions for a joint trajectory
This tutorial will show you how to check whether an input joint trajectory is in collision, violates joint limits or satisfies constraints.
- Displaying joint paths for the entire robot in rviz
This tutorial will teach you how to display a robot model in rviz and visualize joint paths for any set of joints on the robot.
- Sending Goals to the Navigation Stack
The Navigation Stack serves to drive a mobile base from one location to another while safely avoiding obstacles. Often, the robot is tasked to move to a goal location using a pre-existing tool such as rviz in conjunction with a map. For example, to tell the robot to go to a particular office, a user could click on the location of the office in a map and the robot would attempt to go there. However, it is also important to be able to send the robot goals to move to a particular location using code, much like rviz does under the hood. For example, code to plug the robot in might first detect the outlet, then tell the robot to drive to a location a foot away from the wall, and then attempt to insert the plug into the outlet using the arm. The goal of this tutorial is to provide an example of sending the navigation stack a simple goal from user code.
- Using rviz with the Navigation Stack
This tutorial provides a guide to using rviz with the navigation stack to initialize the localization system, send goals to the robot, and view the many visualizations that the navigation stack publishes over ROS.
- Adding a GPS sensor to the Robot Pose EKF Filter
This tutorial describes how to add GPS sensor input to the Robot Pose EKF Filter.
- Getting the current joint angles for the PR2
This tutorial shows you how to get the current joint angles for the PR2 robot.
- Moving the head
This tutorial shows you how to set a desired pose of the robot head using the existing head trajectory controller.
- Moving the arm through a Cartesian pose trajectory using inverse kinematics and the joint trajectory action
This tutorial teaches you how to move the arm through Cartesian pose trajectories using inverse kinematics and low-level joint controllers (the joint_trajectory_action).
- Moving the arm using the Joint Trajectory Action
This tutorial demonstrates moving the arm using the Joint Trajectory Action which is an interface to the lower-level Joint Trajectory Controller.
- Moving the gripper
This tutorial shows you how to move the PR2 gripper using the pr2_gripper_action (an action that runs the gripper controller).
- Moving the torso
This tutorial shows you how to move the PR2 torso using the single_joint_position_action.
- Using the base controller with odometry and transform information
We move the robot forward by a specified amount by using the low-level base controller together with transform information from odometry.
- Using the low-level robot base controllers to drive the robot
This tutorial teaches you how to start up and control the default robot base controllers (pr2_base_controller and pr2_odometry) directly, rather than at a high level (using move_base).
- Getting started with kinematics for the PR2
This tutorial will show you how to get started with computing position forward and inverse kinematics for the PR2.
- Getting kinematic solver info from a kinematics node
This tutorial will show you how to get information about the links and joints that a kinematics solver deals with.
- Forward kinematics for the PR2 arms
This tutorial will show you how to use a kinematics node to solve the forward kinematics and get the cartesian positions for the links on a PR2 arm.
- Inverse kinematics for the PR2 arms
This tutorial will show you how to use a kinematics node to solve the inverse kinematics and get the joint positions for a desired cartesian position of the PR2 arms.
- Collision free inverse kinematics for the PR2 arms
This tutorial will show you how to use a kinematics node to get collision free inverse kinematics solutions for a desired cartesian position of the PR2 arms.
- Adding a PID to a realtime joint controller
This tutorial teaches you how to add a PID object to a realtime joint controller
- Capturing data from a controller
This tutorial teaches you how to store data in a controller and extract it for offline viewing, debugging, and tuning.
- Coding a realtime Cartesian controller with Eigen
This tutorial gives example code for a realtime Cartesian controller using KDL and Eigen
- Coding a realtime Cartesian controller with KDL
This tutorial gives example code for a realtime Cartesian controller using KDL
- Communicating with a realtime joint controller
This tutorial teaches you how to communicate with a controller over ROS.
- Implementing a realtime Cartesian controller
This tutorial teaches you how to control a robot in Cartesian space
- Plotting controller data in matlab or octave
This tutorial teaches you how to visualize the captured state of a controller in matlab or octave.
- Incrementally develop and test a controller in simulation.
This tutorial walks you through the process of creating s simple custom controller, incrementally adding functionality to it and testing each step in simulation.
- Running a realtime Cartesian controller
This tutorial teaches you how to configure and run an existing Cartesian space controller
- Running a realtime joint controller
This tutorial teaches you how to configure and run an existing joint space controller
- Writing a realtime Cartesian controller
This tutorial teaches you how to control a robot in Cartesian space
- Writing a realtime joint controller
This tutorial teaches you how to write a joint space controller that can be executed in the realtime loop of pr2_controller_manager
- 2D Navigation Stack in Simulation
Testing the PR2 2D navigation stack in simulation given an example world with 2 desks as obstacles.
- Automated Regression Tests
Running the Gazebo regression tests on your machine.
- Building a Map in Simulation
Given a simple office environment and PR2 in simulation, how to create a map using the OpenSLAM GMapping package.
- Faking Sensor Info in Simulation
You can get ground truth information from the simulator rather than going through sensors.
- Multi-Level Map With Ramps
An example environment with multiple floor levels and ramps.
- PR2 Opens a Door
Simulated environment for testing autonomous door opening in simulation.
- Pendulum Examples
Simple pendulums examples.
- Debugging Gazebo plugins
You can run gazebo with gdb to debug real time controllers and plugins.
- Starting a Separate Sensor Generation Node
Start up an image sensor generation node when the main simulation node is running headless.
- Going from the simulator to the real world
How to interoperate between the simulator and the physical world.
- Starting PR2 in Simulation
Starting PR2 in Simulation
- Teleop PR2 Mobile Base In Simulation
Controlling PR2 base with keyboard and driving PR2 around in simulation.
- Using Custom Maps in Simulation
How to use a custom map for 2D navigation in Gazebo simulator.
- Stereo Processing in Simulation
Starting the necessary components for generating stereo cloud in simulation with PR2.
- Working with Gazebo over ROS
For the most part, working with Gazebo is the same as working with a robot.
- Attaching a ROS Ground Truth Pose Broadcaster to Objects in Simulation
Attaching a ROS ground truth pose broadcaster to objects in simulation
- Using the robot state publisher on your own robot
This tutorial explains how you can publish the state of your robot to tf, using the robot state publisher.
- Adding a Sensor to the PR2 URDF
This tutorial describes how to add a camera sensor to the PR2 URDF.
- Create your own urdf file
In this tutorial you start creating your own urdf robot description file.
- Parse a urdf file
This tutorial teaches you how to use the urdf parser
- Understanding the PR2 Robot Description, Part 1
This tutorial explains the layout of the top level URDF Xacro file for a complex robot such as PR2.
- Understanding the PR2 URDF description, Part 2
Describes one of the low-level components of the PR2 definition in full detail.
- Understanding the PR2 Robot Description Extensions for Gazebo Simulator
This tutorial explains URDF extensions used by Gazebo simulation.
- Start using the KDL parser
This tutorial teached you how to create a KDL Tree from a URDF file
- Retrieving Files
Demonstrates how to retrieve a file from a URL using the resource_retriever package
- Roslisp Basic Usage
This tutorial gives a brief intro to roslisp. For more, see the API documentation, and the code in the roslisp_examples ROS package.
- Running an Action Server and Client with Other Nodes
This tutorial covers running the averaging action server and client with another data node then visualizing the channel output and node graph.
- Writing a Simple Action Client
This tutorial covers using the simple_action_client library to create a Fibonacci action client. This example program creates an action client and sends a goal to the action server.
- Writing a Threaded Simple Action Client
This tutorial covers using the simple_action_client library to create a averaging action client. This example program spins a thread, creates an action client, and sends a goal to the action server.
- Writing a Simple Action Server using the Execute Callback
This tutorial covers using the simple_action_server library to create a Fibonacci action server. This example action server generates a Fibonacci sequence, the goal is the order of the sequence, the feedback is the sequence as it is computed, and the result is the final sequence.
- Writing a Simple Action Server using the Goal Callback Method
This tutorial covers using the simple_action_server library to create an averaging action server. This example shows how to use an action to process or react to incoming data from ros nodes. The action server averages data from a ros node, the goal is the number of samples to average, the feedback is the sample number, the sample data, the current average, and current standard deviation, and the result is the average and standard deviation of the requested number of samples.
- Writing a Simple Action Client (Python)
This tutorial covers using the action_client library to create a Fibonacci simple action client in Python.
- Writing a Simple Action Server using the Execute Callback (Python)
This tutorial covers using the simple_action_server library to create a Fibonacci action server in Python. This example action server generates a Fibonacci sequence, the goal is the order of the sequence, the feedback is the sequence as it is computed, and the result is the final sequence.
- Publishing messages in rospy
Writing a simple publisher and subscriber already introduced you to the basics of creating rospy Nodes that publish and receive messages on ROS Topics. As you get more experienced with ROS and rospy, you may wish to learn some advanced syntax for publishing that will save you some typing -- as well as make your code more robust to future changes.
- Logging with rospy
Logging messages to rosout is easy with rospy and encouraged. When you are running many nodes, seeing the command-line output of your node gets very difficult. Instead, it is much easier to publish a debugging message to rosout and then view it with rxconsole. rxconsole is "uber-console" of ROS and lets you view and filter the logging messages from all ROS nodes.
- Writing a ROS Python Makefile
I know what you're saying: "Python... Makefile?" Believe it or not, you do need Makefile (and CMakeLists), even if you just hack Python all day.
- Using Parameters in rospy
This tutorial covers the various ways in which you can get and set Parameters in rospy. Getting, setting and deleting parameters from a rospy Node is fairly simple.
- Setting Up Your PYTHONPATH
Setting up your PYTHONPATH is very easy. You already have to write a manifest.xml file that declares your dependencies, so ROS will use this same manifest file to help you set your PYTHONPATH (we try to use the DRY -- Don't Repeat Yourself -- principle as much as possible).
- Writing a Simple Publisher and Subscriber
This demo will walk you through creating a ROS package as well as creating two simple rospy nodes. The "talker" node will broadcast a message on topic "chatter", while the "listener" node will receive and print that message.
- Writing a Simple Service and Client
This tutorial covers how to write a service and client node in python.
- Using numpy with rospy
This tutorial covers using numpy with rospy, the ROS Python client library. Numpy is a popular scientific computing package for Python. You will often want to consider using Numpy with rospy if you are working with sensor data as it has better performance and many libraries for manipulating arrays of data.
- Accessing Private Names from a NodeHandle
This tutorial will show you how to access private Names with roscpp's NodeHandle API.
- Using Parameters in roscpp
This tutorial will show you the NodeHandle parameter API, allowing you to manipulate parameters from the Parameter Server.
- Understanding Timers
This tutorial explains roscpp Timers, which allow you to schedule a callback to happen periodically.
- Using Class Methods as Callbacks
Most of the tutorials use functions in their examples, rather than class methods. This is because using functions is simpler, not because class methods are unsupported. This tutorial will show you how to use class methods for subscription and service callbacks.
- Writing a Simple Publisher and Subscriber
This tutorial covers how to write a publisher and subscriber node in c++.
- Writing a Simple Service and Client
This tutorial covers how to write a service and client node in C++.
- Adding Objects to the World
Objects and robots are described using the URDF language, and added to a running Gazebo instance via ROS.
- Working with the Gazebo GUI
Describes basic interactions with Gazebo GUI, rotating view angles, selecting/moving models, selecting/applying forces on objects.
- Manipulating Objects in the World
This tutorial explains how to set object pose in simulation using the gazebo_ros_sim_iface plugin
- Running Simulator Headless
Running simulation without a graphics card or GLX support.
- Creating and Spawning URDF Objects in Simulation
Creating and Spawning URDF objects in simulation
- Installing and Starting Gazebo
How to get Gazebo up and running.
- Erratic Simulation
Simulating differential drive Erratic robot in 3D simulator and drive it around using ROS.
- 3D Willow Garage Map
Example 3D world generated from the Willow Garage map.
- Simulating One Robot in Stage
This tutorial shows you how to use the Stage simulator to simulate a single, Erratic-like robot, roaming an environment that looks a lot like the Willow Garage building.
- How to Build a Map Using Logged Data
This tutorial shows you how to create a 2-D map from logged transform and laser scan data.
- How to Configure and Use Speakers with sound_play
This tutorial is an introduction to setting up and using USB speakers connected to a desktop computer. After reading it, you should be able to bring up the speakers, configure the speakers, and play sounds.
- Filtering joint trajectories using the trajectory_filter_server
This tutorial will show you how to use the trajectory filtering service provided by the trajectory filter server.
- Generating collision free cubic spline trajectories
In this tutorial, you will learn to configure the joint trajectory filter node to generate collision free cubic spline trajectories.
- How to control a Crust Crawler Smart Arm with Dual Gripper using the smart_arm node
This tutorial describes how to control your Crust Crawler Smart Arm using the smart_arm node.
- How to use a Crust Crawler Smart Arm with Dual Gripper with the smart_arm node
This tutorial describes how to configure the smart_arm node for use with your Crust Crawler Smart Arm with Dual Gripper. The next tutorial will describe how to control the Smart Arm through the smart_arm node.
- Testing a Phidget Accelerometer
This tutorial shows you how to connect a Phidget accelerometer and view axes data changes published to a ROS topic.
- Testing a Phidget RFID Reader
This tutorial shows you how to test a Phidget RFID reader and view tag data changes published to a ROS topic.
- Using CvBridge to convert between ROS images and OpenCV images
This tutorial describes how to interface ROS and OpenCV by converting ROS images into OpenCV images, and vice versa, using CvBridge. Included is a sample node that can be used as a template for your own node.
- 2d Navigation on an Erratic
This tutorial describes how to run a 2d-navigation stack on erratic robots with different laser configurations.
- Build and Bringup of the Navigation Stack
This tutorial provides a step-by-step guide to building and running the navigation stack on a PR2 robot. Before you begin this tutorial, please make sure that you follow the PR2/StartRobot. We assume that you successfully brought up everything from that step.
- Addings objects to the planning environment
The tutorial describes the process of adding an object to the planning environment, which should allow for collision checking against the object as well as point cloud filtering around the object.
- Towers of Hanoi Usage
This tutorial covers how to run the Towers of Hanoi puzzle
- ROS パッケージのビルド
このチュートリアルではパッケージをビルドする rosmake とシステムに依存関係をインストールする rosdep についてカバーします．
- ROS メッセージとサービスの作成
このチュートリアルでは ROS メッセージ（msg）とサービス（srv） ファイルの作成方法と，rosmsgやrossrv・roscp・rosmake といったコマンドライン-ツールの使用法についてカバーします．
- ROS パッケージの作成
このチュートリアルでは，新しいパッケージを作成する roscreate-pkg とパッケージの依存関係をリスト化する rospack コマンドについてカバーします．
- シンプルな発行者と購読者の検査
このチュートリアルでは，起動しているシンプルな配信者と購読者について検査します．
- シンプルなサービスとクライアントの検査
このチュートリアルでは，起動中のシンプルなサービスとクライアントについて検査する
- ROS wiki の使い方
このチュートリアルでは，ROS wiki (ros.org)のレイアウトについて説明し，あなたが知りたいことの見つけかたについてお話します．
- ROS ノードについて理解する
このチュートリアルでは ROS グラフの概念について議論します．また，roscore や rosnode・rosrun といったコマンドライン-ツールの使用法についてもカバーします．
- ROS サービスとパラメータについて理解する
このチュートリアルでは，ROS サービスとパラメータ， rosservice と rxparam コマンドライン-ツールについて紹介します．
- ROS トピックについて理解する
このチュートリアルでは，ROS トピックについて， rostopic と rxplot コマンドライン-ツールを使いながら紹介します．
- ROS のファイルを編集する rosed の使い方
このチュートリアルでは，編集を楽にする rosed の使い方を紹介します．
- rxconsole と roslaunch を使う
このチュートリアルでは，デバッグに rxconsole と rxloggerlevel を使います．また，たくさんのノードを一度に起動するために， roslaunch を使います．
- シンプルな配信者と購読者を書く (C++)
このチュートリアルでは，c++ による配信者と購読者の書き方を説明します．
- ノードハンドルからプライベートネームで接続する
このチュートリアルでは，roscpp のノードハンドルAPIを用いて，プライベートネームに接続する方法について説明します．
- シンプルな配信者と購読者を書く
このチュートリアルでは，C++ によるサービスやクライアントの作り方について説明します．
- シンプルなサービスとクライアントを書く
このチュートリアルでは，C++ によるサービスやクライアントの作り方について説明します．
- Annotating image through action interface
The tutorial walks through the process of launching ROS action to annotate images and creating a simple client that sends images for annotation.
- Annotating images through command line tools
The tutorial demonstrates cv_mech_turk2 command line tools - the easiest way to annotate images in bulk.
- Basic image annotation tutorial
This tutorial walks through the process of creating a simple task and annotation session; submitting images, doing manual grading and retrieving the results.
- Creating new image annotation tasks
- Installing annotation server for Mechanical Turk
The tutorial describes how to install the annotation server, setup testing fixtures, run unit tests against the server and create user accounts.
- Moving the PR2 arm using command line
This tutorial is a brief introduction on how to start up motion planning for the arm.
- How to collect data
How to collect data
- All of the deprecated tutorials in one place.
All of the text from the deprecated tutorials.
- Processing Results with the Stair Vision Library
Processing results using the Stair Vision Library
- Simulating the 2dnav Stack
This tutorial describes how to simulate a 2d-navigation stack in gazebo.
- Running PR2 Self Test
The PR2 Self Test system is designed to examine and test the hardware of the PR2. The self test system can examine joints, motors, sensors and computers.
- Controlling the Camera Pan/Tilt Joints of the Wubble Robot.
This tutorial describes how to control the camera pan tilt joints of the Wubble Robot by publishing angle information to the controller.
- Controlling the Laser Tilt Joint of the Wubble Robot.
This tutorial describes how to control the laser tilt joint of the Wubble Robot by publishing angle and number of cycles information to the controller.
ROS
ROS is an open-source, meta-operating system for your robot. It provides the services you would expect from an operating system, including hardware abstraction, low-level device control, implementation of commonly-used functionality, message-passing between processes, and package management. It also provides tools and libraries for obtaining, building, writing, and running code across multiple computers.
The ROS runtime "graph" is a peer-to-peer network of processes that are loosely coupled using the ROS communication infrastructure. ROS implements several different styles of communication, including synchronous RPC-style communication over Services, asynchronous streaming of data over Topics, and storage of data on a Parameter Server. These are explained in greater detail in our Conceptual Overview.
arm_navigation
The arm navigation stack contains the action/behavior used to execute collision free motion planning and control for a robot arm manipulator. Included in this stack are the messages required for an action interface that can be used to specify and abort goals for the move_arm action. An implementation for arm navigation on the PR2 robot can be found in the pr2_arm_navigation stack.
camera_drivers
This stack contains drivers for a variety of cameras, and some associated tools.
common
A set of code and messages that are widely useful to all robots. Things like generic robot messages (i.e., kinematics, transforms), a generic transform library (tf), laser-scan utilities, etc.
diagnostics
Packages related to gathering, viewing, and analyzing diagnostics data from robots.
executive_trex
trex
geometry
The basic geometric and math libraries used in ros.
image_common
Common code for working with images in ROS.
image_pipeline
image_pipeline fills the gap between getting raw images from a camera driver and higher-level vision processing.
imu_drivers
A stack for any drivers relating to Inertial Measurement Units (IMU).
joystick_drivers
This stack contains a ROS node to interface with joysticks, and drivers for joysticks that are not well supported by a common Linux distribution.
laser_drivers
This stack contains drivers for laser rangefinders, including Hokuyo SCIP 2.0-compliant and SICK models.
laser_pipeline
Libraries from processing laser data, including converting laser data into 3D representations.
motion_planning_environment
The motion_planning_environment stack contains packages that can be used to monitor the world and the state of the robot for collisions. It contains two packages: planning_environment which contains the monitors and planning_environment_msgs which contains the messages and services that can be used for collision checking, adding and clearing objects and monitoring of the robot state and trajectories.
motion_planning_visualization
motion_planning_visualization
navigation
A 2D navigation stack that takes in information from odometry, sensor streams, and a goal pose and outputs safe velocity commands that are sent to a mobile base.
pr2
pr2
pr2_kinematics
This stack contains an implementation of kinematics for the PR2 robot.
pr2_mechanism
The pr2_mechanism stack contains the infrastructure to control the PR2 robot in a hard realtime control loop. The main interface to packages in this stack is through C++, but it is possible to interact with controllers through a ROS API. While the stack is currently aimed at controlling the PR2 robot, it should work on most force-controlled robots.
pr2_simulator
PR2-specific simulation components. These include plugins and launch scripts necessary for running PR2 in simulation.
robot_model
robot_model contains packages for modeling various aspects of robot information, specified in the Xml Robot Description Format (URDF). The core package of this stack is urdf, which parses URDF files, and constructs an object model (C++) of the robot.
ros_experimental
Experimental packages for ROS core system development.
ros_pkg_tutorials
ros_pkg_tutorials is a stack for teaching different aspects of ros-pkg.
ros_tutorials
ros_tutorials contains packages that demonstrate various features of ROS, as well as support packages which help demonstrate those features.
simulator_gazebo
Wrappers for using ROS with the Gazebo simulator.
simulator_stage
2D simulation using the Stage multi-robot simulator.
slam_gmapping
slam_gmapping contains the gmapping package, which provides SLAM capabilities. GMapping is a Creative-Commons-licensed open source package provided by OpenSlam.
sound_drivers
This stack is the common place for all sound related drivers. Currently the only driver is sound_play, which can be used to play WAV and OGG files, synthesize speech and play builtin sounds, over any device supported by pygame (SDL).
trajectory_filters
This stack contains a set of filters to work with joint trajectories. It also contains a trajectory filter server which is a ROS node that exposes a ROS service interface to a chain of filters.
ua_controllers
This stack contains higher level controllers for the Wubble Robot, which generally depend on packages in the ua_drivers stack for interfacing with the hardware. Thus, packages in this stack provide a higher level of abstraction for Wubble Robot subsystems than ua_drivers.
ua_drivers
This stack contains ROS drivers for Phidgets pressure, RFID and accelerometer sensors, Dynamixel AX-12 servos, and two interfaces for the Videre STOC camera.
vision_opencv
opencv c++ and python libraries.
Tutorials with no stack