Implement coroutine-based Python nodes.

Author: kylc

python_examples/btpy.py

@@ -23,3 +23,44 @@ def specify_ports(cls):
         return cls
 
     return specify_ports
+
+
+class AsyncActionNode(StatefulActionNode):
+    """An abstract action node implemented via cooperative multitasking.
+
+    Subclasses must implement the `run()` method as a generator.  Optionally,
+    this method can return a final `NodeStatus` value to indicate its exit
+    condition.
+
+    Note:
+        It is the responsibility of the action author to not block the main
+        behavior tree loop with long-running tasks. `yield` calls should be
+        placed whenever a pause is appropriate.
+    """
+
+    def __init__(self, name, config):
+        super().__init__(name, config)
+
+    def on_start(self):
+        self.coroutine = self.run()
+        return NodeStatus.RUNNING
+
+    def on_running(self):
+        # The library logic should never allow this to happen, but users can
+        # still manually call `on_running` without an associated `on_start`
+        # call. Make sure to print a useful error when this happens.
+        if self.coroutine is None:
+            raise "AsyncActionNode run without starting"
+
+        # Resume the coroutine (generator). As long as the generator is not
+        # exhausted, keep this action in the RUNNING state.
+        try:
+            next(self.coroutine)
+            return NodeStatus.RUNNING
+        except StopIteration as e:
+            # If the action returns a status then propagate it upwards.
+            if e.value is not None:
+                return e.value
+            # Otherwise, just assume the action finished successfully.
+            else:
+                return NodeStatus.SUCCESS

python_examples/ex06_async_nodes.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+
+"""
+Demonstration of an asynchronous action node implemented conveniently as a
+Python coroutine. This enables simple synchronous code to be written in place of
+complex asynchronous state machines.
+"""
+
+import time
+import numpy as np
+from btpy import (
+    AsyncActionNode,
+    BehaviorTreeFactory,
+    SyncActionNode,
+    NodeStatus,
+    ports,
+)
+
+
+xml_text = """
+ <root BTCPP_format="4" >
+
+     <BehaviorTree ID="MainTree">
+        <ReactiveSequence name="root">
+            <Print value="{command}" />
+            <MyAsyncNode start="[0.1, -0.2]" goal="[-0.6, 0.3]" command="{command}" />
+        </ReactiveSequence>
+     </BehaviorTree>
+
+ </root>
+"""
+
+
+@ports(inputs=["start", "goal"], outputs=["command"])
+class MyAsyncNode(AsyncActionNode):
+    def run(self):
+        start = np.asarray(self.get_input("start"))
+        goal = np.asarray(self.get_input("goal"))
+
+        for t in np.linspace(0.0, 1.0, num=10):
+            command = (1.0 - t) * start + t * goal
+            self.set_output("command", command)
+            yield
+
+        print("Trajectory finished!")
+
+        return NodeStatus.SUCCESS
+
+    def on_halted(self):
+        print("Aborted")
+
+
+@ports(inputs=["value"])
+class Print(SyncActionNode):
+    def tick(self):
+        value = self.get_input("value")
+        if value is not None:
+            print(value)
+        return NodeStatus.SUCCESS
+
+
+factory = BehaviorTreeFactory()
+factory.register(MyAsyncNode)
+factory.register(Print)
+
+tree = factory.create_tree_from_text(xml_text)
+tree.tick_while_running()