Analysis and Exploitation of Synchronized Parallel Executions in Behavior Trees

TL;DR

This paper introduces synchronization techniques for parallel behavior tree compositions to improve predictability and performance, supported by experiments on a robot demonstrating practical benefits.

Contribution

It proposes novel synchronization methods for parallel behavior trees and evaluates their impact on predictability and performance through experimental validation.

Findings

Synchronization techniques enhance behavior predictability.

Design choices significantly affect execution performance.

Experimental results validate the proposed methods on a robot platform.

Abstract

Behavior Trees (BTs) are becoming a popular tool to model the behaviors of autonomous agents in the computer game and the robotics industry. One of the key advantages of BTs lies in their composability, where complex behaviors can be built by composing simpler ones. The parallel composition is the one with the highest potential since the complexity of composing pre-existing behaviors in parallel is much lower than the one needed using classical control architectures as finite state machines. However, the parallel composition is rarely used due to the underlying concurrency problems that are similar to the ones faced in concurrent programming. In this paper, we define two synchronization techniques to tackle the concurrency problems in BTs compositions and we show how to exploit them to improve behavior predictability. Also, we introduce measures to assess execution performance, and we show how design choices can affect them. To illustrate the proposed framework, we provide a set of experiments using the R1 robot and we gather statistically-significant data.

Equations

$${\mathcal{T}}_i=\{f_i,r_i,\Delta t\},$$

$$x_{k+1}$$

$$t_{k+1}$$

$$\{x\in {\mathbb{R}}^n:\underset{s\in S_1}{\inf }||x-s||\le d\}\subset I.$$

$$\pi (k_1,k_2)\triangleq \sum _{k=k_1}^{k_2}\sum _{i=1}^N\sum _{j=1}^N\frac{|p_i(x_k)-p_j(x_k)|}{2}$$

$$P(\bar{p})\triangleq mean(T^{\bar{p}})-{\bar{t}}_k$$

