PowerPoint Presentation

Robot Operating System

Spring 2014

Alec Poitzsch

MIT EECS MEng Student (B.Sc 13)

1

Topics

Bridging the gap from simple to complex robotics

Introduction to ROS

ROS Software Development

ROS in 6.141

Bridging the gap fromsimple to complex robotics

RSS Robot Hardware Lab 2

Actuators:

Motors

Sensors:

Encoders

RSS Robot Software Lab 2

translate();

rotate();

RobotPositionController.java

Chassis.java

totalTicks, totalTime, sampleTime

???

publish

subscribe

RSS Robot Software Lab 2

OdometryRobot.java

updateAndControl();

RobotPositionController.java

controlStep();

Problems with this implementation

Single pipeline bottleneck

This is an architecture only suitable for simple systems.

Hardware

RobotBase.java

Software

publish

publish

subscribe

subscribe

We will need an architecture which can support more complex hardware and software components.

Goal: Develop big software for robots

Challenges encountered in robotics

The world is asynchronous

Robots must manage significant complexity

Robot hardware requires abstraction

Most of the robots in the video were doing multiple tasks at the same time.

Navigating towards a goal, while checking for obstacle avoidance; reading encoder information etc.

Reading camera information, sensor information for autonomy

- As a roboticist, work on a single field in which youre trying to be an expert in.

- Most of the components as the robots get bigger need to be abstracted away in order for your code to work

9

Problem 1: Sequential Programming

Lab 2 and conventional programming form:

goForward(1);

turnLeft(Math.PI/2);

Image image = camera.getImage();

double distance = computeDistanceToObject(image);

goForward(distance - 1);

(x, y) = getMyPositionFromTheEncoderCounts();

What happens if an obstacle appears while you are going forward?

What happens to the encoder data while you are turning?

What if some other module wants the same data?

Solution 1: Callbacks

Callback:

Function which is called whenever data is available for processing.

An asynchronous callback can happen at any time.

Examples:

Run the relevant callback function whenever:

An image is read from the camera

The odometry sensor reports new data

void imageCallback(ImageMessage image)

// process the latest image

void odometryCallback(OdometryMessage data)

// handle latest odometry data

void main()initialize();

subscribe(image_msgs, imageCallback);

subscribe(odometry_msgs, odometryCallback);

Problem 2: ComplexitySolution 2: Organizing code

Separate processes: Cameras, Odometry, Laser Scanner, Map Building can all be separated out: theyll interact through an interface

Interfaces: Software processes (nodes in ROS) communicate about shared topics in ROS

Publish/Subscribe: Have each module receive only the data (messages) it requests

12

Camera

Face Detection

Image Message

Obstacle Detection

Image Message

Laser Scanner

PointCloud

Map Building

Obstacle

Topic: /camera/image

Topic: /kinect/cloud

Message passing = Interface

Nodes: Sensors/Algorithms/High-level algorithms

Edges: Topics sent across for communication

12

Problem 3: Hardware dependent codeSolution 3: Abstracting hardware

Camera

Face Detection

Obstacle Detection

Image Message

Laser Scanner

PointCloud

Map Building

Obstacle

Image Message

Hardware-Independent Software

Device-Specific Drivers

Interface

PointCloud

Motors

Etc.

Can also mention the fact that we want code to be agnostic to thetype of hardware our code is running on top of -- both at driverlevel, and at morphology level.

Nodes: can be hardware independent or hardware-specific

Segway: Youve built your robot, how to make it work for these (next slide)

13

Result: Reusable code!

PR2 Roomba Care-O-bot 3

MIT Urban Challenge Vehicle

Summary

We want:

Callbacks

Separate processes that communicate through a messaging interface

A messaging interface that helps avoid hardware dependencies

Theres a software infrastructure out there that enables this (among many other things), and its called ROS.

Introduction to ROS

A meta-operating system for robots

Comparison: the PC ecosystem

Standardized layers

System software abstracts hardware

Applications leverage other applications (such as database, web server).

Widely existent sets of libraries

Applications

Application building blocks

System software

Hardware

Comparison: the robotics ecosystem

Applications

Application building blocks

System software

Hardware

Applications

ROS

Hardware

What is ROS?

A Meta Operating System.

Open source

Runs in Linux (esp. Ubuntu)

Ongoing Windows implementation

