Merge branch 'feature/SmoothingRefactor' of https://github.com/personalrobotics/prpy into feature/SmoothingRefactor

Author: jeking04

README.md

@@ -303,6 +303,38 @@ resolve multiple objects in one statement:
 ```
 
 
+## Concurrent Execution
+
+PrPy has native support for [futures](http://en.wikipedia.org/wiki/Futures_and_promises) and
+[coroutines](http://en.wikipedia.org/wiki/Coroutine) to simplify concurrent programming. A
+_future_ encapsulates the execution of a long-running task. We use the concurrency primitives
+provided by the [`trollius` module](http://trollius.readthedocs.org/en/latest/using.html),
+which is a Python 2 backport of the [`asyncio` module](https://docs.python.org/3/library/asyncio.html)
+from Python 3.
+
+We can use these primitives to parallelize planning and execution:
+
+```python
+@coroutine
+def do_plan(robot):
+    # Plan to goal1 and start executing the trajectory.
+    path1 = yield From(robot.PlanToEndEffectorPose(goal1, execute=False))
+    exec1_future = robot.ExecutePath(path1)
+    
+    # Plan from goal1 to goal2.
+    robot.SetDOFValues(GetLastWaypoint(path1))
+    path2 = yield From(robot.PlanToEndEffectorPope(goal2, execute=False))
+    
+    # Wait for path1 to finish executing, then execute path2.
+    exec1 = yield From(exec1_future)
+    exec2 = yield From(robot.ExecutePath(path2))
+    
+    raise Return(path1, path2)
+
+loop = trollius.get_event_loop()
+path = loop.run_until_complete(do_plan(robot))
+```
+
 ## Method Binding
 
 Finally, PrPy offers helper functions for binding custom methods on (i.e.