Software Development for

Robotics Research
Make your research easier with ROS and other tools
What is ROS?
ROS - the Robot Operating System

a middleware

for interprocess communication and management

a build system / toolchain

an ecosystem of open source robotics software

your friend!
A brief history
Originally developed for class software at Stanford
(c. 2007)
First pub ICRA 2009

Big boost in being used on the PR2 at Willow

Garage (Started with Box turtle, now Jade)

OSRF created to keep ROS going after Willow

Garage closed

ROS 2.0 coming soon, standardized transports

with QOS, better support for other OSes, lighter
weight embedded support,...
The Ecosystem
Kinematics and Dynamics
Kinematic transforms and frames
Orocos / KDL - Forward and inverse kinematics and dynamics
Control and Planning
Standardized control interfaces
OMPL - Open Motion Planning Library
Motion planning libraries (MoveIt!)
Lots of robot drivers / controllers already built
Perception
OpenCV & PCL - Point Cloud Library integration
Mapping and localization
Camera calibration
Stereo image matching
Laser data processing
...
The Ecosystem
Kinematics and Dynamics
Control and Planning
Perception
Simulation
Gazebo
now with multiple physics engines!
Visualization
RVIZ
Getting / Installing and Using
Full support currently only on Ubuntu Linux

Important to match releases of ROS with appropriate Linux releases

ROS 2.0 should fix some of these issues

Current setup for our robots is using Ubuntu 14.04 LTS with ROS Indigo

Can easily install through the package manager (apt)

but installing from source is not too hard, particularly if its only a few packages
you need to hack on

and is SIGNIFICANTLY easier than 5 or 6 years ago

Code Implementation
First class support for two languages:
C++
Python

Somewhat supported:
Matlab / Octave (with help from MathWorks now)
Java
lisp
Issues
Native real-time support is poor

Can be a lot of infrastructure for small projects

particularly with limited system resources

Constrained on system choices

Sometimes you get what you pay for

...but you are always free to fix it yourself!

Developing
Releasing Code for Research
All your code is in a backed up in a repository,
right?
If not you need to do that today!
Bitbucket and github offer free private
repositories for academics (.edu email address)

When you submit a paper, tag your code in your

repository!
can easily replicate your results
New collaborators will know exactly what
you did when it worked!
Also easy to make a "demo" branch
Documentation
Structured information in package.xml files

Gets scraped from registered repositories and updated on wiki:

http://wiki.ros.org

Can automatically generate documentation from doxygen too

Other People's Code
Lots of sources When should you use it, when should
you write your own?
Labmates' code

Other labs

code from class

Why you may want it

To compare to your method

To help you build your system

The Architecture
ROS Architecture
First, there are really good tutorials on this you can check out here:

http://wiki.ros.org/ROS/Tutorials

And there are a list of more resources on the course website:

http://www.coe.utah.edu/~cs7939/ros_tips.html
ROS Components: interprocess communication (IPC)
Nodes - processes on the system (registered with the ROS master node)
Topics - publish-subscribe communication (TCP/IP usually...)

cam_image arm_pose
Camera Arm Tracker Control
Node Node Policy Node

joint_cmd
cur_joint_state

Joint Arm
Encoder Controller
Node Node
Nodes
Primary construct in ROS

Each node is a separate executable

Creates distributed processes for performing some "atomic" processing

Can range from

very simple (e.g repackage some data stream into a more useful data type)

to very complex (e.g. take visual data, extract features, plan a desired task
space trajectory, perform feedback control to track the trajectory)
Topics and Messages
Topics
transport strongly-typed messages between nodes
publishers publish to a named topic (e.g. joint_state)
subscribers subscribe to a topic
can have multiple publishers or subscribers on the
same topic
Beer
Detector
Node

Camera cam_image
Node
Obstacle
Avoidance
Node
Messages
Messages
typed structures (specified in a txt file)
built from primitive types
hierarchical structure can get complicated
standard header: time, seq, frame_id

Standard Message types

geometry - Point, Pose, PoseStamped,...
perception - PointCloud2, Image, Camera,
control - JointState,
Defining a New Message
Easily defined in text files Example.msg Accessing data in python:

Abstract form: from example_pkg.msg import *

