This is a search for all Tutorials on ROS.org:
All Tutorials
- Setting up an XCode Project
This tutorial show how to create a basic native OSX application for ROS.
- 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
- Stack Installation
This tutorial describes how to install 3rd party stacks
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.).
- 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.
- How to Calibrate an IEEE 1394 Camera
This tutorial explains how to calibrate an IEEE 1394 camera.
- How to Configure IEEE 1394 Camera Features
This tutorial explains how to set IIDC feature parameters for an IEEE 1394 digital camera.
- 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.
- How to Set IEEE 1394 Camera Bayer Parameters
This tutorial explains how to set color decoding parameters for IEEE 1394 cameras with Bayer encoding.
- How to Set IEEE 1394 Camera Parameters Dynamically
This tutorial explains how to use dynamic reconfigure to change IEEE 1394 camera driver parameters.
- How to Use Multiple IEEE 1394 Cameras
This tutorial explains how to handle multiple IEEE 1394 camera streams with ROS.
- Using camera_info_manager in a Camera Driver (C++)
This tutorial shows how to provide calibration information while publishing images.
- 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.
- 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
- 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
- Cart-robot calibration
This will describe how to find calibration transforms for the yaml file for cart manipulation
- Implementing Custom cart local planners
This tutorial guides you through the process of implementing your own local planner for cart pushing
- Running the cart pushing stack
This tutorial will describe how to launch and interact with the cart pushing stack from RViz
- 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.
- Live visualization of a script
This tutorial teaches you how to visualize a running script.
- Modifying parameter files
This tutorial teaches you how to modify parameter files, e.g. for teaching new positions.
- 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.
- Running a simple grasp script
This tutorial teaches you how to run a script.
- Specify execution behaviour (python)
This tutorial shows how to execute synchronous and asynchronous behaviour.
- Using other commands (python)
This tutorial teaches you how to use other commands beside the move command.
- Using the move command (python)
This tutorial teaches you how to use the move function.
- Writing and Using a Simple Plugin
This tutorial describes how to create and then load a simple plugin using pluginlib.
- 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.
- Running a nodelet
This will show you how to run a nodelet already in the system.
- 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.
- 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.
- Setting Up Dynamic Reconfigure for a Node
Setting Up Dynamic Reconfigure for a Node
- CBState
This tutorial gives an example of how to use CBState, a state that simply executes a callback when it is active.
- Calling Actions from a State Machine (ROS)
This tutorial teaches you how to call action servers from within a SMACH state machine.
- Concurrence container
This tutorial teaches you how to use the Concurrence container.
- Concurrent States
This tutorial shows an example of running two states in parallel.
- Create a Hierarchical State Machine
This tutorial teaches you how to nest different state machines, creating a hierarchical state machine.
- Generic State
This tutorial show how to implement a generic SMACH State
- Getting Started with smach
This tutorial guides you through the very first steps of using smach.
- Iterator container
This tutorial teaches you how to use the Iterator container.
- MonitorState (ROS)
Monitor a state!
- Nesting State Machines
This tutorial gives an example of nesting a state machine in another state machine, creating a hierarchical state machine.
- Sequence container
This tutorial teaches you how to use the Sequence container.
- ServiceState (ROS)
This tutorial shows how to represent the execution of a service as a SMACH state.
- Simple Action State (ROS)
This tutorial shows an example of states that call directly into the actionlib interface.
- Simple State Machine
This tutorial shows how to put together a simple state machine with two states.
- SimpleActionState (ROS)
This tutorial show how to use the SimpleActionState to directly call an action interface using SMACH
- 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.
- State Preemption Implementation
This tutorial shows how to implement simple flag-based preemption in SMACH states.
- StateMachine container
This tutorial teaches you how to use the StateMachine container.
- Passing User Data between States
This tutorial teaches you how to pass data from one state(machine) to the next state(machine).
- User Data Passing
This tutorial gives an example of two states passing user data to each other.
- Wrapping a Container With actionlib
This tutorial explains how to serve out a SMACH plan as an action over actionlib.
- 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.
- 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.
- 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
- Frame transformations (Python)
This tutorials gets you started with KDL Frames, Vectors, Rotations, etc
- 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.
- 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
- Using Stamped datatypes with tf::MessageFilter
This tutorial describes how to use tf::MessageFIlter to process Stamped datatypes.
- 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.
- Getting Started with gpsd_client (C++)
Detailed tutorial for running gpsd_client in ROS
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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).
- 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.
- Getting started with NXT-ROS
This tutorial describes how to start using ROS on your NXT robot.
- 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.
- 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.
- Learning templates online
In this tutorial we learn how to write a program that learns and detects dominant orientation templates.
- Loading and detecting previously learned templates
In this tutorial we learn how to write a program that loads and detects templates.
- Adding a new detector to the recognition_pipeline
This tutorial shows how to add a new detector to the recognition pipeline
- Getting Started with p2os
A quick tutorial for installing and running p2os with ROS
- Concatenate the fields of two Point Clouds
Concatenate the fields of two Point Clouds
- Concatenate the points of two Point Clouds
Concatenate the points of two Point Clouds
- Construct a convex hull polygon for a planar model
Construct a convex hull polygon for a planar model
- Cylinder model segmentation
Cylinder model segmentation
- Downsampling a PointCloud using a VoxelGrid filter
Downsampling a PointCloud using a VoxelGrid filter
- Extracting indices from a PointCloud
Extracting indices from a PointCloud
- Filtering a PointCloud using a PassThrough filter
Filtering a PointCloud using a PassThrough filter
- Planar model segmentation
This tutorial walks you through writing planar model segmentation code.
- Projecting points using a parametric model
Projecting points using a parametric model
- Reading Point Cloud data from PCD files
How to read a Point Cloud from a PCD file
- Reading Point Cloud data from BAG files
Reading Point Cloud data from BAG files
- Removing outliers using a StatisticalOutlierRemoval filter
Removing outliers using a StatisticalOutlierRemoval filter
- Writing Point Cloud data to PCD files
How to write a Point Cloud to a PCD file
- 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.
- PR2 Full System Calibration
Calibrating the PR2's cameras, and kinematic parameters
- Calibrating the PR2's Cameras
Calibrate the PR2's Narrow Stereo, Wide Stereo, Forearm Cams & Prosilica
- Using PR2 Auto Calibration
This tutorial will show you how to use auto calibration on the PR2
- 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).
- Setting up communication with a new EtherCAT device
Second part of tutorial. Shows how to setup process communication with new device.
- Using the 3-axis accelerometer on the PR2 gripper
Introduction to the 3-axis accelerometer on the PR2 gripper
- Writing a controller for the gripper accelerometer.
Writing a real-time controller for the gripper accelerometer.
- 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.
- 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
- 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.
- 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
- 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.
- 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.
- 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
- 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.
- 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).
- 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.
- PR2 dashboard
This tutorial teaches you how to run the PR2 dashboard
- PR2 diagnostics system
This tutorial teaches you about the PR2 diagnostics system.
- PR2 logger
This tutorial teaches you how to use the PR2 logging system
- 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.
- Power system
This tutorial teaches you about the PR2 power system
- PR2 run stops
This tutorial teaches you about the PR2 run stops
- PR2 safety system
This tutorial teaches you about the PR2 safety system.
- Starting up the PR2
This tutorial guides you step by step through starting the PR2 robot
- How to run pr2_etherCAT
How to run pr2_etherCAT for non-typical setups.
- 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.
- PR2 Simulator Workshop
This tutorial explores basic PR2 interfaces while using the PR2 in simulation.
- 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
fake_localization node usage is introduced. It provides transform between base_link frame and the map frame.
- 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.
- PR2 Plugs Itself In
Simulate environment for testing autonomous PR2 plugging in.
- 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.
- Simple PR2 Grasping Demo in Simulation
Simple PR2 Grasping Demo in Simulation
- 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
- 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.
- 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.
- 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)
- 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++.
- 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.
- 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.
- 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.
- 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
- Exporting URDF to COLLADA
This tutorial teaches you how to export an URDF file to a COLLADA document
- Using multiple cameras
Describes how to set up udev rules and launch files to use several robotino_cams
- Enabling ROS Epic Fail for a Hudson Build
Enable ROS Epic Fail for a Hudson build, so that tests can use ROS Epic Fail
- Enabling ROS Epic Fail for a Package
Enable ROS epic fail for a package
- Enabling ROS Epic Fail for a Test
Use ros_epic_fail to catch bag files from a randomly failing test.
- 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++.
- Simulate a Spinning Top
Simulate a Spinning Top
- Gazebo ROS API for C-Turtle
Gazebo ROS API for C-Turtle. Manipulate and interact with simulation and simulated objects.
- List of Materials
This page simply lists the available materials in Gazebo.
- Running Simulator Headless
Running simulation without a graphics card or GLX support.
- Creating and Spawning Custom URDF Objects in Simulation
Creating and Spawning Custom 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 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
- How to use Karto stand-alone (tutorial1.cpp)
This tutorial presents how to create a localized range scan
- 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.
- 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.
- 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.
- 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.
- 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_controller
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 running in the ax12_controller_core node.
- 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.
- 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.
- 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.
- 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.
- 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.
- Markers: Points and Lines (C++)
Teaches how to use the visualization_msgs/Marker message to send points and lines to rviz.
- Introduction to Sparse Bundle Adjustment
This tutorial introduces Sparse Bundle Adjustment (SBA), its uses, and some basic concepts.
- Performing SBA on Data from File
This tutorial shows how to perform SBA on data from a file.
- 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 App Basics
The basics of making/using Web Apps
- Simulating the 2dnav Stack
This tutorial describes how to simulate a 2d-navigation stack in gazebo.
- Integrating a detector
This tutorial describes how to integrate a custom detector into world_db_model.
- 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.
- Create your own task
This tutorial explains how to create a task for the robot to execute
- Schedule your own task on the robot
- Towers of Hanoi Usage
This tutorial covers how to run the Towers of Hanoi puzzle
- ICRA manipulation demo sync point hierarchy
A list of the sync points used to pause the demo when using the demo joystick controller.
- 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.
- 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.
- Running the ICRA manipulation demo
This tutorial explains how to run the ICRA manipulation demo.
- 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.
- 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.
- 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.
- Assisted Teleop Video Demo
This is the demo shown in the announcement video.
- 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
- Running PR2 Counterbalance Check
Shows how to run the counterbalance adjustment test on the PR2.
- Plot mtrace data from Shadow Hand device
Plot mtrace data from Shadow Hand device
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.
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.
camera_drivers
This stack contains drivers for a variety of cameras, and some associated tools.
cart_pushing
cart_pushing
cob_apps
The cob_apps stack provides example applications, mainly for testing the Care-O-bot hardware drivers.
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.
driver_common
The driver_common stack contains classes and tools that are useful throughout the driver stacks. It currently contains:
executive_smach
The executive_smach stack contains the SMACH library, together with tools for introspection and a ROS integration package.
executive_trex
trex
geometry
The basic geometric and math libraries used in ros.
gps_umd
GPS messages and libraries
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.
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.
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.
object_recognition
The object_recognition stack contains algorithms and tools relevant to object recognition from visual data.
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.
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.
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.
pr2_controllers
Contains the controllers that run in realtime on the PR2 and supporting packages.
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.
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_object_manipulation
Contains PR2-specific implementations of some of the generic functionality needed for pickup and place tasks.
pr2_robot
This stack collects PR2-specific components that are used in bringing up a robot.
pr2_simulator
PR2-specific simulation components. These include plugins and launch scripts necessary for running PR2 in simulation.
pr2_tabletop_manipulation_apps
Brings together manipulation and perception for complete task execution using the PR2 robot.
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.
robotino_drivers
ROS packages for the mobile robot Robotino
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, tools and additional API's 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.
slam_karto
SLAM using KARTO from SRI International
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).
sql_database
Provides an easy way to use SQL databases from the ROS environment.
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
These are vision-related packages.
vision_opencv
opencv c++ and python libraries.
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.
vslam
Visual SLAM with sparse bundle adjustment
web_interface
This stack contains the packages and utilities required to run the web user interface.
wg_robots_gazebo
wg_robots_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.
Tutorials with no stack