IEEE Robotics & Automation Magazine - September 2018 - 53

Passing a memory key as an argument to a branch is in
many respects similar to passing a pointer to a function in the
C++ programming language. During runtime, the code related to the targeted branches may use the key to query the
memory and use the extracted information for self-reconfiguration. As schemes may be pushed and pulled to and from the
memory at high frequencies, this may result in efficient sensory-motor couplings.
In the background, data exchange relies exclusively on
pull/push calls. But in effect, the targeting keyword
results in a flow of information from the memory to all nodes
and evaluations corresponding to the targeted branch. Via the
targeting keyword, these information flows are only
implied by the programmer and implemented transparently
by the system at runtime.
Targeting is Playful's less intuitive concept. It is based on
the triggering system, which we previously implemented in
TDM [5], here extended to behavior trees. For details related
to shared memory, the pull/push data exchange paradigm,
and encapsulation of data into schemes, we invite the reader
to consult [6]. We provide concrete instances in the "Examples" section.
Formal Syntax
Playful's syntax is formally presented in Algorithm 1. Items in
parentheses refer to content that has to be specified by the
developer, and items in brackets indicate optional content. In
bold are the supported statement keywords. Evaluations are
functions that should either return a Boolean (when associated
with whenever or if) or a float (when associated with priority of). A node is defined as a list of nodes associated
with keywords for dynamic reconfiguration and exchange of
memory keys (targeting), evaluations for setting rules of
activation (whenever, switch to), and rules of prioritization (priority of). Leaf nodes are instances of Python
objects, which interact with the middleware. Higher levels of
the tree encode the logic that monitors the leaf nodes' activation
status. They do so through evaluations and resource management (e.g., forbidding two leaf nodes from simultaneously controlling the same robot joints). If no evaluation is used and no
resource conflict is detected, each leaf node runs continuously,
concurrent with all of the other running leaf nodes.
The activation status of a node propagates to all of the
nodes of its subtree, including the leaf nodes. If a given node

is deactivated, all of the nodes in its subtrees are deactivated. If
a node is activated, the monitoring of the activation status of
its underlying nodes is delegated to their evaluations. Thus, a
change in the activation status of a node in the tree implies a
change in the pattern of activation of its underlying leaf
nodes. And because leaf nodes interface with the middleware,
a change in the patterns of activation of the leaf nodes shapes
the behavior performed by the robot.
Python for Evaluations and Leaf Nodes
Evaluations and leaf nodes are to be programmed using
the Python scripting language. Evaluations can be any
arbitrary Python statement that evaluates to either a Boolean (when associated with the keywords whenever or
if ) or a float (when connected with priority to ).
The Playful interpreter also supports simple logic and
arithmetic. For example, an evaluation may consist of the
negation of a Python function (keyword not) or the addition of a function with a number. Leaf nodes correspond
to Python objects, which must implement the specific
interface required for communication with the Playful
engine (e.g., it must implement a run function). Leaf
nodes may be considered our platform's primitives, and
the behavior tree the encoding of the logic used to orchestrate their activation during runtime. Each leaf node is
spawned in a dedicated thread running at its dedicated frequency. Playful provides an API for receiving start or stop
commands from the engine, accessing the shared memory,
and reserving or releasing resources.
Playful's Back End
The scripting language is the front end of the Playful software
platform, which is completed by the engine back end. The latter consists of two parts. First, there is the interpreter, which
creates the behavior tree and relates nodes and evaluations to
their corresponding Python code. Second, there is the engine,
which at runtime
● instantiates new branches when the memory is updated
with a new key, according to the usage of the targeting
keyword
● calls evaluations code, i.e., branches that are conditionally
evaluated as false (whenever keyword) or as not active
(switch to keyword) are sent signals to deactivate;
other nodes are sent signals to activate

Algorithm 1:
(node name):
[
[targeting (memory key):](node name)[, whenever (evaluation)][, priority of
(evaluation) if (evaluation), [...]][, switch to (node name)
if (evaluation), [...]]
[...]
]

september 2018

*

IEEE ROBOTICS & AUTOMATION MAGAZINE

*

53
IEEE Robotics & Automation Magazine - September 2018

Table of Contents for the Digital Edition of IEEE Robotics & Automation Magazine - September 2018