msg_obj = Example()
fieldtype1 fieldname msg_obj.object_name = "Coffee Mug"
fieldtype2 fieldname ...

Example:

string object_name
int object_height
geometry_msgs/Pose object_pose

Also supports arrays (fixed and variable length)

Services
Services are request-reply blocking communications between nodes:
node_1 sends a request message to node_2
node_1 waits
node_2 performs some computation based on the request and sends a
response message back to node_1
node_1 receives the result and continues processing
E.g.
exp1_node sets up all necessary conditions to run an experiment
exp1_node sends a service request to move the robot spine to the correct
height
exp1_node then sends a request to start the experiment using your feedback
controller
Service files
*.srv instead of *.msg

Format:

field1 req1
field2 req2
---
field3 res1
field4 res2
Parameter Server
Shared dictionary of variables between all nodes

Nodes can store and retrieve parameter values at runtime

Primarily used for static value parameter setting

Not optimized for real-time or large data performance

ROS Master Node
"The ROS Master provides naming and registration services
to the rest of the nodes in the ROS system. It tracks
publishers and subscribers to topics as well as services. The
role of the Master is to enable individual ROS nodes to locate
one another. Once these nodes have located each other they
communicate with each other peer-to-peer.

The Master also provides the Parameter Server."

Actionlib
More advanced Finite State Machine interactions
Gives more control than simple services
...but requires much more specification and care in implementing.
Gives feedback during execution (can track progress to goal)
Can update input during execution as well
Review
Nodes - processes for performing computation

Topics - send messages between nodes

Publishers and Subscribers - communicate over common topics

Services - message passing which blocks until the receiving node finishes and
returns a result

Parameters - can be got or set at anytime from the parameter server

Launch files - files for organizing complicated structures of the above

Review: ROS Components
Nodes - processes on the system (registered with the ROS master node)
Topics - publish-subscribe communication (TCP/IP usually...)

cam_image arm_pose
Camera Arm Tracker Control
Node Node Policy Node

joint_cmd
cur_joint_state
Parameter Server:
"jakes_g" = 9.7 Joint Arm
"/left_arm/joint0/init_pos" = Encoder Controller
0.2 Node Node
...
Using ROS
Setting up an environment
Can easily install packages in Ubuntu via apt

Need to set certain environmental variables to access command line tools and
navigate the ROS system easily.

These environment variables can get complicated for large projects or many
projects that are switched between. Some tools to help with this, but can get
confusing quickly.

This is where the tutorials & documentation online are better than what I can
offer
Command line tools
Has many tools for interacting with the system:
roscd - easily navigate to different ros packages
> roscd beer_detector_pkg
rosrun - run ROS nodes in other directories from an arbitrary path
> rosrun beer_detector_pkg beer_detector_node.py
roscore - creates the ROS master as well as parameter server and ros output
aggregator
NEEDS TO BE RUN BEFORE RUNNING ROS NODES!
rostopic - get info on current topics running
rosmsg - look up information about available ROS messages (e.g. hz, echo, )
And many others...
Launch Files...make your life easier!
XML files for specifying:

nodes to launch and their unique names

topic names and who subscribes and publishes to them

parameter values to set on the parameter server

Automatically launches roscore, so you don't have to

Can include other launch files

Are your best friend in setting up complicated systems

TF
Transform Library

Gives easy access to kinematic and

dynamic transformations between different
reference frames

Just need to specify robot & environment

structure and publish / update joint states

Remember all sensor messages should be

stamped with frame and time, so can easily
reproduce
URDF - Universal Robot Description Format
XML file describing robot links, joints, motors

Joints:
Revolute
Prismatic
Fixed - allows for adding arbitrary reference frames

Must be tree structure - no parallel robots

Geometry:
Can define separate visual and (simpler) collision geometries
URDF: Example
rosbag: Logging and Replaying Data
Collects data published over different topics

By default you can log everything

Can also just log some data (e.g. camera info and joint states)

Can then playback data as if they are publishers

Helpful in developing and tuning code that requires data to perform

Can be used for diagnostic data collection

Helpful in debugging strange behavior on robots

Conclusions
1. Backup your code in a structured way
2. Document your code
3. Write modular, reusable software
4. Leverage existing software

Bitbucket or github for 1

ROS helps with 2-4