$$p_i(x_k)=\{\begin{array}{ll}0& \text{ if }k=0\\ p_i(x_{k-1})+{\alpha }_i+{\omega }_i(x_k),& \text{otherwise}\end{array}$$

$$p_1(x_k)=\{\begin{array}{ll}0& \text{ if }k=0\\ p_1(x_{k-1})+0.1,& \text{otherwise}\end{array}$$

$$p_2(x_k)=\{\begin{array}{ll}0& \text{ if }k=0\\ p_2(x_{k-1})+2+{\omega }_i(x_k),& \text{otherwise}\end{array}$$

Full text

In this paper, we define two synchronization techniques to tackle the concurrency problems in BTs compositions and we show how to exploit them to improve behavior predictability. Also, we introduce measures to assess execution performance, and we show how the design choices can affect them.

To illustrate the proposed framework, we provide a set of experiments using the R1 robot and we gather statistically-significant data.

I Introduction

Modeling robot’s behaviors using Behavior Trees (BTs) is becoming an appreciated practice. Applications span from manipulation [1, 2] to non-expert programming [3, 4, 5]. Other works include task planning [6], learning [7, 8, 9], and UAV systems [10, 11]. Using BTs, the designer creates robots behaviors by composing together actions and condition in a hierarchical fashion. There are different ways to create such compositions, each with its own semantic. A very powerful composition is the parallel one, where the designer can easily encode the concurrent execution of several sub-behaviors. Unfortunately, the parallel composition is the least used composition due to its underlying concurrency problems [12, 13, 14].

In this paper, we show how recent advances in BT compositions allow extending the use of BTs to those applications that either requires synchronized concurrent actions or predictable execution times.

The choice of using BTs to model robot behaviors is often driven by the fact that BTs are modular, flexible, and reusable [12]. Moreover, they have also been shown to generalize successful robot control architectures such as the Subsumption Architecture [15] and the Teleo-Reactive Paradigm [12]. Using BTs, the designer can compose simple behaviors using the so-called control flow nodes. The most common control flow nodes, which will be described in this paper, are Sequence, Fallback, and Parallel. The parallel execution of independent behaviors can arise several concurrency problems in any modeling language and BTs are no exception. However, the parallel composition of BTs is less sensitive to dimensionality problems than a classical finite state machine [12].

Real robots often require to execute behaviors concurrently, for efficiency or constraints satisfaction, as we will show in this paper. The presence of concurrent behaviors requires to face the same issues affecting concurrent programming. The solutions adopted in concurrent programming made a tremendous impact on software development, increasing their applicability and performance to the scale that it is now a common practice in modern software.

Another issue faced in computer programming is predictability. Predictability is required in applications with safety-critical constraints. Similarly, we desire robots with predictable behaviors, especially at the developing stage, where actions may run with a different speed in the real world and in a simulation environment. Increasing predictability reduces the difference between simulated and real-world robots execution.

Concurrent behaviors are also well studied in the Human-Robot Interaction (HRI) community, where they show evidence of more “believable” robots’ behaviors in the presence of coordinated movements [16] (e.g. the robot moves the arm to point at an object while moving the head to look at it.), coordinated robots and human movements [17], and coordinated gestures and diaogues [18].

In our recent work [13], we partially addressed the aforementioned issues by defining Concurrent BTs, where nodes expose information regarding progress and resource used and allow actions to have progress that depends on each other. In this paper, we extend our previous work by discriminating between absolute and relative synchronization techniques and show how we can exploit such synchronizations to improve behavior predictability. In addition, we introduce measures to assess execution performance and show how design choices affect them.

The remainder of this paper is structured as follows: In Section II we overview the related work. In Section III we present the background. Then, in Section IV, we formulate two different synchronization techniques to coordinate actions and increase behavior predictability. In Section V we show the proposed performance measure and analyze their dependency on design choices. In Section VI, we provide an experimental evaluation with different use cases. We conclude the paper in Section VII.

II Related Work

The parallel composition has found relatively little use, compared to the other compositions, due to the intrinsic concurrency issues similar to the ones of computer programming such as race conditions and deadlocks. Current applications that make use of the parallel composition assume either that the BTs executed in parallel lie on orthogonal state spaces [19, 1] or the that BTs executed in parallel have a predefined priority assigned [20] where, in conflict situations, it is executed only the BT with the highest priority. Other applications impose a mutual exclusion of actions in BTs that are executed in parallel if they have potential conflicts (e.g. sending commands to the same actuator) [12] or they assume that BTs that are executed in parallel are not in conflict by design.

The parallel composition found large use in the BT-based task planner A Behavior Language (ABL) [21] and in its further developments. ABL was originally designed for the game Façade, and it has received attention for its ability to handle planning and acting at different deliberation layers, in particular, in Real-Time Strategy games [20]. ABL executes sub-BTs in parallel and resolves conflicts between multiple concurrent actions by defining a fixed priority order. This solution threatens the reusability and modularity of BTs and introduces the risk of starvation (i.e. the execution of an action with low priority may be perpetually denied to execute an action with higher priority).

The parallel composition found use also in multi-robot applications [22] where a single robot BT is extended to a so-called multi-robot BT, resulting in improved fault tolerance and other performances. The parallel node involves multiple robots, each assigned to a specific task using a task-assignment algorithm. The task-assignment algorithm ensures the absence of conflicts.

None of the work above addressed properly the synchronization issues that arise when using a parallel BT node.

A recent work [14] proposed BTs for executing actions in parallel, even when they lie on the same state space (e.g. they use the same robot arm). The coordination mechanism is conducted by activating and deactivating motion primitives based on their conditions. Such framework avoids that more actions access a critical resource concurrently. In our work, we are interested in synchronizing the progress of actions that can be executed concurrently.

In our recent work [13], we address the aforementioned issue by defining BT nodes that expose information regarding progress and resource uses. We also defined a relative synchronized parallel BT node execution and we provided theoretical validation of the proposed nodes. In this paper, we extend our previous work by defining absolute relative synchronization and we define and study their performance.

To conclude, there is currently no work in exploiting and analyzing the performance of the synchronized parallel node. This makes our paper fundamentally different than the ones presented above and the BT literature.

III Background

In this section, we briefly present the classical formulation of BTs and we introduce the concepts for synchronization barriers and predictability. A more detailed description of BTs is available in [12] while a more detailed description of concurrent programming is available in [23].

III-A Behavior Trees

A BT is a graphical modeling language used as a representation for actions orchestration. A BT is as a directed rooted tree where the internal nodes represent behavior compositions and leaf nodes represent actuation or sensing operations.

The children of a BT node are placed below it, as in Figure 5(a), and they are executed in the order from left to right. The execution of a BT begins from the root node. It sends ticks, which are activation signals, with a given frequency to its children. A node in the tree is executed if and only if it receives ticks. When the node no longer receives ticks, its execution is aborted. The child returns to the parent a status, which can be either Success, Running, or Failure according to the node’s logic. Below we present the most common BT nodes and their logic.

Fallback

When a Fallback node receives ticks, it sends ticks to its own children in order from the left. It returns a status of Success or Running whenever it finds a child that returns Success or Running respectively. It returns Failure whenever all the children return Failure. When a child returns Running or Success, the Fallback node does not send ticks to the next child (if any). The Fallback node is represented by a square with the label “$?$”, as in Figure 5(a).

Sequence

When a Sequence node receives ticks, it sends ticks to its own children in order from the left. It returns Failure or Running whenever it finds a child that returns Failure or Running respectively. It returns Success whenever all the children return Success. When a child returns Running or Failure, the Sequence node does not send ticks to the next child (if any). The Sequence node is graphically represented by a square with the label “$\rightarrow$”, as in Figure 5(a).

Parallel

The Parallel node sends ticks to all its children. It returns Success if all children return Success, it returns Failure if at least one child returns Failure, and it returns Running otherwise. The parallel node is graphically represented by a square with the label “$\rightrightarrows$”.

Action

Whenever an Action node receives ticks, it performs some operations. It returns Success whenever the operations are completed and Failure if the operations cannot be completed. It returns Running otherwise. When a running Action no longer receives ticks, its execution is aborted. An Action node is graphically represented by a rectangle, as in Figure 5(a).

Condition

Whenever a Condition node receives ticks, it checks if a proposition is satisfied or not. It returns Success or Failure accordingly. A Condition is graphically represented by an ellipse as in Figure 5(a).

The state-space formulation of BTs [12] was defined to study them from a mathematical standpoint. In that formulation, the tick is represented by a recursive function call that includes both the return status, the system dynamics, and the system state. This formulation allows us to define concepts of progress and safeguarding BTs, used in this paper.

Definition 1** (Behavior Tree [12])**

A BT is a three-tuple

[TABLE]

where $i\in\mathbb{N}$ is the index of the tree, $f_{i}:\mathbb{R}^{n}\rightarrow\mathbb{R}^{n}$ is the right hand side of a difference equation, $\Delta t$ is a time step and $r_{i}$ is the return status that can be equal to either Running, Success, or Failure. Finally, let $x_{k}=x(t_{k})$ be the system state at time $t_{k}$, then the execution of a BT $\mathcal{T}_{i}$ is described by the following equations:

[TABLE]

Definition 2** (Progress Function [13])**

The function $p:R^{n}\to[0,1]$ is the progress function. It indicates the progress of the BT’s execution at each state.

Definition 3** (Safeguarding [12])**

A BT is Safeguarding, with respect to the step length $d$, the obstacle region $O\subset\mathbb{R}^{n}$, and the initialization region $I\subset R$, if it is safe, and finite time successful with region of attraction $R^{\prime}\supset I$ [12] and a success region $S$ such that $I$ surrounds $S$ in the following sense:

[TABLE]

III-B Concurrent Programming

Concurrent programming deals with the execution of several concurrent processes that need to be synchronized to achieve a task or simply to avoid being in conflict with one another. The main uses of synchronization are producer-consumer relationship, where a consumer process has to wait until a producer provides the necessary data, and exclusive use of resources, where multiple processes have to use or access a critical resource and a correct synchronization strategy ensures that only one process at a time can access the resource [23]. The use of barriers is one popular way to implement correct synchronization strategies [23]. The use of barriers allows concurrent processes to wait for each other at a specific point of execution.

III-C Predictability

Predictability represents the ability to ensure the execution of an application without concern that outside factors will affect it in unpredictable ways. In other words, the application will behave as intended in terms of functionality, performance, and response time.

Predictability is highly appreciated in real-time systems. A real-time system must behave in a way that can be predicted in time to estimate the likelihood that a task can be completed before a given deadline.

IV Parallel Synchronization of BT

In this section, we present the first contribution of this paper. We extend our previous work on parallel synchronization of BTs [13] by introducing absolute and relative synchronized parallel nodes and we show how they can be used to synchronize actions with both durative (with a given duration and progress) and perpetual (without a given duration and progress) actions. Moreover, we show how to use these synchronization techniques to improve the predictability of the progress of a BT.

IV-A Absolute Synchronized Parallel Node

Absolute synchronization is achieved by setting, a-priori, a finite ordered set $\mathcal{B}$ of values for the progress. These values are used as barriers at the task level (see Section III-B). Whenever a node in this parallel composition has the progress equal to or greater than a progress barrier in $\mathcal{B}$ it no longer receives ticks until all the other nodes of the parallel composition have the progress equal to or greater than the value of that the barrier.

Algorithm 1 shows the pseudocode of the absolute synchronized parallel node. At each tick, the node first assesses the minimum progress of its children (Lines 2-3), then it finds, among the predefined barriers contained in $\mathcal{B}$, the current barrier (i.e. the barrier of smaller value that the progress of at least one child has not reached) (Lines 4-7). Then it sends ticks only to those actions whose progress did not exceed the value of the current barrier (Lines 8-10). Finally, it computes its return status (Lines 11-15). The absolute synchronized parallel node is graphically represented by a square with the label “$\rightrightarrows^{A}$”.

We now present a use case example for the absolute synchronized parallel node.

Example 1** (Door Pulling)**

A humanoid robot has to pull a door open. This task requires the synchronization of two actions, the arm movement to pull the door and the mobile base movement to make the robot move away from the door while this opens. To succeed in the task, the arm movement and the mobile base must be synchronized.

IV-B Relative Synchronized Parallel Node

Relative synchronization is achieved by setting a-priori a threshold value $\Delta\in[0,1]$. Whenever a node in this parallel composition has a progress that exceeds the minimum progress, among all the other nodes of the parallel composition, by $\Delta$, it no longer receives ticks.

Algorithm 2 shows the pseudocode of the relative synchronized parallel node. At each tick, the node first assesses the minimum progress of its children (Lines 2-4), then it sends ticks only to those actions whose progress did not exceeds the minimum progress by the predefined offset $\Delta$ (Lines 5-7). Finally, it computes its return status (Lines 8-12).

The relative synchronized parallel node is graphically represented by a square with the label “$\rightrightarrows^{R}$”.

We now present a use case example for the relative synchronized parallel node.

Example 2** (Relative)**

A service robot has to give directions to visitors of a museum. To make the robot’s motions look natural, whenever the robot gives a direction, it points with its arm to the direction while moving the head to such direction. The arm and head may require different times to perform the motion. By imposing a relative progress synchronization we avoid the unnatural behavior where the robot looks first to a direction and then points at it, or the other way round.

The relative synchronized parallel node can be used also to impose coordination between perpetual action, (i.e. an action that even in the ideal case, do not have a fixed duration, hence a progress profile), as in the following example.

Example 3** (Perpetual Actions)**

A service robot has to carry around different tools in a workshop and it uses a cart to carry them. This behavior can be described as the relative parallel BT composition of two actions: one for holding the cart straight, and one for navigation. While the robot is pushing the cart forwards, the cart may drift sideways, just like any ordinary cart. Since the navigation and manipulation actions are executed concurrently in two independent actions the robot may move too fast and the cart may drift away before the robot can align it. By setting the progress of both actions to $1$ whenever the error of, respectively, arm or base reference position is within a boundary and [math] otherwise, the base movements stops while the robot is aligning the cart.

We will present the implementation of the example above in Section VI.

Remark 1

Designing a single action that operates both arm and base represents an easier synchronized solution. However, creating the single action for composite behaviors reduces the reusability of single behaviors and the whole BT.

IV-C Improving Predictabity

Progress synchronization can be used to impose a given progress profile constraint. The idea is to define an artificial action with the desired progress profile (over time) defined a priori and putting it as a child of an absolute synchronized parallel node with the actions whose progress is to be constrained. However, since we are allowed to only stop actions (i.e. BTs have no means to speed up actions), we can only define such artificial action as the ideal upper bounds of the other actions progresses.

Example 4

An industrial robot has to perform several manipulation tasks. Depending on the tool used, the movements have to take different progress profile.

We will present the implementation of the example above in Section VI.

Remark 2

This type of progress-profile creation may become very useful at the developing stage, since the actions may run with a different speed in the real world and in a simulation environment. Improving predictability reduces the difference between simulated and real-world robots execution.

V Performance Analysis of Synchronized BTs

In this section, we present the second contribution of this paper. We define measures for the concurrent execution of BTs used to establish execution performance. We show measures for both progress synchronization and predictability. We also show how the design choices for relative and absolute parallel nodes affect the performance.

V-A Progress Synchronization Distance

Definition 4

The progress distance over a time window $[k_{1},k_{2}]$ for a parallel node with $N$ children is defined as:

[TABLE]

where $p_{i}\in[0,1]$ is the progress of the $i$-th child, as in Definition 2.

Intuitively, a small progress distance results in high performance for both relative and absolute nodes synchronization.

V-B Predictability Distance

A useful method to measure predictability is to set the desired progress value and compute the average variation from the expected and the true time instant in which the action has a progress that is closest to the desired one.111It could be the case that the progress is defined only at discrete points of execution. This measure can be used to assess the deviation from the ideal execution.

Definition 5

Let $\bar{p}\in[0,1]$ and $T^{\bar{p}}$ be the set of time instances $t_{k}$ such that $t_{k}=\operatorname*{\arg\!\min}{(p(x(t_{k}))-\bar{p})}$, collected by running a BT a finite number of times. The time predictability distance relative to progress $\bar{p}$ is defined as:

[TABLE]

where $\bar{t}_{k}$ is the time instance when $p(x(t_{k}))$ is expected to be equal to $\bar{p}$.

V-C Sensitivity Analysis

We are ready to show how the number of barriers in $\mathcal{B}$ (for absolute synchronization) and the threshold value $\Delta$ (for relative synchronization) affect the performance, computed using the measures defined in this section. For illustrative purposes, we define custom made actions with difference progress profiles. To collect statistically-significant data, we ran the BT of each example 1000 times and we use plot boxes to compactly show the minimum, the maximum, the median, and the interquartile range of the measures proposed.

V-C1 How the number of equidistant barriers affects the performance of absolute synchronization

We now present an example that highlights how the number of progress barriers in $\mathcal{B}$ affects the performance of absolute synchronization. In the example, we consider equidistant progress barriers.

Example 5

Let a BT $\mathcal{T}$ be an absolute parallel synchronization with the actions $\mathcal{A}_{1}$, $\mathcal{A}_{2}$, and $\mathcal{A}_{3}$ as children. The actions are such that the progress profile of each $\mathcal{A}_{i}$ holds Equation (7) below:

[TABLE]

with $\alpha_{i}$s for each action $\mathcal{A}_{i}$ as: $\alpha_{1}=1$, $\alpha_{2}=2$, and $\alpha_{3}=5$; $\omega_{i}(x_{k})\in[-\bar{\omega},\bar{\omega}]$ a number, sampled from an uniform distribution, in the interval $[-\bar{\omega},\bar{\omega}]$.

The model above describes an action whose progress evolves with a fixed value ($\alpha_{i}$) and with some noise ($\omega_{i}(x_{k})$), modeling possible uncertainties in the execution that affect the progress.

Figure 1 shows the results of running 1000 times the BT in Example 5 in different settings. We observe higher performance with a large number of barriers and smaller $\bar{\omega}$. This highlights that a higher number of barriers prevents the progress of the actions to differ from each other (see Algorithm 1 Line 5 and 9-10). Moreover, a larger $\bar{\omega}$ results in an higher increase in the progress between one tick and the next one, resulting in worse performance.

V-C2 How the threshold value affects the performance of relative synchronization

We now present an example that highlights how the value of $\Delta$ affects the performance of relative synchronization.

Example 6

Let a BT $\mathcal{T}$ be a relative parallel synchronization with the same actions of Example 5 as children. Figure 2 shows the results of running 1000 times the BT in Example 6 in different settings. We observe that the performance increases with a smaller $\Delta$ and decreases with a larger $\bar{\omega}$. This highlights that a smaller $\Delta$ prevents the progress of the actions to differ from each other (see Algorithm 2 Lines 3-7). Moreover, a larger $\bar{\omega}$ result in a higher possible difference in the progress of two actions between one tick and the next one, resulting in worse performance.

Remark 3

The synchronization may deteriorate other desired qualities. For example, since actions are waiting for one another, the overall execution may be slower than the slowest action. Moreover, a small value for $\Delta$ or a larger number of barriers can result in highly intermittent behaviors.

V-C3 How the number of barriers affects the predictability

We now present two examples that highlights how the number of barriers for an absolute synchronized parallel node affects the predictability of an execution.

Example 7

Let a BT $\mathcal{T}$ be an absolute parallel synchronization that the actions $\mathcal{A}_{1}$ and $\mathcal{A}_{2}$ as children. $\mathcal{A}_{1}$ is an artificial action that has the desired progress profile over time (see Section IV-C), whose progress holds Equation (8) below:

[TABLE]

Hence, the desired progress profile is such that it starts as [math] and it increases by $0.1$ at each time step. $\mathcal{T}_{2}$ is a the action whose progress is to be imposed. Without constraints, the progress of $\mathcal{T}_{2}$ holds Equation (9) below:

[TABLE]

Figure 3 reports the results of Example 7. We observe worse performance with larger $\bar{\omega}$ and $\Delta$.

Note how, without synchronization, the predictability distance is negative. This is due to the fact that the action $\mathcal{A}_{2}$ has a progress that increases faster than the desired progress profile.

V-C4 Consideration on Safeguarding BTs

For each BT of the Examples 5 and  6 above, the progress difference between $x_{k}$ and $x_{k+1}$ cannot exceed $\alpha+2\bar{\omega}$. This characteristic is similar to the concept of safeguarding BTs (see Definition 3). If the progress function is a monotonic increasing function, then the step length can hint on the synchronization performance. Consider the case in which $p(x_{k})=x_{k}$, the BTs of the examples above are safeguarding with respect to the step length $d=\alpha+2\bar{\omega}$. Intuitively, given the results in this section, a safeguarding BT with smaller step length have better performance.

VI Experimental Evaluation

In this section, we present the experimental evaluation in four different realistic scenarios, one highlighting the absolute progress synchronization (introduced in Section IV-A), one highlighting the relative progress synchronization (introduced in Section IV-B), one showing how to use the proposed framework to impose coordination between perpetual actions, and one predictability (introduced in Section IV-C). To collect statistically-significant data, for we ran each experiment 100 times and we show, plotboxes for the value of the measure described in Section V. The experimental results support the analysis done in Section V-C. A video showing the execution of the experiments is publicly available.222https://youtu.be/eDrZp7n3y-s

Experiment 1** (Absolute Progress Synchronization)**

An object-seeking robot has to detect and recognize possible objects, to clear them, on the floor of a hallway. The robot’s behavior is described as the absolute parallel node of two actions: swipe that makes the head periodically move sideways while scanning possible objects, and navigate that moves the mobile base through the hallway. The progress of both actions increases in linear proportion to the part of the hallway navigated or swept. Whenever the robot finds an unidentified object, the swipe action stops moving the robot’s head until the object is identified. To correctly execute the task, the two actions are synchronized with an absolute parallel synchronized node. Figures 6(a), 6(c), and 6(e) show the steps executed by the robot without a synchronization, whereas Figures 6(b), 6(d), and 6(f) show the steps executed by the robot with synchronization. Figure 4(a) shows the performance of the synchronized and unsynchronized execution in different settings.

Experiment 2** (Relative Progress Synchronization)**

Consider the task on Experiment 1. The actions swipe and navigate are now composed using relative synchronized parallel node. Figure 4(b) shows the performance of the synchronized and unsynchronized execution with different settings.

Remark 4

At the design stage for single actions, we did not specify any speed for the head or mobile base movement. That gives freedom to the user to define any speed and reuse a pre-used action. However, the remark of the safeguarding BTs in Section V-C4 must be taken into account.

Experiment 3** (Synchronization of Perpetual Actions)**

A service robot is tasked to carry tools inside a workshop. When the tools are too many or too heavy, the robot uses a cart to carry them. The robot’s behavior is described as a relative parallel node with two actions as children: hold cart and follow path. The progress of both actions is $1$ whenever the error of, respectively, arm or base reference position is within a boundary, [math] otherwise.

While the robot is pushing the cart forwards, the cart may drift sideways, just like any ordinary cart. To avoid rigidity, the arms’ controllers are compliant, hence the drift of the cart would make the arms move with the cart. Whenever the cart drifts, the error of the action hold cart increases. To avoid that the robot keeps moving while the cart drifts too much, the BT is a relative synchronized parallel node of the two actions.

Figures 7(a), 7(c), 7(e), and 7(g) show the steps executed by the robot without synchronization, whereas Figures 7(b), 7(d), 7(f), 7(h) show the steps executed by the robot with synchronization.

Experiment 4** (Predictability)**

An industrial robot has to perform some specific manipulation operations. Depending on the current tool used, some movements must follow a straight-line profile (same movement’s speed throughout the execution) some other follow a sigmoid profile (the movements are first slow, then fast, then slow again). The robot’s behavior is described by the BT in Figure 5(a), where the action do task describes the manipulation task without any specific progress profile. Figures 5(b) and 5(c) shows the real and the desired progress profile in the two cases.

VII Conclusions

In this paper, we proposed two new BTs control flow nodes for progress synchronization with different synchronization policies, absolute and relative. We proposed measures to assess the synchronization between different sub-BTs and the predictability of robots execution. Moreover, we observed how design choices for the synchronization may affect the performance. Such observations are supported by experimental validation.

We showed the applicability of our approach in a simulation system that allowed us to run the experiments several times in different settings to collect statistically-significant data.