Agent based (nodes)

Message passing

Publish

Subscribe

Services via remote invocation

Supports numerous programming languages (C++, Python, Lisp, Java)

What is ROS?

Low level device abstraction

Joystick

GPS

Camera

Controllers

Laser Scanners

Application building blocks

Coordinate system transforms

Visualization tools

Debugging tools

Robust navigation stack (SLAM with loop closure)

Arm path planning

Object recognition

...

Application building blocks

System software

ROS

What is ROS?

Software management (compiling, packaging)

Remote communication and control

What is ROS?

Founded by Willow Garage

Exponential adoption

Countless commercial, hobby, and academic robots use ROS (http://wiki.ros.org/Robots)

What is ROS?

Software basis of Willow Labss PR2

ROS Philosophical goals

Hardware agnosticism

Peer to peer

Tools based software design

Multiple language support (C++/Java/Python)

Lightweight: runs only at the edge of your modules

Free

Open source

Suitable for large scale research and industry

ROS software development

Conceptual levels of design

29

Node 1

Laser Scanning

Node 2:Map Building

Node 3:Planning

(C) File-system level: ROS Tools for managing source code, build instructions, and message definitions.

Node 4

(B) Computation Graph: Peer-to-Peer Network of

ROS nodes (processes).

Node 5

Node 6

Node7

Carnegie Mellon

(A) ROS Community: ROS Distributions, Repositories

(A) Community Level: Resources that enable separate communities to exchange software:(i) ROS Distributions (ii) Code Repositories (Willow Garage, MIT) (iii) Wiki

(B) Computation Graph Level: Peer-to-Peer network of ROS processing that are processing sensor data and doing other computations. Nodes can be distributed across machines

(C) Filesystem Level: Ros has lots of tools for (i) organizing source code (ii) simplifying build instructions / dependencies (iii) Managing message definitions

29

Tools-based software design

Tools for:

Building ROS nodes

Running ROS nodes

Viewing network topology

Monitoring network traffic

Many cooperating processes, instead of a single monolithic program.

(A) No Monolithic Runtime Environment(B) Small tools for building + running ros nodes: visualizing network topology, measuring bandwidth utilization, plotting.

30

Multiple language support

ROS is implemented natively in each language.

Quickly define messages in language-independent format.

Python Node:

Laser Scanner

C++ Node : Map Building

Topic: LaserData

Publication

Subscription

Header header

Points32[] pointsXYZ

int32 numPoints

File: PointCloud.msg

File-system level

(A) ROS implemented natively in each target langauge.(B) Language-independent Interface Definition Language (IDL) for defining messages:

31

Lightweight

Encourages standalone libraries with no ROS dependencies:

Dont put ROS dependencies in the core of your algorithm!

Use ROS only at the edges of your interconnected software modules: Downstream/Upstream interface

ROS re-uses code from a variety of projects:

OpenCV : Computer Vision Library

Point Cloud Library (PCL) : 3D Data Processing

OpenRAVE : Motion Planning

Carnegie Mellon

ROS Community

Get downstream data, produce upstream data.

(A) Would like modules to be re-usable outside of ROS. Encourage all algorithm development to occur in standalone libraries w/ no dependencies on ROS. Dont put ROS in your algorithm.

(B) ROS re-uses code from a variety of projects: OpenCV, Point Cloud Library, OpenRAVE (ish). ROS just routing data in/out of respective software with as little wrapping as possible.

32

Peer to Peer Messaging

No Central Server through which all messages are routed.

Master service run on 1 machine for name registration + lookup

Messaging Types:

Topics : Asynchronous data streaming

Parameter Server

Computation Graph

The ROS runtime "graph" is a peer-to-peer network of processes.

No Central Server: Contrast w/ central-server-based Carmen: Consider the case of running robot w/ off-board compute-intensive tasks. If we run a central server offboard (or even onboard: go thru both cases) this results in unnecessary traffic across (slow) wireless link: many message routes are fully contained in subnets either onboard or offboard. Peer-to-peer connectivity avoid this issue

Master : DNS / name service : register + find nodes. Nodes connect to other nodes directly; the Master only provides lookup information, much like a DNS server. Nodes that subscribe to a topic will request connections from nodes that publish that topic, and will establish that connection over an agreed upon connection protocol. The most common protocol used in a ROS is called TCPROS, which uses standard TCP/IP sockets.

Styles of communication: *Asynchronous streaming of data over topics, and storage of data on a Parameter Server. 3rd type: synchronous RPC-style communication over services we dont really use

33

Peer to Peer Messaging

Master: Lookup information, think DNS

roscore command starts master, parameter server, logging

Publish: Will not block until receipt, messages get queued.

Delivery Guarantees: Specify a queue size for publishers: If publishing too quickly, will buffer a maximum of X messages before throwing away old ones

Transport Mechanism: TCPROS, uses TCP/IP

Bandwidth: Consider where your datas going, and how

Computation Graph

TCPROS is a transport layer for ROSMessagesandServices. It uses standard TCP/IP sockets for transporting message data. Inbound connections are received via a TCP Server Socket with a header containing message data type and routing information.

34

Free & Open Source

BSD License : Can develop commercial applications

Drivers (Kinect and others)

Perception, Planning, Control libraries

MIT ROS Packages : Kinect Demos, etc

Interfaces to other libraries: OpenCV, etc

ROS Debugging

36

Shutdown Object node re-compile restart : wont disturb system

Logging (VIDEO)

Kinect Driver

Object Recognition

Laser Scanner

Logger

Object Recognition

Logger Playback

Playback (VIDEO)

Editing Software: Say you want to debug 1 node in a large 20-node system. You can start all 20 nodes. Then if you want to change the 1 node youre interested in: you can shut it down while leaving the other 19 running. You can re-code, re-compile, and re-launch that node. The ros infrastructure (graph / master name registration) will automatically adapt to nodes dropping out / activating.

(B) Logging: Can dump any message stream to disk without modifying source code.

Logging/Playback: Recall your simulation environment in Labs

36

Useful ROS Debugging Tools

rostopic: Display debug information about ROS topics: publishers, subscribers, publishing rate, and message content.

rostopic echo [topic name] prints messages to console

rostopic list prints active topics

(several more commands)

rxplot : Plot data from one or more ROS topic fields using matplotlib.

rxplot /turtle1/pose/x,/turtle1/pose/y graph data from 2 topics in 1 plot

Rxplot: Rotation angle of the wheels/ Encoder reading

Rostopic: What if you dont know if your encoders are being read correctly, or if your motor died ( how does the robot know it is not responding )

DEBUGGING tools

37

rosbag

Useful ROS Debugging Tools

rxgraph

ROS Visualization

Visualize:

Sensor data

Robot joint states

Coordinate frames

Maps being built

Debugging 3D markers

VIDEO

(A) rviz (demo): tap into any message stream and visualize (if plugin available)Demo will show visualization of point clouds, robot joint states, coordinate frames, user-added markers

40

rviz

ROS Transformations

TF = Name of Transform package

Tully Foote == Person/Developer

TF Handles transforms between coordinate

frames : space + time

tf_echo : print updated transforms in console

Example:

rosrun tf tf_echo [reference_frame] [target_frame]

Packages

Perception

Point Cloud Library (PCL)

OpenCV

Kinect/OpenNI

ROS in 6.141

Reconciling Lab 2 with ROS

uorc_publisher

uorc_listener

Orcboard

/rss_msgs/EncoderMsg

/rss_msgs/MotionMsg

45

Reconciling Lab 2 with ROS

uorc_publisher

uorc_listener

/rss_msgs/EncoderMsg

/rss_msgs/MotionMsg

Your code

46

Reconciling Lab 2 with ROS

uorc_publisher

uorc_listener

/rss_msgs/EncoderMsg

/rss_msgs/MotionMsg

Your code

Orcboard

/rss_msgs/EncoderMsg

/rss_msgs/MotionMsg

47

Peer to Peer

Workstation

Netbook

ROS code enviroment

Since our codebase is in JAVA, we use rosjava.

roscore launch ROS host on netbook

rosmake build a package (formerly ant)

roslaunch lab4 lab4.launch launch package (formerly ant run)

*.launch file specifies additional parameters

Lab 3 ROS and Visual Servoing

publish

Topic: /rss/video

Your code

subscribe

Lab 3 will contain a comprehensive overview of ROS

ROS Resources

http://www.ros.org

http://wiki.ros.org

ROS Cheatsheet: http://www.tedusar.eu/files/summerschool2013/ROScheatsheet.pdf

Thank you!