This is a search for all Tutorials on ROS.org:
All Tutorials
- Shared Control for a Quadrotor Platform
This tutorial guides a shared autonomy control scheme for a quadcopter that is suited for inspection of vertical infrastructure. An unskilled operator is assisted by onboard sensing and partial autonomy to safely fly the robot in close proximity to the structure. The operator uses their domain knowledge and problem solving skills to guide the robot in difficult to reach locations to inspect and assess the condition of the infrastructure. The operator commands the robot in a local task coordinate frame with limited degrees of freedom (DOF). For instance: up/down, left/right, toward/away with respect to the infrastructure. We therefore avoid problems of global mapping and navigation while providing an intuitive interface to the operator.
- Setting up an XCode Project
This tutorial show how to create a basic native OSX application for ROS.
- No Title
No Description
- Building a ROS Package
This tutorial covers using rosmake to build a package, and rosdep to install system dependencies.
- Creating a ROS package by hand.
This tutorial explains how to manually create a ROS package.
- Creating a Simple Hardware Driver
This tutorial shows how to create a simple hardware driver that connects via serial to a Parallax RFID Card Reader.
- 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.
- Defining Custom Messages
This tutorial will show you how to define your own custom message data types using the ROS Message Description Language.
- 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.
- Installing and Configuring Your ROS Environment
This tutorials walks you through installing ROS and setting up your ROS environment on your computer.
- Setting up a Mobile Robot with ROS
How to set up your custom mobile robot in ROS
- 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
- 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.
- 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.
- 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.
- Python tutorial to interact with open_loop_object_manipulation_actionserver
This tutorial will show you how to interact with the drive_to_action_server in Python
- Python tutorial to interact with open_loop_object_manipulation_actionserver
This tutorial will show you how to interact with the open_loop_object_manipulation_actionserver in Python
- Connecting to a ROS Master
This tutorial will show you the steps involved in introducing an Android device to your ROS Master.
- Installing the ArbotiX Firmware
This tutorial shows how to install the ROS firmware on the ArbotiX.
- Adding a button
This tutorial shows how to add a push button
- Setting Servo IDs
This tutorial shows how to set servo IDs using the terminal program.
- Adding Virtual Objects to the Planning Scene
In this tutorial we show how to add virtual objects to the Planning Scene and to check state validity against the virtual objects.
- Attaching Virtual Objects to the Robot
In this tutorial we describe attaching virtual objects to the robot's body - these are objects that are assumed to move with the robot instead of being static in the environment.
- Checking a state for validity
In this tutorial we show how you can use the planning scene architecture with the environment monitor, as well as code in the planning_environment stack to check state validity - whether or not a given state is within the joint limits, or in collision with the robot's other links or the environment. You'll also see how to publish markers based on this information.
- Checking Trajectory Validity
This tutorial will describe using the Planning Scene Architecture to check whether or not an entire Joint Trajectory is valid: focusing on whether it obeys joint limits and avoids collision.
- Understanding the arm navigation Planning Scene Architecture
This tutorial will go into the new formulation of arm navigation 1.0, focusing particularly on the Planning Scene. It will describe what it is, the design philosophy behind it, and how to use it in different contexts.
- Running arm navigation on non-PR2 arm
This tutorial describes the steps necessary to make arm_navigation stack running on an arm other than PR2
- Running the object pickup pipeline
- Planning Components Visualizer
This tutorial explains the planning components visualizer in the move_arm package, and how it may be used to interact with a robot.
- Planning Description Configuration Wizard
This tutorial explains the use of the planning description configuration wizard, which automatically generates a stack containing configuration and launch files used in arm planning.
- Understanding and adjusting the auto-generated arm navigation application
This tutorial will walk you through the launch files generated by the planning description visualization wizard and describe aspects you may wish to change for your robot.
- Warehouse Viewer
Learn to use the planning scene warehouse viewer, a GUI application for editing, loading, and saving planning scenes and trajectories.
- 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.
- Calling the kinematics services
Calling the kinematics services
- Configuring kinematics for your arm
Configuring kinematics for your arm and launching the kinematics node.
- Setting up the prerequisites
Setting up the prerequisites
- Before you begin planning: Setting up the Prerequisites
Before you begin planning: Setting up the Pre-requisites
- Calling the joint space planner
Calling the joint space planner
- Configuring a joint space planner
Configuring a joint space planner
- Configuring a kinematics plugin
Configuring a kinematics plugin
- Launching a joint space planner
Launching a joint space planner
- Specifying a start state
Specifying a start state
- Specifying pose goals
Specifying pose goals
- 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.
- ''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.
- Learning Kinematic Models for Articulated Objects using a Webcam
This tutorial is a step-by-step guide that instructs users how to learn kinematic models of articulated objects only by using a webcam and a laptop.
- Running the articulation perception demo using a Microsoft Kinect sensor
This tutorial explains how to install and run the articulation perception demo.
- Learning Kinematic Models for Articulated Objects using a Webcam
This tutorial is a step-by-step guide that instructs users how to learn kinematic models of articulated objects only by using a webcam and a laptop.
- 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.
- Learning Kinematic Models from End-Effector Trajectories
This tutorial demonstrates the process of model fitting and model selection to real data recorded by a mobile manipulation robot operating various doors and drawers.
- 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.).
- Running the AscTec driver
This tutorial goes over how to run the driver for the AscTec quadrotors, which enables communication with the vehicle over ROS.
- Onboard datafusion and position control on Ascending Technologies quadrotors
This tutorial shows how to use the datafusion and position controller provided in the asctec_hl_firmware package running on the high level processor of Ascending Technologies quadrotors.
- How to capture, stream, and play audio using audio_capture and audio_play.
This tutorial covers the audio_capture and audio_play packages. The audio_capture package records audio from a microphone and publishes audio messages on the /audio topic. The audio_play package listens to /audio and outputs the audio messages to speakers.
- 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.
- Basic Setup of Skin Hardware and Software
This tutorial guides the user through the setup of the skin hardware as well as the initial installation and configuration of the skin software.
- Using Javascript to control ROS via rosjs
This tutorial will show you how to write HTML web-pages that interact with ROS.
- Ten-Minute Guide to rosbridge
In ten minutes, this screencast walks through installing rosbridge and the basic operations (publishing and making service calls) used to access the full power of ROS over its simple JSON-based protocol. Captions are available.
- Using Javascript to control ROS via rosjs
This tutorial will show you how to write HTML web-pages that interact with ROS.
- 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.
- Add Kinect camera frame to the PR2 urdf tree
This tutorial teaches you how to use the camera_pose_urdf_updater package to add the Kinect camera frame as a child into an existed (also already calibrated) PR2 urdf tree.
- Calibrate camera pose to the map frame
Suppose you have a camera mounted somewhere in the room, this tutorial teaches you how to find out the camera pose relative to the map frame.
- Simplify the calibration process for multiple cameras
The camera_pose_toolkits package provides a convenient tool called camera_dispatcher that allows the user to dynamically switch between different cameras. This tutorial shows you how to use it to help manage multiple-camera calibration.
- Configuring a new cart
This tutorial will describe how to add a new cart to the cart pushing stack.
- Running the cart pushing stack on a PR2
This tutorial will describe how to launch and send goals to the cart pushing stack on a PR2
- Running the cart pushing stack in Stage
How to run cart pushing in the stage simulator
- Building and Running the actionlib_java Tutorial
- Installing rosjava
installing rosjava on your computer
- Publication and Subscription
Hello World: Writing a publisher and subscriber
- Building and Running the Tutorial Included in rosjava_core
- 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.
- Care-O-bot Environment
This tutorial show you how to run the simulation of the Care-O-bot on your pc.
- Homework 1
task: you have to generate a video to proof you can run the Care-O-bot simulation
- Homework 2
task: modify the script file to order the Care-O-bot grasping the "jodsalz" object
- Installing Software
This tutorial show you how to install the software on your pc.
- Run Scenario Script
You learn how to launch the Care-O-bot in Simulation an let them do some tasks.
- Day 1
First step with the real Care-O-bot and test your homework on the robot
- Day 2
robot technology day, learn how a real robot move this base
- 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 Callback Based SimpleActionClient
Example of using callbacks for program flow that's more complicated than a simple, linear script.
- 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.
- Create your own task
This tutorial explains how to create a task for the robot to execute
- Schedule your own task on the robot
- Controlling turtlesim from Lisp
In this tutorial you will learn how to control a turtle in turtlesim with CRAM Fluents
- Creating a CRAM package
In this tutorial you will learn how to set up a ROS package to use the CRAM plan language
- Implementing simple plans to move a turtle
In this tutorial you will learn how to implement a simple plan to move a turtle from waypoint to waypoint.
- Process modules
The concept of process modules allows to write plans that are robot independent.
- Set-up and first steps with CRAM and the CRAM language
In this tutorial, you learn how to set up your environment and how to use the CRAM language from the lisp REPL
- 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.
- 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.
- Connecting to Dynamixel bus
This tutorial describes how to connect and examine raw feedback from Robotis Dynamixel servos.
- Creating a joint controller
This tutorial describes how to create a joint controller with one or more Robotis Dynamixel motors.
- Covariance Ellipsoids
Algorithms for 2d and 3d covariance ellipsoids, typically used in slam.
- Function Objects
Passing functions around as typed class objects.
- Parameters
Avoiding a profusion of get/set.
- Reference Wrappers
When you want to pass a reference, but are only permitted to pass a copy.
- Singleton
The classic singleton design pattern.
- Eigen Extensions
Some extensions the ecl has made in and around eigen.
- Using Eigen
There are quite a few tricks you should be aware of when using eigen...
- Arrays
Introduction to c++ style arrays, both fixed and dynamic.
- Buffer Overflow Detection
Detecting ecl array over/under runs.
- Fifo
A simple first in, first out class.
- Stencils
Windows onto ecl arrays.
- Container Utilities
container formatters and converters.
- Numerical Limits
Fixing a few rough edges around c++ numeric limits.
- The 'Is A' Traits
Temporary fillers for the 'is a xxx' fundamental type traits till C++0x is widespread.
- Command Line Parsing with TCLAP
Introduction to command line parsing with TCLAP.
- Using Ecl Formatters
Introduction to the usage of ecl formatters.
- Writing a Custom Formatter
Writing your own custom formatters.
- Priorities
Setting thread or process scheduling priorities.
- Thread
Threading functionality via composition.
- Thread Locks
Locking threads to protect shared data
- Threadable
Threading functionality via inheritance.
- Introduction to Ecl Devices
Introduces the general framework for ecl devices.
- Implementing Concepts
Writing and using concept check tests.
Simple Math
- Input and Output Streams
General usage notes for input-output streams.
- Logging Streams
- Manipulators
Manipulators for ecl streams.
- Semaphores
Locks for multiple processes (use with shared memory).
- Shared Memory
Simplified api-like interface to shared memory storage.
- Using Converters
Demonstrates usage of the ecl converters.
- Boolean Logic
Using compile time boolean types for metaprogramming.
- Converters
Compile time type converters.
- Enable If
An if operator for template type arguments.
- Benchmarking
Tools to assist benchmarking programs.
- Sleep
Classes that put the thread to sleep for fixed or periodic intervals.
- Stopwatch
Devices to record the passing of time.
- Timestamps and Durations
Timestamping and performing arithmetic on timestamps/durations.
- Angles
Convenience class for abstractly storing and representing angles.
- Cartesian Points
Simple object representations for cartesian points.
- Polynomials
Working with polynomials of the n-th degree.
- Pose
2D and 3D representations for poses.
- Splines
Continuously connected functions (splines) and interpolation algorithms.
- Debugging Sigslots
Tools to help debug sigslots problems.
- Introduction to Sigslots
Creating, connecting and triggering signals and slots.
- Relaying Signals
Relaying data from one signaller to the next.
- Ecl Exception Handling
Introduction to the usage of exceptions in the ecl.
- No malloc/new
- No exceptions
- Minimal templates
- Custom Platform Detection
Manually setting platform macros for the ecl on a custom board.
- Sigslots for Embedded Boards
Sigslots designed for very low end boards/dsp's.
- Simple Error Handling
Simple cross-platform error handling macros, flags, asserts used by the ecl.
- Debugging Sigslots Lite
Utility functions for diagnosing lite sigslots.
- Using Sigslots Lite
Shows how to set up signals and slots with ecl_sigslots_lite.
- Custom Platform Detection
Manually setting ecl_config parameters for a custom board configuration.
- Assertions in the Ecl
how to utilise ecl's run-time and compile-time asserts/aborts.
- Debug Modes in the Ecl
Toggling debug/ndebug mode for the ecl.
- Error Handling in the ECL
Shows how the ecl does error handling at the simplest level, with macros and flags.
- Link As Needed
Remove unused library dependencies from being automatically linked by ros.
- The Ecl CMake Library
Lists ecl's cmake library api and demos its usage.
- Link as Needed
Remove unused library dependencies from being automatically linked by ros.
- The Ecl CMake Library
Lists ecl's cmake library api and demos its usage.
- Running the Controller
Explains how to how to run a force controlled trajectory.
- Switching Controllers at Run Time (Python)
Shows how to switch between the force/impedance controller and the arm_navigation suite of controllers at run time. This tutorial is only available in python.
- Writing a Force Controller (C++)
Shows how to use the force/impedance controller for force control using C++.
- Writing a Force Controller (Python)
Shows how to use the force/impedance controller for force control using python.
- Writing a Stiffness Controller (C++)
Shows how to use the force/impedance controller to do stiffness control with the PR2 arm using C++.
- Writing a Stiffness Controller (Python)
Shows how to use the force/impedance controller to do stiffness control with the PR2 arm using python.
- Running the Controller
Explains how to download the action server and controller and how to run a force controlled trajectory.
- Writing a Force Controller
Shows how to use the force/compliance controller for force control.
- Writing a Stiffness Controller
Shows how to use the force/compliance controller to do stiffness control with the PR2 arm.
- Writing a Stiffness Controller (Python)
Shows how to use the force/compliance controller to do stiffness control with the PR2 arm.
- Running showcase applications
Short tutorial on running some apps ready to launch as showcase.
- Full Cross
Cross-compiling in a cross-compiled ros.
- Install/Uninstall Targets
This shows how to add install/uninstall targets to your package. This is most useful when building strictly c++ packages (no ros) within the ros build environment and you want a regular install step.
- Installing with Unison
This tutorial covers a simple method to filter (create binary images) and deploy ros stacks to an embedded board or a fakeroot.
- Partial Cross
Outlines how to use the ros build environment as a cross-compile environment for embedded development (doesn't actually cross-compile ros itself).
- Toolchain Bridge
Convert an existing toolchain into an ros-ready toolchain.
- Ubuntu in a Chroot
Part two of a three part tutorial illustrating how to install, maintain and deploy a stripped down ubuntu (lucid) on pen drives for intel atoms using an i686 intel build platform. This one covers maintainence in a chroot.
- Ubuntu for Intel Atoms
Part one of a three part tutorial illustrating how to install, maintain and deploy a stripped down ubuntu (lucid) on pen drives for intel atoms using an i686 intel build platform.
- Ubuntu on Pen Drives
Part three of a three part tutorial illustrating how to install, maintain and deploy a stripped down ubuntu (lucid) on pen drives for intel atoms using an i686 intel build platform. This one covers bulletproofing deployment on pen drive using a union filesystem.
- 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 State Machine
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
- Bringing up the find object system
How to start up and control the system
- 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.
- Adding a frame (C++)
This tutorial teaches you how to add an extra fixed frame to tf2.
- Adding a frame (Python)
This tutorial teaches you how to add an extra fixed frame to tf2.
- Debugging tf2 problems
This tutorial gives a systematic approach for debugging tf2 related problems.
- Introduction to tf2
This tutorial will give you a good idea of what tf2 can do for you. It shows off some of the tf2 power in a multi-robot example using turtlesim. This also introduces using tf2_echo, view_frames, and rviz.
- Converting Datatypes
This is a quick description of the changes in syntax for converting datatypes.
- Migrating a TransformBroadcaster from tf to tf2
This is a guide for converting a tf TransformBroadcaster class to a tf2 Listener class
- Migrating a TransformListener from tf to tf2
This is a guide for converting a tf TransformListener class to a tf2 Listener class
- Time travel with tf2 (C++)
This tutorial teaches you about advanced time travel features of tf2
- Time travel with tf2 (Python)
This tutorial teaches you about advanced time travel features of tf2
- Transforming your own datatypes
This tutorial explains which methods you need to implement to make tf2 transform your own datatypes.
- Using Stamped datatypes with tf2::MessageFilter
This tutorial describes how to use tf2::MessageFIlter to process Stamped datatypes.
- Writing a tf2 broadcaster (C++)
This tutorial teaches you how to broadcast coordinate frames of a robot to tf2.
- Writing a tf2 broadcaster (Python)
This tutorial teaches you how to broadcast the state of a robot to tf2.
- Writing a tf2 listener (C++)
This tutorial teaches you how to use tf2 to get access to frame transformations.
- Writing a tf2 listener (Python)
This tutorial teaches you how to use tf2 to get access to frame transformations.
- Learning about tf2 and time (C++)
This tutorial teaches you to use the waitf2orTransform function to wait for a transform to be available on the tf2 tree.
- Learning about tf2 and time (Python)
This tutorial teaches you to use the waitf2orTransform function to wait for a transform to be available on the tf2 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.
- 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 set up hector_slam for your robot
This tutorial shows you how to set frame names and options for using hector_slam with different robot systems.
- Getting started
Generating a simple trajectory from footprints.
- Loading a pre-computed trajectory
How to use the generator node to load a stored trajectory.
- 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.
- Writing a simple image processor
This code snippet shows how to modify and create a sensor_msgs/Image.
- 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.
- 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.
- 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.
- 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.
- 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.
- Adding a Kinect to an iRobot Create/Roomba
This tutorial has step by step instructions for modifying the iRobot Create/Roomba to power a Kinect.
- 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.
- Download and install wifi_comm
This tutorial will guide you through the process if downloading and installing wifi_comm as well as olsrd.
- How to run wifi_comm
This tutorial guides you through the process of running wifi_comm.
- Assembling the Roomba
This tutorial guides you through the process of assembling a typical LSE Roomba.
- Installing the software for a Roomba
This tutorial will guide you through the process of installing all the necessary software to run a LSE Roomba on its netbook.
- Simulating a Roomba on Stage
This tutorial will guide you through the process of simulating a single Roomba equipped with a laser range finder on Stage, and how to use the navigation stack with it.
- Running the navigation stack on the Roomba
This tutorial guides you through the process of setting up the navigation stack for the Roomba robot.
- Running pointcloud_registration
This tutorial show how to use the pointcloud_registration package.
- Grasping an Object
This tutorial shows how to detect an object using ar_kinect and then grasp the object using simple_arm_server.
- Moving the Arm
This tutorial shows how to move the arm on Mini Maxwell using the simple_arm_server.
- Moving the Base
This tutorial will show you how to move the robot base.
- Pointing the Head
This tutorial shows step by step how to point the head at a point in space.
- Starting Up Mini Maxwell
This tutorial guides you step by step through starting the Mini Maxwell robot
- Using the Buttons
This tutorial shows how to access the state of the buttons on Mini Maxwell
- Assembling the Body
This tutorial shows how to assemble the base, torso and head for Mini Maxwell
- Netbook Setup
This tutorial will show you how to setup a netbook to control Mini Maxwell.
- Wiring Mini Maxwell
This tutorial shows how to wire and program the servos.
- EVaRT setup
How to setup evart-stream and evart_bridge?
- Getting started
Basic use of evart_bridge
- 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.
- Basic Navigation Tuning Guide
This guide seeks to give some standard advice on how to tune the ROS Navigation Stack on a robot. This guide is in no way comprehensive, but should give some insight into the process. I'd also encourage folks to make sure they've read the ROS Navigation Tutorial before this post as it gives a good overview on setting the navigation stack up on a robot wheras this guide just gives advice on the process.
- 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.
- Running NetFT node
Tutorial describing how to configure Linux network to communicate with NetFT sensor. It also describes running NetFT ROS node and provides some troubleshooting tips.
- Using NetFT plugin with pr2_etherCAT
Configuring and using NetFT plugin with pr2_etherCAT
- Running NetFT example controller
Describes using and troubleshooting controller that uses AnalogIn data from netft_ethercat_hardware plugin.
- Porting nodes to nodelets
- Running a nodelet
This will show you how to run a nodelet already in the system.
- 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.
- Running the Action Client
Shows how to run opencupboard_action
- Writing the Action Client
Shows how to use opencupboard_action
- Frame transformations (Python)
This tutorials gets you started with KDL Frames, Vectors, Rotations, etc
- Getting Started with p2os
A quick tutorial for installing and running p2os with ROS
- Running patrolling_sim
This tutorial describes how to run the patrolling_sim package in Stage/ROS. An example is presented for ease of understanding.
- Write a node that performs analog input and output operations.
Setup a node to use the Sensoray 626 for analog input and output operations.
- Turning a PointCloud into an Image
This tutorial is a simple guide to turning a dense point cloud into an image message
- ConvexHull planar surface reconstruction
ConvexHull planar surface reconstruction
- ExtractPolygonalPrismData segmentation
ExtractPolygonalPrismData segmentation
- PassThrough filtering
PassThrough filtering
- SACSegmentationFromNormals planar segmentation
SACSegmentationFromNormals planar segmentation
- VoxelGrid filtering
VoxelGrid filtering
- How to compose a script for use with Polonius
A tutorial describing how to write a script for use with Polonius
- Running the portrait bot
A tutorial on how to run the portrait_bot stack on the PR2 and the basestation.
- Reconfiguring the experience based parameter selector
This tutorial describes how the experience based parameter selector can be reconfigured to give out results with different properties.
- Using face_contour_detector without the other packages in the portrait_bot stack
This tutorial describes how to send the face_contour_detector requests without the rest of the tools in the portrait_bot stack.
- 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
- Kinect URDF Calibration (Experimental)
Calibrate the Kinect Sensor into PR2's URDF
- Null Chain Kinect URDF Calibration
Calibrate the Kinect sensor that is not part of any calibration chain into PR2's URDF (practically for every mount point but head).
- Using PR2 Auto Calibration (Experimental)
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).
- Changing the packet timeout and number of process data retries for pr2_etherCAT
Changing the packet timeout and retries for pr2_etherCAT
- 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.
- 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
- Upgrading WGE100 Firmware on the PR2
Updating and verifying the firmware for all WGE100 cameras on the PR2.
- Types of EtherCAT packet loss
How to determine what is causing EtherCAT packet loss.
- 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 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.
- Running Simulator with GDB cturtle
- Running Simulator with GDB diamondback
- Starting a Separate Sensor Generation Node
Start up an image sensor generation node when the main simulation node is running headless.
- PR2 Pick and Place Demo
PR2 Pick and Place Demo in Simulation Using the Grasping Pipeline
- Starting PR2 in Simulation
Starting PR2 in Simulation
- Teleop PR2 arm in simulation
This tutorial will give you keyboard teleop control of the PR2 arm
- 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.
- Adding a GazeboRosForce gazebo ros plugin to a simulated object
- 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.
- 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.
- Mingw Qt-Ros Packages
How to create qt-ros packages that can also be compiled by the mingw_cross compiler.
- Qt App Templates
Speeding app development with quickstart templates via roscreate-qt-pkg.
- Qt App Templates
Speeding app development with quickstart templates via roscreate-qt-pkg.
- Reinforcement Learning Tutorial
This tutorial explains how to use the rl-texplore-ros-pkg to perform reinforcement learning (RL) experiments. It will explain how to compile the code, how to run experiments using rl_msgs, how to run experiments using rl_experiment, and how to add your own agents and environments. This package was developed by Todd Hester and Peter Stone at the University of Texas at Austin.
- Using interactive markers with rosjs
This tutorial describes using interactive markers in wviz
- Writing a simple 3D visualization for rosjs
This tutorial covers using rosjs to write a simple 3D visualization in the browser.
- Detecting a new audio event using the ROAR detector
This tutorial teaches you how to use the ROAR package to detect learned audio-event models
- Learning a new audio event using the ROAR trainer
This tutorial teaches you how to use the ROAR package to create and train a new model for audio-event detection
- Pre-Recording audio for training and testing with ROAR
This tutorial gives instructions on how to record audio .wav files and use them for training and testing with the ROAR package
- Create a point cloud object model
Create a point cloud model from an object using a Kinect camera and a marker pattern
- Download object models and use them for object detection
Download object models from the RoboEarth database and use them for object detection
- 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 Physical and Collision Properties to a URDF Model
Learn how to add collision and inertial properties to links, and how to add joint dynamics to joints.
- Adding a Sensor to the PR2 URDF
This tutorial describes how to add a camera sensor to the PR2 URDF.
- Building a Movable Robot Model with URDF
Learn how to define movable joints in URDF
- Building a Visual Robot Model with URDF from Scratch
Learn how to build a visual model of a robot that you can view in Rviz
- 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 Xacro to Clean Up a URDF File
Learn some tricks to reduce the amount of code in a URDF file using Xacro
- 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
- Working Directly with COLLADA
This tutorial shows how to visualize COLLADA XML files and use the in the ROS system as an alternative to URDF XML files.
- Converting SimMechanics To URDF!
A step by step tutorial.
- View camera images
A guide on how to view camera images from Robotino using the image_view package.
- Mapping with Robotino
Explains how to build a map with Robotino using gmapping
- Navigation with Robotino
Autonomous navigation of a known map with Robotino
- 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.
- 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.
- Organizing files for roslisp
This tutorial explains how the ASDF standard is used in roslisp, with a few added conventions.
- 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
- 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.
- 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++.
- Writing actionlib servers
This tutorial presents the macros offered by actionlib_lisp.
- Basic usage of actionlib with actionlib_lisp
This tutorial gives a brief intro to writing clients for actionlib servers
- Basic usage of CL_TF
This tutorial describes the tf client that allows easy access to transformations in the ROS TF framework
- Unit Testing with RT
This explains how to create unit tests with RT, also for rostest
- Arduino IDE Setup
This tutorial shows step-by-step how to setup up the Arduino IDE to use rosserial.
- Arduino Oscilloscope
In this tutorial, we will be making a poor man's oscilloscope using the Arduino's ADC (analog to digital converter) and rxplot.
- Blink (example subscriber)
This tutorial shows step by step how to use rosserial with subscribers.
- BlinkM Tutorial
Control a BlinkM through ROS using an Arduino and rosserial
- CMake with rosserial_arduino
This tutorial shows how to use the CMake build system with rosserial_arduino.
- Hello World (example publisher)
This tutorial shows step by step how to create a publisher using rosserial.
- IR Ranger Tutorial
Using an IR Ranger with rosserial and an Arduino
- Temperature Sensor
Measuring Temperature using the TMP102
- Push Button
Monitor a push button and publish its state in ROS
- SRF08 Ultrasonic Ranger
In this tutorial, we will use an Arduino and a SRF08 Ultrasonic Ranger as a Range Finder.The SRF08 communicates with an Arduino over SPI/I2C.
- Servo Controller Example
Tutorial for controlling an R/C servo with rosserial and an Arduino
- Using Time and TF
This tutorial shows how to use ros::Time and TF to create a tf publisher on the Arduino.
- Adding Support for New Hardware
This tutorial contains details about the custom code required to get rosserial_client working on your hardware.
- Generating Message Header File
This tutorial shows how to generate message header files for using new message packages with rosserial.
- Using rosserial with AVR and UART
This tutorial will show you how to get the rosserial_arduino Hello World (example publisher) tutorial running on an AVR.
- An Example rosserial_xbee Network
A guide to building a simple rosserial_xbee network
- ROS RC Car
controlling an a small robot base with rosserial_xbee
- Creating a package to interact with our robots.
This tutorial will show you how to create a package to interact with our robots. This is the "clean" way of working with the robots.
- Running the Hand and Arm Interface
This tutorial is an introduction on how to run the Hand and Arm interface. It explains how to change from the simulated to the real interface.
- Moving the Robot
First examples on how to interact with the Robot, through a GUI or simple programs.
- Recording a movement and replaying it.
Uses rxbag to record and replay a movement.
- Using the Object Manipulation Stack with the Shadow Robot Hand.
Using the Shadow hand / arm to do some automatic pickup and place. The 3D sensor we're using is a Microsoft kinect.
- Setting new Controller Parameters
Learn how to change the PID parameters value on our real hardware using ROS.
- Simulation: Using the Gazebo interface
This tutorial will get you started with our Gazebo interface.
- Starting different nodes on different machines
This will show you how to easily start different nodes on different machines.
- Getting Data
Getting data from the tactile sensors.
- Using the Real Tactile Sensors
If you want to learn how to run the real tactile sensors interface on our hand.
- Using Simulated Tactile Sensors
Learn how to use the two different simulated tactile sensors: the dummy tactile sensors, and the simulated tactile sensors in the Gazebo simulator.
- Create a new Controller for the Shadow Hand
Create a new controller for the Shadow Robot Hand (EtherCAT or simulated in Gazebo).
- Controlling the Shadow Hand with a Cyberglove
In this tutorial you'll learn how to easily control a Shadow Dexterous Hand using the Cyberglove.
- Starting the EtherCAT Hand
How to start the etherCAT Hand ROS driver.
- Controlling the EtherCAT Hand
How can you send targets to the EtherCAT hand.
- Starting a set of Controllers
How do we start a given set of controllers, to move the joint by controlling their positions, their velocity, or the forces applied.
- Moving an Arm
This tutorial shows step-by-step how to move an ArbotiX-based arm controlled by the simple arm server.
- Simulate a Spinning Top
Simulate a Spinning Top
- Gazeb Plugin Intro
A basic tutorial that shows users how to create a gazebo plugin.
- 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.
- Downloading and installing PlumeSim
This tutorial guides you through the process of downloading and installing PlumeSim.
- How to export a Fluent log file for PlumeSim
This tutorial teaches how to export a Fluent log file to be used in PlumeSim.
- Using PlumeSim with virtual_nose
This tutorial teaches how to use virtual_nose with PlumeSim to simulate a virtual nose.
- 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
- 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.
- Running the continual planning navigation demo
This tutorial shows how to run the navigation demo for continual planning.
- Learn how to create your own trajectory filter
Learn how to create your own trajectory filter
- 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.
- Advanced Networking for Turtlebot
Advanced methods for setting up networking on your turtlebot
- How to control your TurtleBot from an Android device
This will walk you through how to control your TurtleBot from an Android phone or tablet.
- Environment Setup
This tutorials steps you through setting up your desktop environment.
- Visualizing TurtleBot Kinect Data
This tutorial shows you how to look at data coming from the kinect camera.
- TurtleBot Care and Feeding
This tutorials explains how to charge and maintain your TurtleBot.
- Turtlebot Ubuntu Installer
Using and Regenerating the Turtlebot Ubuntu Installer
- TurtleBot Bringup
How to start the TurtleBot software.
- The TurtleBot Follower Demo
This describes how to run the TurtleBot Follower Demo on your TurtleBot.
- TurtleBot Teleoperation
How to teleoperate your TurtleBot with a keyboard, joystick, or rviz.
- Teleoperate a Turtlebot with the PS3 Joystick
Teleoperate a Turtlebot with the PS3 Joystick
- TurtleBot Odometry and Gyro Calibration
This will show you how to calibrate or test the calibration of a TurtleBot which is highly recommended when running any navigation based application.
- Autonomous Navigation of a Known Map with TurtleBot
This tutorial describes how to use the TurtleBot with a previously known map.
- SLAM Map Building with TurtleBot
How to generate a map using gmapping
- Assembling the TurtleBot Arm
Instructions on how to assemble the TurtleBot arm.
- Installation Instructions for TurtleBot Arm
Installing the software for the TurtleBot Arm, both on the TurtleBot and on the local machine.
- Setting up TurtleBot Arm Servos
This tutorial walks through setting the correct IDs for the servos, confirming that the power to the board works correctly, and testing the arm.
- Calibrating a Kinect to the TurtleBot Arm for Manipulation
This tutorial will describe how to calibrate the physical position of the kinect to the TurtleBot arm, when the kinect is positioned either on-board the TurtleBot or off-board.
- Using TurtleBot Arm Interactive Markers
Learn to control the TurtleBot arm through interactive markers in rviz, including doing trajectory control and individual joint control.
- TurtleBot Arm Block Manipulation Demo
This tutorial will walk you through picking and placing blocks on a level surface using user input from rviz.
- Installing the TurtleBot Simulator
This tutorial will step you through installing the TurtleBot simulator on your Ubuntu desktop.
- Running the TurtleBot Simulator
This tutorials demonstrates how to start the TurtleBot simulator and drive the TurtleBot in simulation.
- TurtleBot Teleoperation Using Interactive Markers
A tutorial describing how to use rviz interactive markers for controlling the TurtleBot.
- Running a twoLevelMTTD simulation in ROS (using stageros)
This tutorial allows and explain how to simulate (and use) the twoLevelMTTD OROCOS components using MTTD_interface for ROS.
- Running twoLevelMTTDExamples - Experiment 1
This tutorial explain, step by step, how to run the first experiment in twoLevelMTTDExamples
- 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.
- Configuring a Multiple Joystick System
This tutorial uses the joystick remapping node to allow two different joysticks to control a single robot.
- 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.
- Converting between ROS images and OpenCV images (Python)
This tutorial describes how to interface ROS and OpenCV by converting ROS images into OpenCV images, and vice versa, using cv_bridge. Included is a sample node that can be used as a template for your own node.
- Converting between ROS images and OpenCV images (C++)
This tutorial describes how to interface ROS and OpenCV by converting ROS images into OpenCV images, and vice versa, using cv_bridge. Included is a sample node that can be used as a template for your own node.
- Fine tuning of the tracking parameters
Modifying offline and online the tracking parameters.
- Getting started with the ViSP moving edge tracker
How to track an object using a recorded video sequence.
- Tracking your own model
How to track a custom object.
- Interactive Markers: Basic Controls
This tutorial explains how the basic_controls tutorial code works.
- Interactive Markers: Getting Started
This tutorial explains what Interactive Marker are and teaches you some of the basic concepts.
- Interactive Markers: Writing a Simple Interactive Marker Server
This tutorial explains how to setup a minimalist server which manages a single interactive marker.
- Markers: Points and Lines (C++)
Teaches how to use the visualization_msgs/Marker message to send points and lines to rviz.
- 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.
- 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.
- Running the warehouse
How to start up and configure the Mongo DB server
- Using the C++ client library
How to use the C++ client library to talk to the warehouse
- Using the Python client library
How to use the Python client library to talk to the warehouse
- Web App Basics
The basics of making/using Web Apps
- Running Qualification System
Running the WG Hardware Qualification System.
- Using Test Manager
Covers using, debugging and running Test Manager.
- Using mtrace_plot
Using mtrace_plot to view MotorTrace messages
- Simulating the 2dnav Stack
This tutorial describes how to simulate a 2d-navigation stack in gazebo.
- 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.
- Mingw Build Environment
a cross-compiling build environment for mingw programs.
- Mingw Packages
How to create ros packages that can also be compiled by the mingw_cross compiler.
- Mingw Qt-Ros Packages
How to create qt-ros packages that can also be compiled by the mingw_cross compiler.
- Visual Studio Build Environment
Compiling ros packages with rosbuild2 and the ms visual studio compiler.
- Visual Studio SDK
Installing, configuring and verifying the windows sdk.
- Visual Studio SDK Projects
Setting up projects in Visual Studio that use the sdk.
- Mingw Build Environment
A cross-compiling build environment for mingw programs.
- Mingw Cross and Native Mingw Compatibility
Often you'll need to transfer some mingw_cross built libs to a native mingw windows environment so that you can finish development. Either its because your colleagues are using windows, or you have other libraries already built in the native mingw environment that you cant rebuild with mingw_cross. This guide was written based on Guillaume Walck's experiences.
- Mingw Packages
How to create ros packages that can also be compiled by the mingw_cross compiler.
- Mingw Qt-Ros Packages
How to create qt-ros packages that can also be compiled by the mingw_cross compiler.
- Integrating a detector
This tutorial describes how to integrate a custom detector into world_db_model.
- Zeroconf Avahi Tutorials
Tutorials for an avahi (linux) implementation of zeroconf.
- Zeroconf Jmdns Tutorials
Tutorials for a java (android) implementation of zeroconf.
- Understanding Service Types
Explains the zeroconf service type formats.
- Debugging with Avahi Command Line Tools
Some tips on how to use the avahi tools to debug zeroconf services.
- Discover Ros Masters with Avahi
Illustrates how to discover ros master services with avahi.
- Publishing a Ros Master with Avahi
Illustrates how to publish a zeroconf service for your ros master with avahi.
- Zeroconf Using Ros Api with Avahi
Illustrates how to do generic publishing/discovery of zeroconf services using a ros style api with avahi.
- Publishing Services
Illustrates how to use the zeroconf_jmdns api to publish services.
- Service Discovery via Callbacks
Shows how to do service discovery with jmdns using callbacks.
- Service Discovery via Polling
Shows how to do service discovery with jmdns using a simple polling method.
- 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.
- How to use ROSARIA with ActivMedia/MobileRobots/Adept robots
This tutorial describes how to get started using ROSARIA with ActivMedia/MobileRobots/Adept robots (supported with Aria library). Using an iPhone's inertial sensing like a joystick to drive the robot is demonstrated.
- Dashboard
This tutorial show you how to run the simulation of the Care-O-bot on your pc.
- Running showcase applications
Short tutorial on running some apps ready to launch as showcase.
- Using USB flash drive for bag files storage
Simple how-to on using USB flash drive for storing bag files (as EeePC internal HDD has very limited capacity)
- CMake for avr_bridge
cmake compilation and programming for arduinos using avr_bridge
- Hello World
The avr_bridge hello world using an arduino
- Setting Up Eclipse for avr_bridge
How To set up Eclipse IDE for compiling and programming the avr_bridge avr code
- How to train and use the BiGG object detector
This tutorial presents a brief description of the steps needed to train and use the BiGG object detector
- Using cob_arm_navigation to plan collision-free arm movements for Care-O-bot 3.
This tutorial will explain which launch files need to be started to plan collision-free movements for the care-o-bot mobile manipulator.
- Train a new object
This tutorial teaches you how to train a new object with the IPA object detection package.
- Contour Initialization
In this tutorial you will learn how to initial the contour of a given object in an image or in a video.
- Tracking
In this tutorial you will learn how to use the CCD algorithm to track the motion of a moving object in a sequence of images, e.g. a video.
- Segmentation
In this tutorial you will learn how to use the CCD algorithm to segment an observed object in a static image
- Set-up of CCD and parameters initialization
In this tutorial, you learn how to install the CCD and set up the parameters which control the run-time behaviour
- How to Write Your First .cfg File
This tutorial will familiarize you with .cfg files that allow you to use dynamic_reconfigure.
- Setting Up Dynamic Reconfigure for a Node
Setting Up Dynamic Reconfigure for a Node
- Setting up Dynamic Reconfigure for a Node(cpp)
How to make a node dynamically reconfigureable in C++.
- Setting up Dynamic Reconfigure for a Node (python)
How to make a node dynamically reconfigureable in python
- Using the Dynamic Reconfigure Python Client
This tutorial cover basic setup and usage of the dynamic_reconfigure client.
- 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.
- 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.
- Debug the grasp evaluation service
This tutorial teaches you how to debug the grasp evaluation server with visualized results
- 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++ によるサービスやクライアントの作り方について説明します．
- ROS 파일시스템 돌아다니기
이 자습서는 ROS 파일시스템 개념을 소개하고, roscd, rosls, rospack 명령행 도구 사용법을 다루고 있습니다.
- 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.
- Using the move_arm_service package
Explains how to use the services to make simpler calls to move_arm and interpolated_ik_motion_planner.
- Cross-Compiling ROS for the Nao
This tutorial covers the steps necessary for cross-compiling ROS for the Nao's AMD Geode platform.
- Cross-Compiling ROS for the Nao (cturtle on NaoQI 1.6)
This tutorial covers the steps necessary for cross-compiling ROS cturtle for the Nao's AMD Geode platform (NaoQI 1.6).
- Assisted Teleop Video Demo
This is the demo shown in the announcement video.
- Building a Database From a Set of Images
This tutorial describes how to create a database for ODUfinder from set of images. The database is stored into binary files, which can than be used by ODUfinder in order to recognize objects.
- Detecting Objects
This tutorial describes how to use ODUfinder in order to detect objects in the camera images
- Getting Started with openning the cupboard
These tutorial will show you how to use the GraspHandleAction
- How to write a simple client for opendoors action server
This tutorial shows how to write a simple client for the GraspHandleAction
- Writing the Action Client
- Writing the action Client
- 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
- Writing and Using a Simple Plugin
This tutorial describes how to create and then load a simple plugin using pluginlib.
- Calling Grasp Adjustment
- 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.
- Customizing a Joystick Configuration
- Remote Operation of a PR2
- Running PR2 Counterbalance Check
Shows how to run the counterbalance adjustment test on the PR2.
- Adding a new detector to the recognition infrastructure
This tutorial shows how to add a new detector to the recognition infrastructure
- Testing the teleoperation pipeline
A tutorial about how to set up and use the teleoperation pipeline with REEM. The pipeline can be tested using a Kinect or a provided bag file containing an example captured operator motion.
- Adding a new detector to the recognition infrastructure
This tutorial shows how to add a new detector to the recognition infrastructure
- Using multiple cameras
Describes how to set up udev rules and launch files to use several robotino_cams
- Calibrating the Robotino grappler
Steps on how to calibrate the grappler on Robotino
- A More Advanced Publisher/Subscriber
A tutorial to show how to change control values via ROS Publishers and Subscribers
- Basic Interaction with ROS and TouchOSC
Interacting with some of the capabilities of ROS and OSC
- Setting up ROSOSC
Setting up an environment to use ROSOSC and TouchOSC
- Loading TouchOSC Layouts with ROS
Basics of TouchOSC and loading custom layouts to iOS devices.
- Using Tabpage Handlers (Teleop)
How to use pre-built tabpage handlers in the ROSOSC stack. In particular, the teleoperation tabpage handler.
- Using Tabpage Handlers (Diagnostics)
How to use pre-built tabpage handlers in the ROSOSC stack. In particular, the diagnostics tabpage handler.
- Using the Default tabpage handler to interact with TouchOSC layouts
How to use the default tabpage handler to interact with TouchOSC layouts
- 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
- Getting Started with rosserial_java
How to get started with rosserial_java on Android
- How to run rosworldwind
This tutorial covers how to visualize a Marker on a virtual globe.
- Installing rosworldwind
This tutorial will guide you through the process of installing rosworldwind
- Writing your own controller.
It is relatively easy to write a new controller.
- Running a stand-alone Shadow Hand
Describes steps needed to get Shadow Hand running stand-alone.
- Plot mtrace data from Shadow Hand device
Plot mtrace data from Shadow Hand device
- Detailed Explanation
This tutorial gives you detailed explanation about the SRS tutorials.
- Get the milk
This tutorial teaches you how to run the get milk script.
- Installing stacks for SRS tutorials
This tutorial teaches you how to install stacks for the srs tutorials.
- Testing the grasp action server.
This tutorial teaches you how to test the grasp action server
- Introduction to Stage Controllers
Stage (ver 3.0.0 and above) is equipped to work as standalone, wherein controllers integrated into stage enables motion, behaviour and processes for the robot(s). This tutorial discusses two such stage controllers.
- Making Maps Using Stage's Wander Controller
This tutorial uses stage's wander controller to obtain a map of the robot's environment in an incremental manner.
- 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.
- First Flight
This tutorial walks through the first 'flight' using starmac-ros-pkg. This is done using the simple quadrotor simulator provided by flyer_sim and so you can do this tutorial without an actual robot.
- Installing starmac-ros-pkg
This tutorial provides a guide to installing starmac-ros-pkg and its dependencies
- Download and install swissranger_camera
This tutorial guides you through the process of downloading and installing all the software needed to run your Swissranger 3D Camera.
- Cabinet Handle Detection
This tutorial explains how to run tabletop_for_cabinet to find a handle on a cabinet door. It also shows how to see the handle in rviz.
- Recognition Node
This tutorial explains how to start a ROS recognition node and recognize objets
- Recognizing tools
This tutorial explains how to recognize objects using tod_detecting
- Training Base Creation
A guide to creating a training base suitable for textured object recognition from a prerecorded bag.
- recording a training bag
- Connecting the XV-11 Laser to USB
This tutorial will show you how to remove the XV-11 vacuum cleaner's built in laser and connect it as a stand alone laser scanner through USB.
- Running the XV-11 Laser Node
This tutorial will walk you through installing and running the XV-11 Laser Node so that you get laser scans in rviz.
- The Underlying XV-11 Protocol Explained
This tutorial will walk you through one entire message sent from the XV-11 laser and will tell you exactly what gets output from the unit. This is an advanced tutorial for those interested in the raw data formatting. This is for the older firmware only.
MikroKopter
MikroKopter stack for ROS
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.
aaai_lfd_demo
Infrastructure for the 2011 AAAI-LfD Challenge
android_sensors_driver
android_sensors_driver
arbotix
This stack provides comprehensive access to the ArbotiX RoboController and associated peripherals.
arm_navigation
This stack contains packages that permit collision-free arm navigation
arm_navigation_experimental
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_msgs package defines messages and services for exchanging trajectories and kinematic models.
The articulation_models package provides several nodes for fitting and selecting kinematic models for articulated objects. We employ maximum-likelihood sample consensus (MLESAC) for robustly estimating the kinematic parameters, and the Bayesian information criterion (BIC) for selecting between alternative model classes. The learned model assigns likelihoods to observed trajectories, predict the latent configuration of the articulated object, projects the noisy poses onto the model, predict the Jacobian, etc.
The articulation_structure package provides a service for fitting and selecting the kinematic model for articulated objects consisting of more than two parts.
Several tutorials, example launch files and demonstration videos are available in the package articulation_tutorials.
asctec_drivers
Driver stack for AscTec Quadrotors including the Pelican and Hummingbird
asctec_mav_framework
Framework for data aquisition and position control to be used with the highlevel processor of Ascending Technologies helicopters
audio_common
Common code for working with audio in ROS
bosch_skin
Contains the Bosch Sensor Skin driver and demo applications.
brown_remotelab
Infrastructure for remote labs, remote teleoperation, and teleprescence robotics
camera_drivers_experimental
camera_drivers_experimental
camera_pose
This stack contains a set of tools to work with multiple rgb camera's simultaneoulsy.
cart_pushing
cart_pushing
client_rosjava
client_rosjava
cob_command_tools
The cob_command_tools stack provides tools, for operating Care-O-bot.
cob_scenarios
cob_scenarios
common_tutorials
common_tutorials
continuous_ops
continuous_ops
cram_pl
A set of libraries for implementing AI enabled robot control programs.
crustcrawler_smart_arm
crustcrawler_smartarm
diagnostics
Packages related to gathering, viewing, and analyzing diagnostics data from robots.
dynamixel_motor
This stack contains packages that are used to interface with Robotis Dynamixel line of servo motors. This stack was tested with and fully supports AX-12, AX-18, RX-24, RX-28, MX-28, RX-64, EX-106 models.
ecl_core
A set of tools and interfaces extending the capabilities of c++ to provide a lightweight, consistent interface with a focus for control programming.
ecl_lite
The ecl-lite stack includes packages with few dependencies on either system or c++ functionality. This makes it ideal for very embedded builds where many of the usual mechanisms are unavailable.
It also includes a few packages which standardise lower level api (e.g. posix/win32) with drop-ins to make them properly cross-platform,
ecl_tools
This stack provides cmake modules, makefiles, tools and build scripts for ecl development.
ee_cart_imped
Stack for a controller that does force/impedance end effector Cartesian control.
elektron_robot
elektron_robot
eros
This stack includes supporting components to enable ros development on embedded boards.
executive_smach
The executive_smach stack contains the SMACH library, together with tools for introspection and a ROS integration package.
executive_trex
trex
find_object
find_object
geometry
The basic geometric and math libraries used in ros.
geometry_experimental
The experimental geometric and math libraries used in ros.
gps_umd
This stack provides a ROS binding for the GPS receivers that are supported by the GPSd software (http://gpsd.berlios.de/).
hector_slam
hector_slam contains ROS packages related to performing SLAM in unstructed environments like those encountered in the Urban Search and Rescue (USAR) scenarios of the RoboCup Rescue competition
humanoid_walk
This stack gathers tools to generate walking movements for humanoids robots. It provides both C++ interfaces through walk_interfaces, ROS interfaces through walk_msgs and pattern generators algorithms.
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.
kinect
ROS Kinect is an open source project focused on the integration of the Microsoft Kinect sensor with ROS. The kinect ROS stack contains low-level drivers, visualization launch files, and PCL/OpenCV tutorials/demos.
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.
lse_communication
Communication stack holding some useful tools for serial port communication, CerealPort, as well as a package for communication between robots, WifiComm.
lse_roomba_toolbox
Useful tools for the Roomba robots used at the LSE including popular tf setups, Stage world files and 2D navigation parameters and example launch files for the real and simulated robots.
mapping
Collection of routines and functions for 3D mapping@IAS.
mini_max
motion_analysis_mocap
This stack provides a bridge between the Cortex software from Motion Analysis and ROS. The bridge relies on evart-stream and evart-client software written by Anthony Mallet.
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.
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.
netft
netft
nodelet_core
Nodelets library and tools. Nodelets are a plugin architecture for roscpp that enable dynamic loading of multiple 'nodelets' into a single ROS node instance.
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.
octomap_mapping
The OctoMap library implements a 3D occupancy grid mapping approach, providing data structures and mapping algorithms. The map implementation is based on an octree. This stack contains the actual OctoMap package and additional code for ROS integration.
opencupboard
opencupboard
orocos_kinematics_dynamics
orocos_kinematics_dynamics
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.
patrol
Multi-Robot Patrol-Related Stack from the ISR Coimbra.
penn_lightweight_teleop
penn_lightweight_teleop
perception_pcl
This contains the Point Cloud Library (PCL), its 3rd party dependencies, and a ROS interface for PCL nodelets.
polonius
polonius
portrait_bot
The portrait_bot stack enables the PR2 draw faces recognized in camera images.
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. Note that the only support API for the stack is the tutorial for calibrating the PR2. All of the internal APIs are not considered to be stable.
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_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.
prosilica_driver
This stack contains the ROS driver and SDK for AVT/Prosilica cameras.
qt_ros
This stack provides templates, tutorials and other resources that assist qt on ros development.
reinforcement_learning
Reinforcement Learning framework. Repositories of agents and environments. ROS interface for reinforcement learning algorithms. Includes the TEXPLORE algorithm and real-time architecture for model-based RL. Developed by Todd Hester and Peter Stone at the University of Texas at Austin.
remote_lab
A stack of tools for remote control, tele-op and remote labs.
roar_stack
ROS Opensource Audio Recognizer Stack
roboearth
ROS packages for the RoboEarth project.
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
ROS Stack for Robotino
ros_comm
ROS communications-related packages, including core client libraries (roscpp, rospy, roslisp) and graph introspection tools (rostopic, rosnode, rosservice, rosparam).
ros_experimental
Experimental packages for ROS core system development.
ros_tutorials
ros_tutorials contains packages that demonstrate various features of ROS, as well as support packages which help demonstrate those features.
roslisp_common
Common libraries to control ROS based robots. This stack contains an implementation of actionlib (client and server) in Common Lisp, a transformation library and an implementation of tf in Common Lisp.
roslisp_support
Support stack for roslisp that brings in required sbcl runtime
rosserial
ROS Serial is a point-to-point version of ROS communications over serial, primarily for integrating low-cost microcontrollers (Arduino) into ROS. ROS serial consists of a general p2p protocol, libraries for use with Arduino, and nodes for the PC/Tablet side (currently in both Python and Java).
shadow_robot
This stack regroups the different ros interfaces developped for Shadow Robot's Hardware. It provides an interface to both simulated and real hardware.
shadow_robot_etherCAT
This stack contains the drivers and the controllers for Shadow Robot's EtherCAT Hand.
simple_arms
simulator_gazebo
Wrappers, tools and additional API's for using ROS with the Gazebo simulator.
simulator_plumesim
Odor plume simulator for ROS.
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
sql_database
Provides an easy way to use SQL databases from the ROS environment.
symbolic_planning
The symbolic_planning stack contains symbolic planners (currently TFD/M), domain descriptions and additional packages for integration into ROS.
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.
turtlebot
The turtlebot stack provides all the basic drivers for running and using a TurtleBot.
turtlebot_apps
turtlebot_apps is a group of simple demos and exmaples to run on your TurtleBot to help you get started with ROS and TurtleBot.
turtlebot_arm
The turtlebot_arm package provides bringup, description, and utilities for using the TurtleBot arm.
turtlebot_simulator
Turtlebot specific simulation components.
turtlebot_viz
turtlebot_viz
twoLevelMTTD_stack
Stack for the tracking and detection of multiple targets using the twoLevelMTTD algorithm
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, Phidgets InterfaceKit, Dynamixel servos, Videre Stereo cameras. Also includes low level C++ serial port interface via Gearbox project.
vision_opencv
Packages for interfacing ROS with OpenCV, a library of programming functions for real time computer vision.
vision_visp
This stack wraps ViSP, the virtual visual servoing platform into ROS. In particular, visp_tracker allows online object tracking.
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
warehousewg
warehouse
web_interface
This stack contains the packages and utilities required to run the web user interface.
wg_hardware_test
Hardware testing tools and utilities. Willow Garage use only.
wg_robots_gazebo
This stack contains a variety of tests and demos launch scripts in simulation.
wge100_driver
This stack contains the ROS driver and firmware for the WGE100 camera used on the PR2 robot.
win_ros
Setup and utilities for ros on windows.
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.
zeroconf_implementations
Convenient wrappers around platform-dependant implementations whose purpose are both to expose a fairly standard sort of api as well as a ros api (topics and services) where practical. The only implementation it doesn't include is the android (will eventually merge back in here if ubuntu starts officially including adk packages).
Tutorials with no stack