This is a search for all Tutorials on ROS.org:

All Tutorials

    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.

    1. Setting up an XCode Project

      This tutorial show how to create a basic native OSX application for ROS.

    2. Building a ROS Package

      This tutorial covers using rosmake to build a package, and rosdep to install system dependencies.

    3. 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.

    4. Creating a ROS Package

      This tutorial covers using roscreate-pkg to create a new package, and rospack to list package dependencies.

    5. Examining the Simple Publisher and Subscriber

      This tutorial examines running the simple publisher and subscriber.

    6. Examining the Simple Service and Client

      This tutorial examines running the simple service and client.

    7. Getting started with roswtf

      Basic introduction to the roswtf tool.

    8. 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.

    9. Navigating the ROS Filesystem

      This tutorial introduces ROS filesystem concepts, and covers using the roscd, rosls, and rospack commandline tools.

    10. 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.

    11. 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

    12. Stack Installation

      This tutorial describes how to install 3rd party stacks

    13. Understanding ROS Nodes

      This tutorial introduces ROS graph concepts and discusses the use of roscore, rosnode, and rosrun commandline tools.

    14. Understanding ROS Services and Parameters

      This tutorial introduces ROS services, and parameters as well as using the rosservice and rosparam commandline tools.

    15. Understanding ROS Topics

      This tutorial introduces ROS topics as well as using the rostopic and rxplot commandline tools.

    16. Using rosed to edit files in ROS

      This tutorial shows how to use rosed to make editing easier.

    17. Using rxconsole and roslaunch

      This tutorial introduces ROS using rxconsole and rxloggerlevel for debugging and roslaunch for starting many nodes at once.

    18. Writing a Simple Publisher and Subscriber (C++)

      This tutorial covers how to write a publisher and subscriber node in C++.

    19. Writing a Simple Publisher and Subscriber (Python)

      This tutorial covers how to write a publisher and subscriber node in python.

    20. Writing a Simple Service and Client (C++)

      This tutorial covers how to write a service and client node in C++.

    21. Writing a Simple Service and Client (Python)

      This tutorial covers how to write a service and client node in python.

    22. Roslisp Basic Usage

      This tutorial gives a brief intro to roslisp. For more, see the API documentation, and the code in the roslisp_tutorials ROS package.

    23. 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.

    24. 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.

    25. 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

    26. 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

    27. Producing filtered bag files

      This tutorial will cover using rosbag filter to filter bag files into new bag files using topic and data information

    28. 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

    29. 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.

    30. 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

    31. Add support for a new system dependency

      This will show you how to add support for a new system dependency.

    32. How to add a system dependency to a package.

      This shows how to add a system dependency to a package.

    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.

    1. Running the object pickup pipeline

    2. 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.

    3. 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.

    4. 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.

    5. 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.

    6. 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.

    7. ''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.

    articulation

    This stack provides software that can recover articulation models given 3D or 6D pose trajectories.

    The articulation_models package defines messages and services for exchanging trajectories and kinematic models. Models can be fitted to the data, and selected according to the Bayesian information criterion (BIC). The models assign likelihoods to observed trajectories, predict the current configuration of the object, predict the pose, predict the Jacobian, etc.

    Several demonstration launch files are available in the package demo_fitting.

    1. Getting started with Articulation Models

      This tutorial guides you step-by-step through the available tools for fitting, selecting and displaying kinematic trajectories of articulated objects. We will start with preparing a text file containing a kinematic trajectory. We will use an existing script to publish this trajectory, and use the existing model fitting and selection node to estimate a suitable model. We will then visualize this model in RVIZ.

    2. Using the Articulation Model Library (C++)

      This tutorial demonstrates how to use the articulation model library directly in your programs. This is more efficient than sending ROS messages or ROS services. In this tutorial, a short program is presented that creates an artificial trajectory of an object rotating around a hinge, and then uses the model fitting library to recover the rotational center and radius. Further, the sampled trajectory and the fitted model are publishes as a ROS message for visualization in RVIZ.

    3. Using the Articulation Models (Python)

      In this tutorial, you will create a simple python script that calls ROS services for model fitting and selection. The script will output the estimated model class (like rotational, prismatic, etc.) and the estimated model parameters (like radius of rotation, etc.).

    camera_drivers

    This stack contains drivers for a variety of cameras, and some associated tools.

    1. 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.

    2. 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.

    3. Running the WGE100 camera in externally triggered mode

      This tutorial covers using an external trigger with the WGE100 camera on the PR2.

    4. How to Calibrate an IEEE 1394 Camera

      This tutorial explains how to calibrate an IEEE 1394 camera.

    5. How to Configure IEEE 1394 Camera Features

      This tutorial explains how to set IIDC feature parameters for an IEEE 1394 digital camera.

    6. How to Connect to an IEEE 1394 Camera

      This tutorial is an introduction to using a digital camera connected to an IEEE 1394 bus. It explains how to connect to a 1394 camera, configure it, and display the images.

    7. How to Set IEEE 1394 Camera Bayer Parameters

      This tutorial explains how to set color decoding parameters for IEEE 1394 cameras with Bayer encoding.

    8. How to Set IEEE 1394 Camera Parameters Dynamically

      This tutorial explains how to use dynamic reconfigure to change IEEE 1394 camera driver parameters.

    9. How to Use Multiple IEEE 1394 Cameras

      This tutorial explains how to handle multiple IEEE 1394 camera streams with ROS.

    10. Using camera_info_manager in a Camera Driver (C++)

      This tutorial shows how to provide calibration information while publishing images.

    11. Configuring the Prosilica GigE for a Desktop

      This tutorial covers configuring the Prosilica camera for a desktop and viewing images.

    12. 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.

    13. Configuring the Prosilica GigE for the PR2

      This tutorial covers configuring the Prosilica camera for a PR2 and viewing images.

    14. Introduction to working with the Prosilica camera.

      This introduction will teach you how to work with a pre-configured Prosilica camera.

    cart_pushing

    cart_pushing

    1. Cart Pushing Configuration

      This tutorial will provide descriptions of the main parameters in the cart pushing stack, and how to tune them to suit your needs

    2. Configuring a new cart

      This tutorial will describe how to add a new cart to the cart pushing stack, and configure the cart local planner

    3. Cart-robot calibration

      This will describe how to find calibration transforms for the yaml file for cart manipulation

    4. Implementing Custom cart local planners

      This tutorial guides you through the process of implementing your own local planner for cart pushing

    5. Running the cart pushing stack

      This tutorial will describe how to launch and interact with the cart pushing stack from RViz

    cob_apps

    The cob_apps stack provides example applications, mainly for testing the Care-O-bot hardware drivers.

    1. Generate a graph from a script

      This tutorial teaches you how to generate a graph from a script and save it as a *.png file.

    2. Live visualization of a script

      This tutorial teaches you how to visualize a running script.

    3. Modifying parameter files

      This tutorial teaches you how to modify parameter files, e.g. for teaching new positions.

    4. Preparing a new script (python)

      This tutorial shows how to write a simple script for grasping and handing over an object using cob_script_server.

    5. Running a simple grasp script

      This tutorial teaches you how to run a script.

    6. Specify execution behaviour (python)

      This tutorial shows how to execute synchronous and asynchronous behaviour.

    7. Using other commands (python)

      This tutorial teaches you how to use other commands beside the move command.

    8. Using the move command (python)

      This tutorial teaches you how to use the move function.

    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.

    1. Writing and Using a Simple Plugin

      This tutorial describes how to create and then load a simple plugin using pluginlib.

    2. 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.

    3. Running a nodelet

      This will show you how to run a nodelet already in the system.

    diagnostics

    Packages related to gathering, viewing, and analyzing diagnostics data from robots.

    1. 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.

    2. 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.

    3. Creating a Diagnostic Analyzer

      An example of how to write your own diagnostic analyzer plug-in for the diagnostic_aggregator.

    4. 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.

    5. 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.

    6. 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.

    driver_common

    The driver_common stack contains classes and tools that are useful throughout the driver stacks. It currently contains:

    • dynamic_reconfigure: A dynamic reconfiguration system to allow node parameters to be changed without restarting the node.
    • driver_base: A base class for sensors to provide a consistent state machine (retries, error handling, etc.) and interface.
    • timestamp_tools: Classes to help timestamp hardware events.

    1. Setting Up Dynamic Reconfigure for a Node

      Setting Up Dynamic Reconfigure for a Node

    executive_smach

    The executive_smach stack contains the SMACH library, together with tools for introspection and a ROS integration package.

    1. CBState

      This tutorial gives an example of how to use CBState, a state that simply executes a callback when it is active.

    2. Calling Actions from a State Machine (ROS)

      This tutorial teaches you how to call action servers from within a SMACH state machine.

    3. Concurrence container

      This tutorial teaches you how to use the Concurrence container.

    4. Concurrent States

      This tutorial shows an example of running two states in parallel.

    5. Create a Hierarchical State Machine

      This tutorial teaches you how to nest different state machines, creating a hierarchical state machine.

    6. Generic State

      This tutorial show how to implement a generic SMACH State

    7. Getting Started with smach

      This tutorial guides you through the very first steps of using smach.

    8. Iterator container

      This tutorial teaches you how to use the Iterator container.

    9. MonitorState (ROS)

      Monitor a state!

    10. Nesting State Machines

      This tutorial gives an example of nesting a state machine in another state machine, creating a hierarchical state machine.

    11. Sequence container

      This tutorial teaches you how to use the Sequence container.

    12. ServiceState (ROS)

      This tutorial shows how to represent the execution of a service as a SMACH state.

    13. Simple Action State (ROS)

      This tutorial shows an example of states that call directly into the actionlib interface.

    14. Simple State Machine

      This tutorial shows how to put together a simple state machine with two states.

    15. SimpleActionState (ROS)

      This tutorial show how to use the SimpleActionState to directly call an action interface using SMACH

    16. Viewing State Machines (ROS)

      This tutorial shows you how to use the smach viewer, a simple tool to monitor state machines and get introspection into the data flow between states.

    17. State Preemption Implementation

      This tutorial shows how to implement simple flag-based preemption in SMACH states.

    18. StateMachine container

      This tutorial teaches you how to use the StateMachine container.

    19. Passing User Data between States

      This tutorial teaches you how to pass data from one state(machine) to the next state(machine).

    20. User Data Passing

      This tutorial gives an example of two states passing user data to each other.

    21. Wrapping a Container With actionlib

      This tutorial explains how to serve out a SMACH plan as an action over actionlib.

    22. Writing Custom Container Classes

      Most tasks can be performed without writing new types of container classes, but this tutorial explains how to write a new one.

    23. Writing Custom State Classes with User-defined Callbacks

      Sometimes you want to create a state class like smach.SimpleActionState which receives user callbacks as arguments. If these callbacks change the SMACH interface of a state (outcomes, userdata keys), then the callbacks need to be annotated with this information.

    executive_trex

    trex

    1. 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.

    2. 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.

    3. Create and explore a simple Hello World project

      In this tutorial you will create a T-REX demo project and execute a test case.

    4. Obtain, compile and test T-REX.

      This tutorial will get you started using T-REX.

    5. Interactive execution and visualization

      In this tutorial you will learn the basics of incremental, interactive execution and visualization of trex.

    6. Using the test harness

      In this tutorial you will learn about the test harness structure put in place for testing the executive

    7. Visualize prior execution

      In this tutorial you will learn the basics of using the trexmonitor tool to visualize execution

    geometry

    The basic geometric and math libraries used in ros.

    1. Frame transformations (Python)

      This tutorials gets you started with KDL Frames, Vectors, Rotations, etc

    2. Adding a dynamic frame (C++)

      This tutorial teaches you how to add an extra dynamic frame to tf.

    3. Adding a dynamic frame (Python)

      This tutorial teaches you how to add an extra dynamic frame to tf.

    4. Adding a frame (C++)

      This tutorial teaches you how to add an extra fixed frame to tf.

    5. Adding a frame (Python)

      This tutorial teaches you how to add an extra fixed frame to tf.

    6. Debugging tf problems

      This tutorial gives a systematic approach for debugging tf related problems.

    7. 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.

    8. Time travel with tf (C++)

      This tutorial teaches you about advanced time travel features of tf

    9. Time travel with tf (Python)

      This tutorial teaches you about advanced time travel features of tf

    10. Using Stamped datatypes with tf::MessageFilter

      This tutorial describes how to use tf::MessageFIlter to process Stamped datatypes.

    11. Writing a tf broadcaster (C++)

      This tutorial teaches you how to broadcast coordinate frames of a robot to tf.

    12. Writing a tf broadcaster (Python)

      This tutorial teaches you how to broadcast the state of a robot to tf.

    13. Writing a tf listener (C++)

      This tutorial teaches you how to use tf to get access to frame transformations.

    14. Writing a tf listener (Python)

      This tutorial teaches you how to use tf to get access to frame transformations.

    15. 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.

    16. 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.

    gps_umd

    GPS messages and libraries

    1. Getting Started with gpsd_client (C++)

      Detailed tutorial for running gpsd_client in ROS

    2. Writing a Subscriber for gpsd_client (C++)

      This tutorial illustrates a sample code in C++ to get gps data using gpsd_client. We use class methods to bring the gps data to the main function.

    image_common

    Common code for working with images in ROS.

    1. Running the Simple Image Publisher and Subscriber with Different Transports

      This tutorial discusses running the simple image publisher and subscriber using multiple transports.

    2. 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!

    3. Writing a Simple Image Publisher (C++)

      This tutorial shows how to publish images using all available transports.

    4. 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.

    5. Writing a New Transport

      This tutorials covers how to write publisher and subscriber plugins for a new image transport option.

    image_pipeline

    image_pipeline fills the gap between getting raw images from a camera driver and higher-level vision processing.

    1. Choosing Good Stereo Parameters

      This tutorial walks you through a real-world example of tuning a running stereo_image_proc instance to get the best stereo results, using stereo_view and rviz for visual feedback.

    2. 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.

    3. 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.

    imu_drivers

    A stack for any drivers relating to Inertial Measurement Units (IMU).

    1. 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.

    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.

    1. 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.

    2. 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.

    3. 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.

    4. 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.

    5. 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.

    6. 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.

    7. 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.

    8. 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.

    9. 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.

    10. 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.

    11. 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.

    12. 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.

    13. Configuring a Multiple Joystick System

      This tutorial uses the joystick remapping node to allow two different joysticks to control a single robot.

    laser_drivers

    This stack contains drivers for laser rangefinders, including Hokuyo SCIP 2.0-compliant and SICK models.

    1. 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.

    2. 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.

    3. 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.

    4. 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.

    laser_pipeline

    Libraries from processing laser data, including converting laser data into 3D representations.

    1. 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.

    2. 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.

    3. 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.

    4. 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.

    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.

    1. Adding known objects to the motion planning environment

      This tutorial will introduce the topic of adding known objects to the collision environment. Known objects are shapes that have been recognized by a semantic perception pipeline or are known to exist at particular positions by a system designer.

    2. Attaching objects to the robot's body

      This tutorial describes methods by which known objects can be attached to a robot's body. Attaching an object to the body means that the object will move when the robot moves; this functionality allows motion planners and the trajectory monitor to deal with situations where the robot has grasped something and avoiding collisions between the grasped object and the environment becomes important.

    3. Making collision maps from self-filtered laser data

      This tutorial introduces the processing pipeline that takes scans from the tilting laser on the PR2, self-filters the robot from the data, and constructs a collision map that can then be used for checking potential collisions.

    4. Checking collisions for a given robot state

      This tutorial will show you how to use the environment server with laser collision map data to check whether a given robot state is collision free, within the joint limits and satisfies joint or cartesian constraints.

    5. 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.

    motion_planning_visualization

    motion_planning_visualization

    1. 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.

    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.

    1. 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.

    2. 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.

    3. 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.

    nxt

    This stack has basic interfaces for interacting with ROS and NXT. The software in this stack is intended to run on top of the default NXT firmware provided by lego.

    1. Creating a simple robot model using lxf2urdf.py

      This tutorial demonstrates how to convert a Lego Digital Designer file (*.lxf and *.ldr) to a ROS robot model file (*.urdf).

    2. Creating an full robot in NXT-ROS

      This tutorial shos you how to create an nxt_ros.yaml file for you nxt robot and launch it to view the data.

    3. Getting started with NXT-ROS

      This tutorial describes how to start using ROS on your NXT robot.

    object_manipulation

    Functionality for performing object pickup and placing, while avoiding collisions with the environment. This stack is designed to be robot independent. It contains a complete interface for pickup and place tasks, as well as general implementation of most of the needed functionality.

    1. Install the household_objects_database on your local database server

      Shows how to create the household_objects_database on your local database server, and how to populate it using a backup file from Willow Garage.

    2. Use the household_objects_database remotely from a Willow Garage server

      Shows how to use the household_object_database remotely, by using the services provided by a database wrapper node running on a Willow Garage server.

    object_recognition

    The object_recognition stack contains algorithms and tools relevant to object recognition from visual data.

    1. Learning templates online

      In this tutorial we learn how to write a program that learns and detects dominant orientation templates.

    2. Loading and detecting previously learned templates

      In this tutorial we learn how to write a program that loads and detects templates.

    3. Adding a new detector to the recognition_pipeline

      This tutorial shows how to add a new detector to the recognition pipeline

    p2os

    This stack provides the p2os driver supporting any robot that uses either P2OS or ARCOS firmware. This stack also includes urdf definitions for visualization and examples to control the robot.

    1. Getting Started with p2os

      A quick tutorial for installing and running p2os with ROS

    point_cloud_perception

    The point_cloud_perception stack contains algorithms and tools that deal with 3D point cloud data from a variety of different sensing devices.

    1. Concatenate the fields of two Point Clouds

      Concatenate the fields of two Point Clouds

    2. Concatenate the points of two Point Clouds

      Concatenate the points of two Point Clouds

    3. Construct a convex hull polygon for a planar model

      Construct a convex hull polygon for a planar model

    4. Cylinder model segmentation

      Cylinder model segmentation

    5. Downsampling a PointCloud using a VoxelGrid filter

      Downsampling a PointCloud using a VoxelGrid filter

    6. Extracting indices from a PointCloud

      Extracting indices from a PointCloud

    7. Filtering a PointCloud using a PassThrough filter

      Filtering a PointCloud using a PassThrough filter

    8. Planar model segmentation

      This tutorial walks you through writing planar model segmentation code.

    9. Projecting points using a parametric model

      Projecting points using a parametric model

    10. Reading Point Cloud data from PCD files

      How to read a Point Cloud from a PCD file

    11. Reading Point Cloud data from BAG files

      Reading Point Cloud data from BAG files

    12. Removing outliers using a StatisticalOutlierRemoval filter

      Removing outliers using a StatisticalOutlierRemoval filter

    13. Writing Point Cloud data to PCD files

      How to write a Point Cloud to a PCD file

    pr2_calibration

    Provides a toolchain running through the robot calibration process. This involves capturing pr2 calibration data, estimating pr2 parameters, and then updating the PR2 URDF. This stack is very unstable. Expect many API changes.

    1. Calibrating a new sensor on the PR2

      The pr2_calibration stack is configured to work out-of-the-box with the PR2's standard sensor suite. The stack, however, also provides hooks for adding new sensors. These hooks are not fully documented or supported, but it is in fact possible to add a new sensor to the full robot calibration.

    2. PR2 Full System Calibration

      Calibrating the PR2's cameras, and kinematic parameters

    3. Calibrating the PR2's Cameras

      Calibrate the PR2's Narrow Stereo, Wide Stereo, Forearm Cams & Prosilica

    4. Using PR2 Auto Calibration

      This tutorial will show you how to use auto calibration on the PR2

    pr2_controllers

    Contains the controllers that run in realtime on the PR2 and supporting packages.

    1. Getting the current joint angles for the PR2

      This tutorial shows you how to get the current joint angles for the PR2 robot.

    2. Moving the head

      This tutorial shows you how to set a desired pose of the robot head using the existing head trajectory controller.

    3. 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).

    4. 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.

    5. 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).

    6. Moving the torso

      This tutorial shows you how to move the PR2 torso using the single_joint_position_action.

    7. 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.

    8. 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).

    pr2_ethercat_drivers

    This stack contains drivers for the ethercat system and the peripherals that connect to it: motor control boards, fingertip sensors, texture projector, hand accelerometer.

    1. Setting up communication with a new EtherCAT device

      Second part of tutorial. Shows how to setup process communication with new device.

    2. Using the 3-axis accelerometer on the PR2 gripper

      Introduction to the 3-axis accelerometer on the PR2 gripper

    3. Writing a controller for the gripper accelerometer.

      Writing a real-time controller for the gripper accelerometer.

    4. Integrating a new type of EtherCAT device with ROS.

      First part of tutorial. Provides minimal code needed to get pr2_etherCAT to recognize a new type of device.

    pr2_kinematics

    This stack contains an implementation of kinematics for the PR2 robot.

    1. 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.

    2. 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.

    3. 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.

    4. 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.

    5. 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.

    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.

    1. Adding a PID to a realtime joint controller

      This tutorial teaches you how to add a PID object to a realtime joint controller

    2. 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.

    3. Coding a realtime Cartesian controller with Eigen

      This tutorial gives example code for a realtime Cartesian controller using KDL and Eigen

    4. Coding a realtime Cartesian controller with KDL

      This tutorial gives example code for a realtime Cartesian controller using KDL

    5. Communicating with a realtime joint controller

      This tutorial teaches you how to communicate with a controller over ROS.

    6. Implementing a realtime Cartesian controller

      This tutorial teaches you how to control a robot in Cartesian space

    7. Plotting controller data in matlab or octave

      This tutorial teaches you how to visualize the captured state of a controller in matlab or octave.

    8. 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.

    9. Running a realtime Cartesian controller

      This tutorial teaches you how to configure and run an existing Cartesian space controller

    10. Running a realtime joint controller

      This tutorial teaches you how to configure and run an existing joint space controller

    11. Simple URDF-Controller Example

      This tutorial shows you how to build a simple model with URDF, and how to link it with the controller. In addition, useful tips on building and verifying of the created robot model are given.

    12. Writing a realtime Cartesian controller

      This tutorial teaches you how to control a robot in Cartesian space

    13. 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

    pr2_object_manipulation

    Contains PR2-specific implementations of some of the generic functionality needed for pickup and place tasks.

    1. Force Control with the PR2 Gripper

      This tutorial teaches the user how to use the pr2_gripper_sensor_action package to do force control with the PR2 gripper.

    2. Grab and Release an Object Using pr2_gripper_sensor_action

      This tutorial will show you how to get the gripper to delicately grab an object, then after a certain amount of time automatically look for a contact event (hopefully the contact of the object and the surface you wanted to place it on), and release the object after contact.

    3. Object Manipulation using find_contact, slip_servo, event_detector, and gripper_action

      Advanced tutorial on how to use the low-level actions in the pr2_gripper_sensor_action package

    4. Using the PR2 gripper's reactive actions and services

      This tutorial teaches you to call the actions and services contained in pr2_gripper_reactive_approach: reactive grasp, reactive approach, reactive lift, reactive place, compliant close, and grasp adjustment.

    5. Using the PR2 gripper's grasp planner for point clusters

      This tutorial teaches you how to use the pr2_gripper_grasp_planner_cluster to find grasps of unknown objects (as 3D point clouds from the narrow stereo).

    pr2_robot

    This stack collects PR2-specific components that are used in bringing up a robot.

    1. Adding a Hokuyo to the PR2

      Demonstrates how to add a Hokuyo to the side of the PR2. This includes modifying the URDF, and editing the robot's default launch configuration.

    2. PR2 dashboard

      This tutorial teaches you how to run the PR2 dashboard

    3. PR2 diagnostics system

      This tutorial teaches you about the PR2 diagnostics system.

    4. PR2 logger

      This tutorial teaches you how to use the PR2 logging system

    5. Modifying the Diagnostic Analyzers on a PR2

      This tutorial shows you how to modify the diagnostic analyzers on a PR2. This is useful for modified robots.

    6. Power system

      This tutorial teaches you about the PR2 power system

    7. PR2 run stops

      This tutorial teaches you about the PR2 run stops

    8. PR2 safety system

      This tutorial teaches you about the PR2 safety system.

    9. Starting up the PR2

      This tutorial guides you step by step through starting the PR2 robot

    10. How to run pr2_etherCAT

      How to run pr2_etherCAT for non-typical setups.

    pr2_simulator

    PR2-specific simulation components. These include plugins and launch scripts necessary for running PR2 in simulation.

    1. 2D Navigation Stack in Simulation

      Testing the PR2 2D navigation stack in simulation given an example world with 2 desks as obstacles.

    2. Automated Regression Tests

      Running the Gazebo regression tests on your machine.

    3. PR2 Simulator Workshop

      This tutorial explores basic PR2 interfaces while using the PR2 in simulation.

    4. Building a Map in Simulation

      Given a simple office environment and PR2 in simulation, how to create a map using the OpenSLAM GMapping package.

    5. Faking Sensor Info in Simulation

      fake_localization node usage is introduced. It provides transform between base_link frame and the map frame.

    6. Multi-Level Map With Ramps

      An example environment with multiple floor levels and ramps.

    7. PR2 Opens a Door

      Simulated environment for testing autonomous door opening in simulation.

    8. PR2 Plugs Itself In

      Simulate environment for testing autonomous PR2 plugging in.

    9. Pendulum Examples

      Simple pendulums examples.

    10. Debugging Gazebo plugins

      You can run gazebo with gdb to debug real time controllers and plugins.

    11. Starting a Separate Sensor Generation Node

      Start up an image sensor generation node when the main simulation node is running headless.

    12. Simple PR2 Grasping Demo in Simulation

      Simple PR2 Grasping Demo in Simulation

    13. Starting PR2 in Simulation

      Starting PR2 in Simulation

    14. Teleop PR2 Mobile Base In Simulation

      Controlling PR2 base with keyboard and driving PR2 around in simulation.

    15. Using Custom Maps in Simulation

      How to use a custom map for 2D navigation in Gazebo simulator.

    16. Stereo Processing in Simulation

      Starting the necessary components for generating stereo cloud in simulation with PR2.

    17. Working with Gazebo over ROS

      For the most part, working with Gazebo is the same as working with a robot.

    18. Attaching a ROS Ground Truth Pose Broadcaster to Objects in Simulation

      Attaching a ROS ground truth pose broadcaster to objects in simulation

    pr2_tabletop_manipulation_apps

    Brings together manipulation and perception for complete task execution using the PR2 robot.

    1. Starting the Manipulation Pipeline on the PR2 robot

      Covers bringing up the manipulation pipeline on the PR2 robot, to the point where it is ready to service pick and place requests.

    2. Writing a Simple Pick and Place Application

      Shows how to write a simple application where the PR2 will pick up an object from a table that's in front of it, move it to the side and then place it back down.

    3. A Simple Pick And Place Example Using The Pick And Place Manager

      This tutorial teaches you how to use the pick and place manager to pick up the object nearest to a specified point on a table, and then place it in a specified region. (Python)

    4. The Pick and Place Keyboard Interface

      A simple keyboard interface allowing the user to request the execution of pick and place tasks for the PR2. Written in C++.

    5. The Pick And Place Autonomous Demo

      A demo where the robot will autonomously move objects from one part of a table to the other and back, ad infinitum. Also has a keyboard interface for doing each step separately. Written in Python.

    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.

    1. 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.

    2. Adding a Sensor to the PR2 URDF

      This tutorial describes how to add a camera sensor to the PR2 URDF.

    3. Create your own urdf file

      In this tutorial you start creating your own urdf robot description file.

    4. Parse a urdf file

      This tutorial teaches you how to use the urdf parser

    5. 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.

    6. Understanding the PR2 URDF description, Part 2

      Describes one of the low-level components of the PR2 definition in full detail.

    7. Understanding the PR2 Robot Description Extensions for Gazebo Simulator

      This tutorial explains URDF extensions used by Gazebo simulation.

    8. Using urdf with robot_state_publisher

      This tutorial gives a full example of a robot model with URDF that uses robot_state_publisher. First, we create the URDF model with all the necessary parts. Then we write a node which publishes the JointState and transforms. Finally, we run all the parts together.

    9. Start using the KDL parser

      This tutorial teached you how to create a KDL Tree from a URDF file

    10. Retrieving Files

      Demonstrates how to retrieve a file from a URL using the resource_retriever package

    11. Exporting URDF to COLLADA

      This tutorial teaches you how to export an URDF file to a COLLADA document

    robotino_drivers

    ROS packages for the mobile robot Robotino

    1. Using multiple cameras

      Describes how to set up udev rules and launch files to use several robotino_cams

    ros_experimental

    Experimental packages for ROS core system development.

    1. Enabling ROS Epic Fail for a Hudson Build

      Enable ROS Epic Fail for a Hudson build, so that tests can use ROS Epic Fail

    2. Enabling ROS Epic Fail for a Package

      Enable ROS epic fail for a package

    3. Enabling ROS Epic Fail for a Test

      Use ros_epic_fail to catch bag files from a randomly failing test.

    ros_pkg_tutorials

    ros_pkg_tutorials is a stack for teaching different aspects of ros-pkg.

    1. 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.

    2. 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.

    3. 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.

    4. 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.

    5. 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.

    6. Writing a Simple Action Client (Python)

      This tutorial covers using the action_client library to create a Fibonacci simple action client in Python.

    7. 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.

    ros_tutorials

    ros_tutorials contains packages that demonstrate various features of ROS, as well as support packages which help demonstrate those features.

    1. 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.

    2. 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.

    3. 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.

    4. 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.

    5. 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).

    6. 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.

    7. Writing a Simple Service and Client

      This tutorial covers how to write a service and client node in python.

    8. 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.

    9. Accessing Private Names from a NodeHandle

      This tutorial will show you how to access private Names with roscpp's NodeHandle API.

    10. Using Parameters in roscpp

      This tutorial will show you the NodeHandle parameter API, allowing you to manipulate parameters from the Parameter Server.

    11. Understanding Timers

      This tutorial explains roscpp Timers, which allow you to schedule a callback to happen periodically.

    12. 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.

    13. Writing a Simple Publisher and Subscriber

      This tutorial covers how to write a publisher and subscriber node in c++.

    14. Writing a Simple Service and Client

      This tutorial covers how to write a service and client node in C++.

    simulator_gazebo

    Wrappers, tools and additional API's for using ROS with the Gazebo simulator.

    1. Simulate a Spinning Top

      Simulate a Spinning Top

    2. Gazebo ROS API for C-Turtle

      Gazebo ROS API for C-Turtle. Manipulate and interact with simulation and simulated objects.

    3. List of Materials

      This page simply lists the available materials in Gazebo.

    4. Running Simulator Headless

      Running simulation without a graphics card or GLX support.

    5. Creating and Spawning Custom URDF Objects in Simulation

      Creating and Spawning Custom URDF objects in simulation

    6. Installing and Starting Gazebo

      How to get Gazebo up and running.

    7. Erratic Simulation

      Simulating differential drive Erratic robot in 3D simulator and drive it around using ROS.

    8. 3D Willow Garage Map

      Example 3D world generated from the Willow Garage map.

    simulator_stage

    2D simulation using the Stage multi-robot simulator.

    1. 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.

    slam_gmapping

    slam_gmapping contains the gmapping package, which provides SLAM capabilities. GMapping is a Creative-Commons-licensed open source package provided by OpenSlam.

    1. 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.

    slam_karto

    SLAM using KARTO from SRI International

    1. How to activate loop closure optimization (tutorial2.cpp)

      This tutorial describe how to set the internal solver inside Karto to activate the loop closure mechanism. It's based on the file tutorial2.cpp

    2. How to use Karto stand-alone (tutorial1.cpp)

      This tutorial presents how to create a localized range scan

    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).

    1. 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.

    sql_database

    Provides an easy way to use SQL databases from the ROS environment.

    1. Installation of a PostgreSQL server

      A step-by-step "cheat-sheet" for installing a PostgreSQL server on a Ubuntu machine. Does not cover any advanced installation procedures, just a very simple installation with no additional options. After installing the server, you can set up multiple databases, restore them from backup files, etc.

    2. Introduction to using the SQL database interface

      This is a step-by-step introduction to using the SQL database interface. We will create a new class for holding our data, retrieve data from a database and write back modified fields.

    3. The SQL database interface: advanced concepts

      This tutorial shows some of the advanced concepts of using the SQL database interface, such as objects spanning multiple tables, sequences, and binary data fields.

    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.

    1. 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.

    2. 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.

    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.

    1. How to control a Crust Crawler Smart Arm with Dual Gripper using the smart_arm_controller

      This tutorial describes how to control your Crust Crawler Smart Arm using the smart_arm node.

    2. 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 running in the ax12_controller_core node.

    3. How to use controllers to control motor joints for the Wubble's head, laser and (smart) arm.

      How to use controllers to control motor joints for the Wubble's head, laser and (smart) arm.

    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.

    1. Testing a Phidget Accelerometer

      This tutorial shows you how to connect a Phidget accelerometer and view axes data changes published to a ROS topic.

    2. 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.

    vision

    These are vision-related packages.

    1. Running VSLAM on Stereo Data

      A tutorial that explains how to use the stereo_vslam_node to get point and odometry information from stereo images.

    vision_opencv

    opencv c++ and python libraries.

    1. Projecting a TF frame onto an image (C++)

      This tutorial shows how to use image_geometry together with tf to project a tf frame onto a live image stream.

    2. 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.

    visualization

    Visualization tools for robots. Currently just rviz, a 3d visualization environment for robots using ROS, as well as rxbag_plugins, which extend the visualization capabilities of rxbag.

    1. Markers: Points and Lines (C++)

      Teaches how to use the visualization_msgs/Marker message to send points and lines to rviz.

    vslam

    Visual SLAM with sparse bundle adjustment

    1. Introduction to Sparse Bundle Adjustment

      This tutorial introduces Sparse Bundle Adjustment (SBA), its uses, and some basic concepts.

    2. Performing SBA on Data from File

      This tutorial shows how to perform SBA on data from a file.

    3. Setting up an SBA System

      How to create an SBA system from an external source of data, perform SBA, and then visualize the results.

    web_interface

    This stack contains the packages and utilities required to run the web user interface.

    1. Web App Basics

      The basics of making/using Web Apps

    wg_robots_gazebo

    wg_robots_gazebo

    1. Simulating the 2dnav Stack

      This tutorial describes how to simulate a 2d-navigation stack in gazebo.

    world_db_model

    world_db_model is a framework for creating and maintaining a consistent and persistent state of the world. The idea is to record raw sensor data in bags and provide the results an interface to spatially query detector results. The results of detector plug-ins are calculated on demand and cached in an sqlite3 database. world_db_model provides a core node that contains the basic functionality to load plug-ins, record data into bags and play them back and store detection results. Further, it provides a plug-in for recording the tf-tree which is essential for spatial indexing in the bags, and a library for the easy creation of detector plug-ins.

    1. Integrating a detector

      This tutorial describes how to integrate a custom detector into world_db_model.

    Tutorials with no stack

    1. 2d Navigation on an Erratic

      This tutorial describes how to run a 2d-navigation stack on erratic robots with different laser configurations.

    2. 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.

    3. Create your own task

      This tutorial explains how to create a task for the robot to execute

    4. Schedule your own task on the robot

    5. Towers of Hanoi Usage

      This tutorial covers how to run the Towers of Hanoi puzzle

    6. ICRA manipulation demo sync point hierarchy

      A list of the sync points used to pause the demo when using the demo joystick controller.

    7. Install the model database server and data on a new robot or machine

      Describes how to install and start the PostgreSQL server on a robot. Does not show how to load the actual database onto this server.

    8. One-line key points to mention during the manipulation demo

      A simpler form of the main demo page which describes all the functionality in detail. Think of it as a "cheat-sheet" for remembering the main points that the audience might be interested in.

    9. Running the ICRA manipulation demo

      This tutorial explains how to run the ICRA manipulation demo.

    10. Set up the source code tree for the ICRA manipulation demo

      Easy-to-follow instructions for downloading and building all the code you need for the manipulation demo on a robot.

    11. ROS パッケージのビルド

      このチュートリアルではパッケージをビルドする rosmake とシステムに依存関係をインストールする rosdep についてカバーします.

    12. ROS メッセージとサービスの作成

      このチュートリアルでは ROS メッセージ(msg)とサービス(srv) ファイルの作成方法と,rosmsgやrossrv・roscp・rosmake といったコマンドライン-ツールの使用法についてカバーします.

    13. ROS パッケージの作成

      このチュートリアルでは,新しいパッケージを作成する roscreate-pkg とパッケージの依存関係をリスト化する rospack コマンドについてカバーします.

    14. シンプルな配信者と購読者の検査

      このチュートリアルでは,起動しているシンプルな配信者と購読者について検査します.

    15. シンプルなサービスとクライアントの検査

      このチュートリアルでは,起動中のシンプルなサービスとクライアントについて検査する

    16. ROS wiki の使い方

      このチュートリアルでは,ROS wiki (ros.org)のレイアウトについて説明し,あなたが知りたいことの見つけかたについてお話します.

    17. ROS ノードについて理解する

      このチュートリアルでは ROS グラフの概念について議論します.また,roscorerosnode・rosrun といったコマンドライン-ツールの使用法についてもカバーします.

    18. ROS サービスとパラメータについて理解する

      このチュートリアルでは,ROS サービスとパラメータ, rosservicerxparam コマンドライン-ツールについて紹介します.

    19. ROS トピックについて理解する

      このチュートリアルでは,ROS トピックについて, rostopicrxplot コマンドライン-ツールを使いながら紹介します.

    20. ROS のファイルを編集する rosed の使い方

      このチュートリアルでは,編集を楽にする rosed の使い方を紹介します.

    21. rxconsole と roslaunch を使う

      このチュートリアルでは,デバッグに rxconsole と rxloggerlevel を使います.また,たくさんのノードを一度に起動するために, roslaunch を使います.

    22. シンプルな配信者と購読者を書く (C++)

      このチュートリアルでは,c++ による配信者と購読者の書き方を説明します.

    23. ノードハンドルからプライベートネームで接続する

      このチュートリアルでは,roscpp のノードハンドルAPIを用いて,プライベートネームに接続する方法について説明します.

    24. シンプルな配信者と購読者を書く

      このチュートリアルでは,C++ によるサービスやクライアントの作り方について説明します.

    25. シンプルなサービスとクライアントを書く

      このチュートリアルでは,C++ によるサービスやクライアントの作り方について説明します.

    26. 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.

    27. Annotating images through command line tools

      The tutorial demonstrates cv_mech_turk2 command line tools - the easiest way to annotate images in bulk.

    28. 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.

    29. Creating new image annotation tasks

    30. 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.

    31. Moving the PR2 arm using command line

      This tutorial is a brief introduction on how to start up motion planning for the arm.

    32. Navigation stack and stage

      Simple tutorial that sets up navigation stack and rosstage. Can be used by any new beginner just to see how awesome and simple ROS is. This tutorial is helpful to those who doesn't have any real robots but want to work in ros and simulate real environments. This tutorial assumes that u have installed both base and pr2 specific stacks.

    33. Assisted Teleop Video Demo

      This is the demo shown in the announcement video.

    34. How to collect data

      How to collect data

    35. All of the deprecated tutorials in one place.

      All of the text from the deprecated tutorials.

    36. Processing Results with the Stair Vision Library

      Processing results using the Stair Vision Library

    37. Running PR2 Counterbalance Check

      Shows how to run the counterbalance adjustment test on the PR2.

    38. Plot mtrace data from Shadow Hand device

      Plot mtrace data from Shadow Hand device

Wiki: AllTutorials (last edited 2009-12-04 23:12:49 by MeloneeWise)