Abstract
This work introduces the BoundMPC strategy, an innovative online model-predictive path-following approach for robot manipulators. This joint-space trajectory planner allows the following of Cartesian reference paths in the end-effector’s position and orientation, including via-points, within the desired asymmetric bounds of the orthogonal path error. These bounds encode the obstacle-free space and additional task-specific constraints in Cartesian space. Contrary to traditional path-following concepts, BoundMPC purposefully deviates from the Cartesian reference path in position and orientation to account for the robot’s kinematics, leading to more successful task executions for Cartesian reference paths. Furthermore the simple reference path formulation is computationally efficient and allows for replanning during the robot’s motion. This feature makes it possible to use this planner for dynamically changing environments and varying goals. The flexibility and performance of BoundMPC are experimentally demonstrated by five scenarios on a 7-DoF
1. Introduction
Robot manipulators are multi-purpose machines with many different applications in industry and research, which include bin picking (Bencak et al., 2022), physical human–robot interaction (Ortenzi et al., 2021), and industrial processes like welding (Lei et al., 2020). During the execution of these applications, various constraints have to be considered, such as safety bounds, collision avoidance, task-specific constraints, and kinematic and dynamic limitations. In general, this leads to challenging trajectory-planning problems. A well-suited control framework for such applications is model predictive control (MPC) (Faulwasser et al., 2009). Using MPC, the control action is computed by optimizing an objective function over a finite planning horizon at every time step while respecting all constraints. Online trajectory planning with MPC is particularly useful for robots acting in dynamically changing environments. Especially when there is uncertainty about actors in the scene, it is crucial to appropriately react to changing situations, for example, when interacting with humans (Li et al., 2021). Trajectory planners that plan the full trajectory from a start to a goal pose (e.g., Jankowski et al., 2023; Marcucci et al., 2023) lack the computational efficiency to react online in these situations.
Robotic tasks are often specified as Cartesian reference paths, parametrized by a path parameter. To execute these tasks accurately, path-following controllers are essential. These controllers ensure that the robot’s end-effector follows the specified path with precision and efficiency (Van Duijkeren et al., 2016). Examples include opening a door, where the end-effector has to follow an arc-shaped path in Cartesian space, opening a drawer with a linear motion, and the transfer of an open container, which must be held upright during the motion. These tasks are challenging for a planner that only plans trajectories based on joint-space objectives. In contrast, a Cartesian reference path consists of a series of Cartesian via-points that the robot’s end-effector needs to pass exactly. It is advantageous to decompose the error between the current position and the desired reference path point (Romero et al., 2022) into a tangential error, representing the error along the path and an orthogonal error. The tangential error is minimized to progress along the path quickly while the orthogonal error is bounded (Arrizabalaga and Ryll, 2022).
Providing a reference path or series of via-points in Cartesian space is intuitive. However, due to the complex robot kinematics, trajectory planning is complicated compared to reference paths or via-points in the robot’s joint space. Furthermore, Cartesian reference paths with path error bounds can simplify collision avoidance and can be used to encode task-specific constraints. Specifying these bounds in the joint space is complicated and requires large computational effort, as shown in Marcucci et al. (2023). Existing work often minimizes the path error to follow the path exactly (Arbo et al., 2017; Astudillo et al., 2022b). This works well if the given path is known to be executable but may lead to the robot getting stuck for challenging paths.
This work introduces a novel online trajectory planner in the joint space, BoundMPC, to follow a Cartesian reference path with the robot’s end-effector while bounding the orthogonal path error. Furthermore, position and orientation reference paths with via-points are considered. A schematic drawing of the geometric relationships is shown in Figure 1. By bounding the orthogonal path error and minimizing the tangential path error, the MPC can find the optimal trajectory according to the robot dynamics and other constraints. The robot purposefully deviates from the path to take the robot’s kinematics into account, which allows the robot to follow even more challenging paths. Simple piecewise linear reference paths with via-points are used to simplify online replanning, and (asymmetric) polynomial error bounds allow us to adapt to different scenarios and obstacles quickly. The end-effector’s position and orientation reference paths are parameterized by the same path parameter, ensuring synchronicity at the via-points. The Lie theory for rotations is employed to describe the end-effector’s orientation, which yields a novel way to decompose and constrain the orientation path error. Moreover, the decomposition of the orthogonal error using the desired basis vectors of the orthogonal error plane allows for meaningful asymmetric bounding of both position and orientation path errors. Schematic of the position trajectory planning using BoundMPC in the 3D Cartesian space. The tangential and orthogonal errors are shown for the initial position with the orthogonal error plane spanned by two basis vectors. The planned path over the planning horizon is within the asymmetric error bounds, depicted as shaded green area.
The paper is organized as follows: Related work is summarized in Section 2, and the contributions extending the state of the art are given in Section 3. The general MPC framework BoundMPC is developed in Section 4. The used orthogonal error bounds are described in Section 5. The use of a piecewise linear reference path and its implications are presented in Section 6. Afterward, Section 7 shows the online replanning. The implementation details for the simulations and experiments are given in Section 8. Section 9 deals with the parameter tuning of the MPC. Six experimental scenarios on a 7-DoF
2. Related work
Path and trajectory planning in robotics is an essential topic with many different solutions, such as sampling-based planners (Elbanhawi and Simic, 2014; Karaman and Frazzoli, 2011; Persson and Sharf, 2014), learning-based planners (Mac et al., 2016; Mukherjee et al., 2022; Osa, 2022), and optimization-based planners (Faulwasser et al., 2009; Romero et al., 2022; Van Duijkeren et al., 2016), which can be further classified into offline and online planning. Online planning is needed to be able to react to dynamically changing environments. Sampling-based planners have the advantage of being probabilistically complete, meaning they will eventually find a solution if the problem is feasible. However, online planning is limited by computational costs and the need to smooth the obtained trajectories (Ferguson et al., 2006; Zucker et al., 2007). Constrained motion planning with sampling-based methods is discussed in Kingston et al. (2019). Optimization-based trajectory planners, such as TrajOpt (Schulman et al., 2014), CHOMP (Zucker et al., 2013), and CIAO (Schoels et al., 2020b), take dynamics and collision avoidance into account. However, they are generally too slow for online planning due to the nonconvexity of the planning problems. Receding horizon control plans a trajectory for a finite horizon starting at the current state to reduce computational complexity. For example, CIAO-MPC (Schoels et al., 2020b) extends CIAO to receding horizon control for point-to-point motions.
More complex applications require the robot to follow a reference path. Receding horizon control in this setting was demonstrated for quadrotor racing in Arrizabalaga and Ryll (2022) and Romero et al. (2022) and robot manipulators in Arbo et al. (2017); Astudillo et al. (2022b); and Mehrez et al. (2017). Additionally, Romero et al. (2022) include via-points in their framework to safely pass the gates along the racing path. Adapting the current reference path during the motion to react to a changing environment and a varying goal is crucial. While, in theory, the developed MPC frameworks in Arrizabalaga and Ryll (2022), Astudillo et al. (2022b), Lam et al. (2013), and Romero et al. (2022) could handle a change in the reference path, this still needs to be demonstrated for industrial manipulators. Furthermore, these frameworks need pre-optimized reference paths, which often requires the solution of a nonlinear optimization problem (e.g., Verschueren et al., 2016). This step must be performed before the path-following task, making the online replanning computationally infeasible. Alternatively, the orthogonal error bounds can be adapted to reflect a dynamic change in the environment, as done in Arrizabalaga and Ryll (2022).
To be able to use the path following formulations, an arc-length parametrized path is needed. Since the system dynamics are parametrized in time, a reformulation is needed to couple the reference path to the system dynamics as done in Arrizabalaga and Ryll (2022), Böck and Kugi (2016), Debrouwere et al. (2014), Spedicato and Notarstefano (2018), and Van Duijkeren et al. (2016). Such a coupling allows for a very compact formulation but complicates constraint formulations. Therefore, Lam et al. (2013) decouple the system dynamics from the path and uses the objective function to minimize the tangential path error to ensure that the path system is synchronized to the system dynamics.
Tracking the reference path by the planner results in a path error. The goal of the classical path following control is to minimize this error (Astudillo et al., 2022b; Faulwasser et al., 2009), which is desirable if the reference path is optimal. Since optimal reference paths are generally not trivial, exploiting the path error to improve the performance has been considered in Arrizabalaga and Ryll (2022) and Romero et al. (2022). Further control on utilizing the path error is given by decomposing it into tangential and orthogonal components. To safely traverse via-points, Romero et al. (2022) use a dynamical weighting of the orthogonal path error, achieving collision-free trajectories. Furthermore, the orthogonal path error lies in the plane orthogonal to the path and can thus be decomposed further using basis vectors of the plane. This way, surface-based path following was proposed in Hartl-Nesic et al. (2021), where the direction orthogonal to the surface was used to assign a variable stiffness. The choice of basis vectors is application specific. Concretely, Arrizabalaga and Ryll (2022) use the Frenet–Serret frame to decompose the orthogonal path error. It provides a continuously changing frame along the path but is not defined for path sections with zero curvature. An alternative to the Frenet–Serret frame is the parallel transport frame used in Bischof et al. (2017). The decomposition of the orthogonal error allows for asymmetric bounding in different directions of the orthogonal error plane, but this has yet to be demonstrated in the literature.
Many path-following controllers only consider a position reference trajectory and thus, a position path error. For quadrotors, this is sufficient since the orientation is given by the dynamics (Romero et al., 2022). The orientation was included in Astudillo et al. (2022a, 2022b) for robot manipulators, where the respective orientation error formulation allows arbitrarily large errors. However, their implementation minimizes the orientation path error, which is only feasible for a path known to be kinematically executable by the robot. For arbitrary paths, this may lead to the robot getting stuck in, for example, the joint limits. The orientation in Van Duijkeren et al. (2016) is even considered constant. In Hartl-Nesic et al. (2021), the orientation is set relative to the surface and is not freely optimized. Thus, the literature has yet to treat orientation reference paths without minimizing the orientation path error. Furthermore, a decomposition of the orientation path error analogous to the position path error is missing in the literature, which can further improve the performance of path-following controllers. In this work, orientation reference paths are included using the Lie theory for rotations, which is beneficial since the rotation propagation can be linearized. In Torres Alberto et al. (2022), this property was exploited for pose estimation based on the theory in Solà et al. (2021). Forster et al. (2017) use the same idea for visual-inertial odometry. In this work, the Lie theory for rotations is exploited to decompose the orientation path error and the propagation of this error over time.
3. Contributions
The proposed MPC framework BoundMPC combines concepts discussed in Section 2 in a novel way. It uses a receding horizon implementation to follow a reference path in the position and orientation with asymmetric error bounds in distinct orthogonal error directions. A path parameter system similar to Lam et al. (2013) ensures path progress. Using linear reference paths with via-points yields a simple representation of reference paths and allows for fast online replanning without providing optimal reference paths. Additionally, the orientation has a distinct reference path, and the orientation path errors are freely optimized to account for the robot’s kinematics instead of minimizing them, as in previous works. The novel asymmetric error bounds allow more control over trajectory generation and obstacle avoidance. Through its simplicity of only providing the desired via-points, BoundMPC finds the optimal position and orientation path within the given error bounds. The main contributions are: • A path-following MPC framework to follow position and orientation paths with synchronized via-points is developed. The robot kinematics are considered in the optimization problem such that a joint trajectory is optimized while adhering to (asymmetric) Cartesian constraints. • The position and orientation path errors, computed based on the Lie theory for rotations, are decomposed and bounded to be freely optimized within the given bounds. This allows for more freedom during the trajectory optimization compared to existing approaches that minimize tracking errors. • Piecewise linear position and orientation reference paths with via-points can be replanned online to quickly react to dynamically changing environments and new goals during the robot’s motion. • The framework is demonstrated on a 7-DoF
4. BoundMPC formulation
This section describes the BoundMPC formulation, which is a path-following concept for Cartesian position and orientation reference paths. This concept is schematically illustrated in Figure 1. The proposed formulation computes a trajectory in the joint space, requiring an underlying torque controller to follow the planned trajectory.
First, the formulation of the dynamical systems, that is, the robot manipulator and the jerk input system, is introduced. Second, the orientation representation based on Lie algebra and its linearization is used to calculate the tangential and orthogonal orientation path errors based on arc-length parameterized reference paths. A similar decomposition is also introduced for the position path error, finally leading to the optimal control problem formulation.
4.1. Dynamical system
The robot manipulator dynamics for n joints are described in the joint positions
4.1.1. Joint jerk parametrization
To obtain the desired trajectory
The integration constants
4.1.2. Linear time-invariant system
In the following, (5) is described by a linear time-invariant (LTI) system with the state
4.1.3. Robot kinematics
The forward kinematics of the robot are mappings from the joint space to the Cartesian space and describe the Cartesian pose of the robot’s end-effector. Given the joint positions
By using the geometric Jacobian
If n > 6, the robot is kinematically redundant and the Jacobian
4.2. Orientation representation
The orientation of the end-effector in the Cartesian space can be represented in different ways, such as rotation matrices, quaternions, and Euler angles. In this work, the Lie algebra
4.2.1. Mappings
To transform a rotation matrix
4.2.2. Concatenation of rotations
A rotation matrix may result from the concatenation of multiple rotation matrices. An example is the Euler angles which are the result of three consecutive rotations around distinct rotation axes. Concretely, let us assume that
4.3. Reference path formulation
In this work, each path point is given as a Cartesian pose, which motivates a separation of the position and orientation path as
4.4. Path error
In this section, the position and orientation path errors are computed and decomposed based on the tangential path directions
4.4.1. Position path error
The position path error between the current end-effector position
4.4.2. Position path error decomposition
The position path error (19) is decomposed into a tangential and an orthogonal error. Figure 2 shows a visualization of the geometric relations. The tangential part Position path error decomposition into the orthogonal and tangential path direction. The black rectangle visualizes the orthogonal error plane spanned by the basis vectors 
The time derivatives of (20) and (21) yield
In the following, the function arguments will be omitted for clarity of presentation. The orthogonal path error
The basis vectors
as the first normalized basis vector. The cross product
4.4.3. Orientation path error
In the following, the orientation path errors are derived using rotation matrices. Then the errors are approximated by applying the Lie theory for rotations from Section 4.2. The orientation path error between the planned and the reference path
with Δϕ = ϕ(t + Δt) − ϕ(t). Using (16) and Comparison of the orientation path error computations. The reference and the current orientation path are computed over a time interval of 2.5 s using the constant angular velocities 
4.4.4. Orientation path error decomposition
The orientation path error is decomposed similarly to the position path error. The rotation path error matrix
Using the Lie representation and the approximation (16), the optimization problem (32) can be written as
The Jacobians are not independent of the optimization variables α, β, and γ, which makes solving (35) a challenging task. To further simplify the problem it is assumed for the Jacobians that the optimal values α*, β*, and γ* are close to an initial guess α0, β0, and γ0. This motivates to compute the Jacobians only for the initial guess to obtain the vectors
Equation (38) provides the approximate solution to (32) at one point in time but the vectors
Thus, the approximation error of (39) is limited to the change of the orientation path errors within the time horizon of the MPC.
The orthogonal orientation path errors
Due to the iterative computation of the orientation path errors in (39), the reference path
4.5. Optimization problem
In this section, the results of the previous sections are utilized to formulate the optimal control problem for the proposed MPC framework. The goal is to follow a desired reference path of the Cartesian end-effector’s position and orientation within given asymmetric error bounds in the error plane orthogonal to the path, which also includes compliance with desired via-points. At the same time, the system dynamics of the controlled robot (6) and the state and input constraints must be satisfied. To govern the progress along the path, the discrete-time path-parameter dynamics
The quantities
The term
Within the MPC, the planning problem (43) is solved at each time step with the same sampling time Ts. In each step, the optimal control inputs
Kinematic singularities happen when the Jacobian
5. Orthogonal path error bounds
To stay within predefined error bounds, the MPC formulation (43) bounds the orthogonal position and orientation path errors using (43l) and (43m). The bounds are specified in the Cartesian space and allow for meaningful interpretations. The applications of the bounds are threefold. First, the bounds guide the end-effector along the path, second they ensure collision-freedom, and third they support encoding task-specific constraints. Guidance is important since the end-effector must pass the via-points with zero bounds. Appropriate bounds of the Cartesian reference path ensure collision freedom. In combination with these bounds, the reference path may be specified manually or by a higher-level planner, which is further discussed in Section 6 and Section 10. This way, the bounds capture the obstacle-free space, which can, for example, be obtained using convex collision-free sets (Deits and Tedrake, 2015). This idea contrasts an often-used approach of specifying the obstacle-occupied space and finding a solution in the remaining space (Vu et al., 2020). An advantage of the proposed approach is that the reference paths with the error bounds provide a simple description of the obstacle-free space, independent of the shape or amount of obstacles. Hence, the computational complexity becomes independent of the complexity of the obstacles and the environment. Lastly, the bounds can enforce task-specific constraints along a path, such as keeping the end-effector upright for transferring an open container filled with liquid or moving in a straight line to open a drawer.
The formulation of the bounding functions is detailed in this section. First, the case of symmetric path error bounds is examined and then generalized to asymmetric error bounds with respect to the desired basis vector directions to increase the flexibility of the method. The resulting bounds are visualized for one position basis direction in Figure 4. 2D Visualization of a position reference path 
5.1. Symmetric bounds
For a symmetric bounding of the orthogonal path errors, the representations
The bounding functions ϒj,m(ϕ) are used to smoothly vary the error bounds such that no orthogonal path errors are allowed at the via-points but deviations from the path are possible in between the via-points depending on the respective task and situation. Let us assume that two via-points exist at the path points ϕ
l
and ϕl+1. In this work, the bounding functions for ϕ
l
≤ ϕ ≤ ϕl+1 are chosen as fourth-order polynomials. They provide sufficient smoothness and are easy to specify by using the conditions
The error bounding functions ϒj,m(ϕ) depend on the path parameter ϕ meaning that the orthogonal error is only correctly bounded as long as the tangential errors
5.2. Asymmetric bounds
The symmetric error bounds from the previous section are generalized in this section to allow for asymmetric bounds around the reference paths. The formulation
Setting ϒj,m(ϕl) = 0 and ϒj,m(ϕl+1) = 0 in (48) may lead to numerical issues in the MPC (43). This is especially true for the orientation path error bounds as the orientation errors are only approximated. Therefore, relaxations ϒj,m(ϕl) = ϵl > 0 and ϒj,m(ϕl+1) = ϵl+1 > 0 are used in practice. Note that in combination with asymmetric error bounds, this may entail discontinuous error bounds at the via-points. Choosing linearly varying upper and lower bounds
6. BoundMPC with linear reference paths
This section describes the application of the proposed MPC framework to piecewise linear reference paths. This is a special case of the above formulation yielding beneficial simplifications of the involved terms and expressions. The block diagram in Figure 5 provides an overview of the interaction of BoundMPC with the underlying joint-space computed-torque controller (2) and the higher-level planner that provides the Cartesian reference paths Block diagram of the application of BoundMPC (43) with the reference paths 
6.1 Reference path formulation
In this work, a piecewise linear reference path is a sequence of L linear segments, that is, Visualization of a linear reference path. The current position along the path is 
Thus, the path (51) is uniquely defined by the via-points
The orientation reference path
The piecewise linear position reference path (51) is used to compute the tangential and orthogonal position path errors for the optimal control problem (43). As discussed in Section 4.4.4, the orientation reference
The orthonormal basis vectors
Sampling-based methods, such as RRT, can be applied to efficiently plan collision-free piecewise linear reference paths in the Cartesian space, which is simpler than generating admissible paths in the joint space. The proposed MPC framework is then employed to find the joint trajectories that follow the paths within the given bounds.
6.2. Computation of the orientation path errors
In this section, the orientation path error computations are derived for the piecewise linear orientation reference paths introduced in (54). Let us assume that the initial path parameter of the planner at the initial time t0 is ϕ0. The current segment at time t has the index l
t
. The orientation path error (29) is integrated in the form
where
6.3. Position and orientation synchronization
The position and orientation reference paths
7. Online replanning
A major advantage using the proposed framework compared to state-of-the-art methods is the ability to replan a given path in real time during the motion of the robot in order to adapt to new goals or dynamic changes in the environment. Two different situations for replanning are possible based on when the reference path is adapted, that is, 1. outside of the current MPC horizon 2. within the current MPC horizon.
The first situation is trivial since it does not affect the subsequent MPC iteration. More challenging is the second situation, which requires careful consideration on how to adapt the current reference path such that the optimization problem remains feasible. Finding the replanned reference paths is left to a higher-level planner, which is beyond the scope of this work.
This situation is depicted for linear position reference paths at the current time t in Figure 7 and applies similarly to linear orientation paths. In this figure, the replanned path Replanning for a linear position reference path. The blue color indicates the current position 
To simplify the replanning, the path state is projected onto the new reference path
8. Implementation details
The proposed MPC is implemented on a
The objective function (45) depends on the current end-effector acceleration for the terms
9. Parameter tuning
Parameters of the MPC to be investigated.
Bold entries indicate default values.
Weights for the MPC cost function (45).
Via-points for the parameter studies. The bounds are chosen symmetrical around the reference. Hence, the basis vectors

Visualization of the robot’s configuration at the end of the example trajectory. The white line shows the position reference path of the end-effector. The world coordinate system is given by the RGB (xyz) axes at the robot’s base. The end-effector in red is a gripper attached to the last robot link.
A comparison of the position and orientation trajectories for different horizon lengths N is shown in Figure 9. The orientation is plotted as the vector part of the unit quaternion representing the orientation. All solutions pass the via-points and converge to the final point without violating the constraints. The normalized cumulated costs of the trajectories are depicted in Figure 10. Longer horizon lengths lead to lower cumulated costs. Figure 11 shows the norm of the tangential error Comparison of the position and orientation trajectories of the MPC solutions for different horizon lengths N. The rotation trajectory is shown as the vector part of the quaternion representation of orientations Cumulated costs of the trajectories for different horizon lengths N. The curves are normalized to the cumulated cost value of the trajectory for N = 30 at ϕ = ϕf. Each curve is the cumulated sum of the objective (45) along the resulting trajectories. Norm of the tangential and orthogonal position error of the MPC solutions for different horizon lengths N.


Trajectory duration T in s for different parameter sets. The parameter values corresponding to the different columns are given in Table 1.
Statistics of computation time Tcomp in ms for different horizon lengths N.
The influence of the path velocity bound Influence of the path velocity limit Exploitation of the joint position and velocity limits for different values of the path velocity limit 

The parameters s0 and sf are used in the error bounds in (48) to specify the slopes of the bounding functions at the via-points; see the comparison of the orthogonal errors in Figure 14. The dashed lines indicate the error bounds, which differ only by their slope parameters at the via-points. These parameters influence the error bounds’ shape but do not change the maximum value ϒmax. A low slope intuitively means that the error bounds around the via-points change slowly; hence, the via-points become more like a via-corridor. A high slope means that this via-corridor becomes very narrow. This is important when passing a via-point (see Figure 14). A longer via-corridor forces the orthogonal path errors to be small for a longer time, and thus, the error cannot be exploited well between the via-points. The effect of the slope s0 = s
f
on the trajectory duration T, as presented in Table 4, can be neglected. Comparison of the orthogonal error trajectories of the position and orientation for different slopes s0 = s
f
. The bounds are shown as dashed lines of the corresponding color. Via-points are indicated by vertical gray lines.
A repeated tracking of Cartesian paths, and specifically the paths described in Table 3, is possible due to the stabilization of the joint nullspace by the term
10. Experiments
The proposed trajectory planning framework BoundMPC features several important properties, such as position and orientation path error bounding, adhering to via-points, and online replanning. Six scenarios with different experiments are considered in the following to demonstrate the capabilities of the proposed framework. We grouped the following experiments into tutorial scenarion, which demonstrate the features and performance of BoundMPC in more detail, and application scenarios, which showcase everyday tasks. The first four scenarios are performed in a static environment and the last two scenarios change the task description online, demonstrating the online replanning capabilities. The scenarios are as follows: S1: (Tutorial Static) Moving a large object between obstacles: A large object is moved from a start to a goal pose with obstacles. These obstacles constraint the position and orientation. The position and orientation paths are synchronized using via-points. This scenario is an example of understanding the components of the BoundMPC planning framework. • Experiment 1: Moving the object in a highly constraint space. S2: (Application Static) Opening a drawer: The robot’s end-effector hooks into a cabinet drawer and opens it in a straight motion. A linear reference path segment with tight error bounds encodes the task-specific constraint of a straight motion. This is an application scenario that fulfills an everyday task. • Experiment 2: Opening the drawer with different desired trajectory durations. S3: (Application Static) Table wiping: Wiping a table with straight sponge motions across the surface. The task-specific straight motions require tight error bounds during the wiping motion but allow larger bounds in the transition segments. This is an application scenario that fulfills an everyday task. • Experiment 3: Wiping the table with the sponge. S4: (Tutorial Static) Collision avoidance for full robot: An object is transferred from one shelf in front of the robot to a shelf behind the robot. The environment contains six additional obstacles close to the robot base. Collision avoidance terms are added to the objective function (45) for collision avoidance of the entire robot’s kinematic chain. • Experiment 4: Transferring the object to the shelf behind the robot. • Experiment 5: Evaluation of the task success for shifted obstacles along the x-axis. S5: (Tutorial Replanning) Object grasp from a table: An object is grasped using one via-point at the pre-grasp pose. The path must be replanned during the robot’s motion in real-time to adapt to the sudden change of the object pose. Collisions of the end-effector are avoided by using asymmetric error bounds. This scenario is used to showcase BoundMPC’s replanning capabilities. • Experiment 6: Grasping the object with three replanning steps showcasing the replanning capabilities. • Experiment 7: Randomly updating the object’s pose until replanning fails. • Experiment 8: Planning 50 random poses with a comparison to state-of-the-art motion planners; see below. S6: (Application Replanning) Transfer of a filled open container: Transferring a filled open container from an initial position onto a table while keeping it upright to avoid liquid spillage. A path segment with tight orientation error bounds encodes the task-specific upright constraint. This is an application scenario that fulfills an everyday task. • Experiment 9: Transferring the open container. • Experiment 10: Randomized put-down positions with replanning for the container.
The 7-DoF robot
The motion planning pipeline consists of two components: 1. The higher-level planner provides the linear reference path segments 2. BoundMPC is used to compute a trajectory to follow the reference paths optimally while exploiting the bounds.
The path bounds are assumed to be obstacle-free, which is ensured by the user input or the higher-level planner, as discussed in Section 6. In this work, collision freedom is only considered for the end-effector, and future work will extend this principle to the whole kinematic chain of the robot. Since the bounding functions are specified in Cartesian space, task-specific constraints are easily encoded in this framework.
In order to show the advantages of using the BoundMPC framework, it is compared to the following state-of-the-art motion planners: • Joint trajectory tracking MPC (JT-MPC): This MPC framework uses a joint-space reference trajectory. Trajectory tracking MPCs are popular real-time capable planning methods (see, e.g., Arbo et al., 2017; Dai et al., 2021; Schoels et al., 2020a; Toussaint et al., 2022; Wang et al., 2023). The reference trajectories for the tracking MPC are computed by optimizing a spline trajectory through the inverse kinematic solutions of the given via-points, (see Toussaint et al., 2022). The reference trajectory planning is fast but does not consider collisions. The collision avoidance is performed through a collision term in the MPC objective function based on potential functions (Vu et al., 2020). In order to enable a fair comparison, collision avoidance is only performed for the robot’s end-effector except for scenario S6 where the entire kinematic chain is checked for collisions. A time horizon of 2 s is used. • Cartesian trajectory tracking MPC (CT-MPC): The CT-MPC uses the same formulation as JT-MPC but with Cartesian reference trajectories for the positions and orientation instead of joint-space reference trajectories. A time horizon of 1 s is used. • Path tracking BoundMPC (BoundMPC-PT): This variant of BoundMPC minimizes
The output of all planners is a joint-space trajectory, which is executed by the robot using the computed-torque controller (2). Thus, the planner outputs are comparable.
Importantly, BoundMPC requires a pre-planned collision-free reference path. While this aspect is not the focus of this work preliminary experiments with planning paths based on collision-free convex sets show promising results. The method proposed in Deits and Tedrake (2015) can efficiently compute these sets. Thus, the comparisons lack the computational overhead of computing the reference paths.
The planners are numerically compared for the following metrics: • The planning time tplan is the time the trajectory planner takes each step to generate the joint-space trajectory for the next time step. • The geometric path length lpath is the length of the end-effector’s position path of the resulting trajectory for each planner. • The time it takes for the robot to traverse the trajectory, indicated by ttraj. • The success rate rs is the percentage of successful planning attempts relative to the failed ones.
10.1. Moving a large object between obstacles
10.1.1. Goal
This task aims to move a large object from a start to a goal pose through a confined space defined by obstacles.
10.1.2. Setup
The object is positioned on a table, from which it is grasped and then transferred to the goal pose. The obstacles create a narrow passage in the middle of the path and at the goal pose. Since the object is too large to pass the obstacles in the initial orientation, the robot must turn it by 90° in the first segment, then pass the obstacles, and finally turn the object to the goal orientation to put it down safely. BoundMPC allows setting via-points to traverse the bottlenecks without collision where no stopping at the via-points is required. The path parameter ϕ(t) synchronizes the end-effector’s position and orientation at the via-points. Thus, the position and orientation via-points are reached at the same time, making it possible to traverse the path safely within the given bounds. A video of the experiment can be found at https://www.acin.tuwien.ac.at/42d0/.
10.1.3. Results
Figure 15 illustrates the robot configuration at four time instances of the trajectory to visualize the robot’s motion in the scenario. For further understanding of the basis vectors, Figure 16 displays the position basis vectors Visualization of the robot’s configurations in different time instances along the path: The end-effector in red is a gripper attached to the robot flange. The blue cylinder represents the object to be transferred to the green table. The red walls are obstacles to be avoided. The green and white lines represent the planned trajectory and the reference path of the end-effector, respectively. The world coordinate system is given by the RGB (xyz) axes at the robot’s base. (a) ϕ = 0 m, (b) ϕ = 0.6 m, (c) ϕ = 1.1 m, and (d) ϕ = ϕf = 1.62 m. Position basis vectors for each linear reference path segment for the object transfer scenario. The red and blue arrows indicate the basis vectors End-effector position and orientation trajectories for the object transfer scenario. The projected bounds (light gray areas) for the orthogonal position path error are shown on the Cartesian planes.


Further details are given in the error trajectories in Figure 18. The low bound in the direction of the basis vector Orthogonal path error trajectories in the position and orientation for the object transfer. The upper two plots show the decomposed orthogonal position path errors and the lower three plots the respective orthogonal orientation path errors and the tangential orientation path error. The blue curves show the trajectory when using large error bounds in each segment. The via-points are indicated by vertical gray lines.
Furthermore, Figure 18 shows the bounded tangential orientation path error
Figure 19 depicts the approximation error αapprox of Mean and maximum values of the absolute orientation approximation error 
10.1.4. Comparison
The proposed BoundMPC planner is compared to two different motion planners for this task, that is, JT-MPC and CT-MPC. The comparison metrics are the planning time tplan, the geometric path length lpath, the trajectory duration ttraj, the success rate rs, and formulation-specific collision avoidance aspects.
Comparison of BoundMPC with different motion planners for the object transfer scenario, in terms of planning time tplan, geometric path length lpath, trajectory duration ttraj, and success rate rs. Each planner was run 10 times and the rows report the minimum, mean and maximum values for each planner.

Comparison of the normed Cartesian velocity ‖
10.2. Opening a drawer
10.2.1. Goal
This experiment aims to open a cabinet drawer using the gripper at the end-effector. The robot has to thread the gripper finger into the handle and then pull toward the opening direction.
10.2.2. Setup
The pose of the cabinet is assumed to be known. The robot has to avoid collisions with the cabinet but not with the handle since contact is necessary to exert a pulling force on the handle. Furthermore, moving the gripper finger into the handle from the top is essential, requires precise positioning, and is crucial for success. The developed framework achieves this by putting a via-point above the handle and descending the reference path into the handle with low orthogonal error bounds to ensure the gripper finger hooks into the handle. Since the reference path is independent of the time parametrization during the motion, the task can be performed successfully at different speeds. The physics simulation was performed in MuJoCo (Todorov et al., 2012).
10.2.3. Results
Three robot configurations during the opening of the drawer are shown in Figure 21. The reference paths Visualization of three robot configurations at different time instances along the path. The green box represents a cabinet. The red drawer can be opened by pulling the green handle. The world coordinate system is given by the RGB (xyz) axes at the robot’s base. (a) ϕ = 0 m, (b) ϕ = 1.1 m, and (c) ϕ = 1.44 m. End-effector trajectories in the y-z-plane of BoundMPC (upper) and CT-MPC (lower) for the drawer opening scenario. The cabinet with the attached handle is depicted in green.

10.3. Table wiping
10.3.1. Goal
In this experiment, the robot wipes a table with a sponge. The sponge must stays in contact with the table during the wiping.
10.3.2. Setup
Each wiping motion is a straight line across the top of the table where the sponge attached to the robot’s end-effector is in contact with the table. At the end of each wiping motion, the end-effector lifts off the table and transitions to the following wiping line, starting from the opposite side. Following the straight wiping paths to cover the tabletop area is essential. In order to achieve this, the wiping paths have low error bounds in all position and orientation directions. The first position basis vector
10.3.3. Results
The robot is visualized during the table wiping task in Figure 23. A comparison of the end-effector position trajectories in the x-y-plane is shown in Figure 24 for BoundMPC and JT-MPC. BoundMPC can perform the task successfully while staying on the tabletop. Small deviations from the path are allowed and do not affect the task success. On the contrary, JT-MPC deviates largely from the desired wiping path. Visualization of the robot during the table wiping task: The blue box in the robot’s gripper represents the sponge used to wipe the green table along the white reference path. The world coordinate system is given by the RGB (xyz) axes at the robot’s base. End-effector positions trajectories in the x-y-plane during the table wiping task for the BoundMPC formulation and JT-MPC: The Cartesian reference of the BoundMPC formulation is also shown. The wiping direction is from left to right and the diagonal lines of the reference path are the transitions between the wiping movements.

10.4. Collision avoidance for entire kinematic chain
10.4.1. Goal
This task aims to move an object from a start to a goal pose. The previous scenarios use the bounded reference path to ensure collision-freedom for the end-effector only. However, it is straightforward to also account for collisions with the remaining links of the robot. In this scenario, the entire kinematic chain of the robot is checked for collisions. This is a very demanding task as the space where the robot can turn around is highly constrained due to the obstacles.
10.4.2. Setup
The environment contains the shelves, one in front and one behind the robot, and six additional objects close to the robot’s base. The collision avoidance of the end-effector is guaranteed through the collision-free reference path with the collision-free bounding functions. The collision with the remaining links of the manipulator is checked by adding collision avoidance terms similar to Vu et al. (2020), which are also used in the CT-MPC and JT-MPC formulations.
10.4.3. Results
Figure 25 visualizes the initial and final robot configurations during the object transfer. In Figure 26, the resulting end-effector trajectories of BoundMPC, CT-MPC, and JT-MPC are shown in the x-y-plane. BoundMPC is the only framework that successfully performs the task. The CT-MPC gets stuck at about x = 0 while turning around due to the obstacles. Furthermore, using JT-MPC, a collision of a robot link with one of the collision spheres is detected, as shown in Figure 27. Visualization of two robot configurations at different times along the path: The green box is the object to be transferred between the two shelves. Six obstacles are shown as black spheres close to the robot’s base. The RGB (xyz) axes give the world coordinate system at the robot’s base. (a) ϕ = 0 m and (b) ϕ = 2 m. End-effector trajectories in a top-down perspective (x-y-plane) for the object transfer between two shelves: The trajectories of BoundMPC, CT-MPC, and JT-MPC are shown. The minimum distance dsphere of any robot link to a collision sphere: Each trajectory has to fulfill dsphere > 0 m to ensure collision freedom.


Comparison of BoundMPC with offline and online planners for the shelf transfer task with collision avoidance of the robot's full kinematic chain: Nine experiments are compared, in which the six obstacles in Figure 25 are shifted along the x-axis between −0.4 m and 0.4 m with a step length of 0.1 m.
10.5. Object grasp from a table
10.5.1. Goal
This experiment aims at grasping an object from a table. The object pose is changed before the robot can grasp it, causing a replanning toward the new object pose. This replanning shows the strength of the proposed BoundMPC framework.
10.5.2. Setup
The grasping pose is assumed to be known. The robot’s end-effector must not collide with the table or the obstacle on the table during grasping. These requirements can be easily incorporated into the path planning by appropriately setting the upper and lower bounds for the orthogonal position path error. Note that collision avoidance is only considered for the end-effector. The replanning of the reference path allows a sudden change in the object’s pose or a decision to grasp a different object during motion. The newly planned trajectory adapts the position and orientation of the end-effector to ensure a successful grasp. This replanning is performed every time the object changes its position or orientation. To this end, a simple task-specific high-level path planner is implemented. This planner sets the via-points such that the linear paths themselves are collision-free. Then, the bounds are planned based on the distances of the linear segments to the obstacles. First, an example of three object pose changes is constructed, which results in three replanning instances. Second, a simulation of random object pose changes at random times is performed and the robustness of the approach is evaluated.
10.5.3. Results
In order to visualize the robot’s motion in the scenario for three replanning instances, Figure 28 illustrates the robot configuration in four time instances of the trajectory. The robot’s end-effector follows the reference path and deviates from it according to the bounds between the via-points. The replannings occur at tr ∈ [2 s, 4.5 s, 8.5 s]. At each replanning time instance tr, the optimization has to adapt the previous solution significantly due to the sudden change of the reference path. Visualization of the robot’s configuration at different time instances along the path. The end-effector in red is a gripper attached to the last robot link. The blue box represents the object to grasp, which is above a green table. The red wall is an additional obstacle to be avoided. The first three time instances represent the time of a replanning, where the object’s pose changes. The green and white lines show the end-effector’s planned trajectory and the reference path. The world coordinate system is given by the RGB (xyz) axes at the robot’s base. (a) t = 2 s, (b) t = 4.5 s, (c) t = 8.5 s, and (d) t = 14.6 s.
The error bounds ep,u,m, ep,l,m, and eo,u,m, eo,l,m, m = 1, 2, are chosen such that collisions with the obstacle on the table, the table itself, and the object to be grasped are avoided. This is visualized in Figure 29 for the trajectory between the second and the third replanning (4.5 s ≤ t ≤ 8.4 s). At this time, the robot’s end-effector must pass over the obstacle on the table, approach the object without collision, and then perform the grasp. The error bounds at t = 4.5 s allow large deviations to simplify the replanning and ensure feasibility. Path error trajectories of the orthogonal position path error 
During 4.5 s ≤ t ≤ 8.4 s, the projected position path error
Furthermore, Figure 30 shows the path parameter ϕ and the speed along the path Trajectories of the path parameter ϕ and its time derivative 
The framework was further tested in the scenario of Figure 28 with randomly sampled object positions
One experiment was to perform permanent replanning every 0.5 s to 1.5 s until the MPC did not find a solution. This experiment was conducted 10 times. On average, the MPC performed 95 replanning steps per experiment, corresponding to a failure rate of about 1.1 % of all replanning steps. The proposed framework stayed within the path error bounds to ensure collision-freedom by the design of the reference paths. Hence, no collisions between the robot and the table, the obstacle on the table, or the object were observed.
Comparison of BoundMPC with different motion planners for the object grasp scenario. In total, 50 random object poses were evaluated, and it was ensured that all poses were reachable without collisions. The minimum, mean and maximum values are reported for each planner.
10.6. Transfer of a filled open container
10.6.1. Goal
An open container filled with a liquid is grabbed using a two-finger gripper and is to be placed onto a table on the opposite side of the robot’s workspace. In order to avoid spillage, the container needs to remain upright. A via-point above the table and an approach via-point are used to perform the motion.
10.6.2. Setup
The requirement for the container to stay upright translates easily to the orientation path error bounds of the end-effector. For BoundMPC, a maximum of ±2.5° orientation path error is allowed for the rotations around the x and y axis, that is, limiting
Note that, the liquid inside the container also moves due to the forces exerted by robot’s motion. Hence, the given requirement is only an approximation.
10.6.3. Results
The start and end configurations of the robot are depicted in Figure 31. Figure 32 shows the trajectories of the RPY angles α, β, and γ for BoundMPC and the two CT-MPC formulations. The BoundMPC framework keeps the RPY angles α and γ within the specified bounds shown as gray areas and successfully reaches the goal state (dgoal → 0). The CT-MPC formulations reach the goal point but struggle to find good solutions. When the cost function is parameterized for position tracking (p), the upright requirement is not fulfilled. However, the requirement is fulfilled for orientation tracking (o), but the trajectory’s smoothness, indicated by the norm of the Cartesian acceleration Visualization of two robot configurations in different time instances along the path. The blue cylinder in the robot's gripper represents the filled open container to be placed onto the green table. The world coordinate system is given by the RGB (xyz) axes at the robot’s base. (a) ϕ = 0 m and (b) ϕ = 2.1 m. End-effector orientation trajectories given as RPY error angles defined in (31a) for the filled container transfer scenario. The angles α and γ must stay within the gray area to fulfill the upright requirement. The trajectories of BoundMPC are compared to CT-MPC parametrized for either position (p) or orientation (o) tracking. The fourth plot shows the distance dgoal to the goal point and the last plot depicts the norm of the Cartesian acceleration 

Comparison of the BoundMPC and CT-MPC framework parametrized for orientation following. The metrics are the maximum RPY angle deviations of the upright α and γ and the mean norm of the Cartesian acceleration ‖
10.7. Discussion
The evaluated experiments show the versatility and the strengths of the proposed BoundMPC formulation which are discussed in detail in this section.
10.7.1. General
BoundMPC can perform the tasks in all six scenarios well and can compute the joint-space trajectories online as shown, for example, in Sections 10.1 and 10.5. The orientation approximation Figure 19 used by BoundMPC does not restrict the performance throughout the experiments. Specifically, the approximation error αapprox in Figure 19 is low for the first horizon step, and the optimization is performed at each time step in a receding horizon manner. Thus, the applied linear approximation (39) is valid for finding good orientation trajectories.
10.7.2. Collision avoidance
BoundMPC uses bounded path errors for the collision avoidance of the end-effector, whereas CT-MPC and JT-MPC use cost terms in the MPC objective function. The advantage of the proposed formulation becomes clear in Section 10.1. The formulation with collision-free bounds is independent of the obstacles’s amount, shape, and size, making even highly constrained scenarios easily accessible. This way, the obstacle-free space is parameterized instead of the obstacle-occupied space as for CT-MPC and JT-MPC. This leads to small bounds at the end of the trajectory to place the object between the walls (see Figure 18), but does not impede performance. Although the reference trajectory guides the CT-MPC formulation, it struggles to find a collision-free trajectory for the end-effector, resulting in a longer path length lpath. Furthermore, for the transfer of an object between two shelves in Section 10.4 the collision avoidance of the entire robot’s kinematic chain is demonstrated. In this experiment the collision-free reference path guides the robot with the bounding functions toward the goal. CT-MPC and JT-MPC struggle in this scenario because they lack the guiding of the bounding functions. For JT-MPC, a trade-off between minimizing the trajectory error and collision avoidance leads to an unsafe trajectory of the robot, as seen in Figure 27, because the joint-space reference trajectory guides the end-effector around the outside of the spheres, as seen in Figure 26, which is impossible without collisions.
10.7.3. Path following
The path-following formulation used by BoundMPC exhibits advantages over the trajectory tracking used by JT-MPC and CT-MPC. It makes it optimizing the speed along the path possible such that following a complicated reference path causes the end-effector to slow down for the necessary joint movements. A Cartesian reference path or trajectory does not guarantee that the robot’s end-effector can follow it perfectly. Especially the coupling of position and orientation makes it complicated to plan suitably for the end-effector. When planning a trajectory, the time parametrization causes additional problems since the nonlinear robot kinematics must be considered. In the object transfer scenario in Section 10.1, BoundMPC slows down at t ≥ 3.0 s to approach the goal smoothly and slowly, as depicted in Figure 20. In contrast, CT-MPC cannot follow the reference trajectory due to the issues mentioned above, forcing the robot to slow down at 4.5 s ≤ t ≤ 5 s. However, since the reference trajectory progresses, the tracking error in the cost function increases, leading to large Cartesian velocities to decrease the tracking error at t ≥ 5 s. This issue is less pronounced for the joint-space planner JT-MPC because of its large planning horizon. However, making JT-MPC faster causes the end-effector to collide with obstacles. These collisions are caused by a trade-off between collision avoidance and minimizing the tracking error, which the path-following formulation proposed in this paper avoids. This effect is also observed in Section 10.4.
10.7.4. Bounded path errors
As discussed above, the bounded path errors are used for collision avoidance but are also important for task success. Some scenarios require certain path error bounds to finish the task successfully. In Section 10.2, BoundMPC finds suitable trajectories for all trajectory durations tf and performs the task successfully (see Figure 22). For long trajectory durations (tf ≥6 s), CT-MPC also manages to solve the task. However, if the durations become small, for example, tf ≤ 4.5 s, CT-MPC struggles to follow the reference and fails at opening the drawer. CT-MPC reduces tracking errors by shortcutting, which leads to task failure. The BoundMPC formulation stays within the path error bounds and adapts the path velocity
10.7.5. Purposeful path deviations
The path error in BoundMPC is not minimized but bounded so that the robot can deviate from the path when necessary. This is advantageous in avoiding local minima due to the robot’s kinematic. As seen in Section 10.6 and Figure 32, BoundMPC-PT gets stuck during the container transfer because the reference trajectory is suboptimal and hard to follow precisely. As the tracking errors
10.7.6. Cartesian reference paths
The Cartesian reference paths in BoundMPC show advantages over planners working in the joint space. In the table-wiping task in Section 10.3, the robot has to follow a reference path on the table. It is not possible to finish this task successfully with the JT-MPC formulation as the joint-space reference trajectory does not correspond to a wiping motion, emphasizing the need for Cartesian reference paths. In the transfer of a filled open container in Section 10.6, JT-MPC cannot perform this task without additional cost terms or constraints, as the joint-space reference trajectory has no notion of orientation. However, BoundMPC can perform this task successfully due to the Cartesian reference paths.
10.7.7. Path error decomposition
The BoundMPC formulation decomposes the position and orientation path error into tangential and orthogonal directions. This is helpful in Section 10.6 since it becomes possible to bound only the relevant error directions for the upright constraint but leave the remaining directions with large allowed path errors. Table 9 and Figure 32 show that smoother and more successful trajectories are obtained due to this advantage over CT-MPC. A major issue for CT-MPC is that the end-effector’s reference trajectory is not perfectly followable. Thus, CT-MPC has to deviate in either position or orientation, while lacking information on which direction deviations are allowed. If the position tracking error is weighted stronger than the orientation tracking error, the MPC violates the upright requirement. If the orientation is weighted stronger, large non-smooth position deviations occur since the position error grows large, and eventually, the MPC tries to decrease it back to zero. Parametrizing CT-MPC for orientations minimizes all orientation errors. Hence, the error in β is also minimized, which is not critical for spilling. The decomposition is also helpful in Section 10.4 as the position path error is constrained stronger in the direction that points toward the spheres, thus favoring a deviation in the other basis directions. Due to this, BoundMPC successfully solves the task.
10.7.8. Replanning
BoundMPC can perform robust online replanning to react to environmental changes and avoid collisions with the obstacles. Global trajectory planners, for example, Jankowski et al. (2023) and Marcucci et al. (2023), that plan the entire trajectory from the start to the goal pose are generally not real-time capable and therefore not applicable to this scenario. The replanning capabilities are demonstrated in Section 10.5. A simple task-specific higher-level path planner was implemented for this scenario, but it did not consider the robot’s kinematics or dynamics. For complex scenarios a more general and sophisticated planner is required. The design of such a planner is part of our future work. In the comparison in Table 8, CT-MPC performs as well as BoundMPC in this environment, and JT-MPC slightly outperforms it. This is expected as the Cartesian and joint-space reference trajectories are collision-free in most cases However, the maximum planning times tplan are the same for BoundMPC and CT-MPC, so both concepts are equivalent in this context. Notably, some poses are hard to reach for the manipulator such that the trajectory tracking issues discussed above also apply here, that is, CT-MPC offers no considerable advantage in this application. JT-MPC is fine with hard-to-reach poses as it plans in the joint space. The replanning experiments for the scenario with the filled container in Section 10.6 show that BoundMPC can robustly replan even with task-specific constraints which is not possible for CT-MPC, as seen in Table 9.
11. Conclusion
This work proposes a novel model-predictive trajectory planning for robots in Cartesian space, called BoundMPC, which systematically considers via-points, tangential and orthogonal error decomposition, and asymmetric error bounds. The joint jerk input is optimized to follow a reference path in Cartesian space. The motion of the robot’s end-effector is decomposed into a tangential motion, the path progress, and an orthogonal motion, which is further decomposed geometrically into two basic directions. A novel way of projecting orientations allows a meaningful decomposition of the orientation error using the Lie theory for rotations. Additionally, the particular case of piecewise linear reference paths in orientation and position is derived, simplifying the optimization problem’s online calculations. Online replanning is crucial to adapt the considered path to dynamic environmental changes and new goals during the robot’s motion.
Simulations and experiments were carried out on a 7-DoF
First, the transfer of a large object through a slit, where lifting of the object is required, is solved by utilizing via-points and specific bounds on the orthogonal error in the position and orientation reference paths, which are synchronized by the path parameter. Second, an object has to be grasped from a table, the commanded grasping point changes during the robot’s motion, and collision with other objects must be avoided. This case shows the advantages of systematically considering asymmetric Cartesian error bounds and the dynamic online replanning. Further scenarios show the drawer opening, the transfer of an open container, and the table wiping. The advantages of path-following concepts compared to trajectory-following and Cartesian reference paths over joint-space reference paths are elaborated. The last scenario highlights the possibility of collision avoidance for the entire robot’s kinematic chain.
Due to the advantageous real-time replanning capabilities and the easy asymmetric Cartesian bounding, we plan to use BoundMPC in dynamically changing environments in combination with cognitive decision systems that adapt the pose reference paths online according to situational needs.
Supplemental Material
Footnotes
Acknowledgments
The authors acknowledge TU Wien Bibliothek for financial support through its Open Access Funding Program.
Declaration of conflicting interests
The author(s) declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.
Funding
The author(s) received no financial support for the research, authorship, and/or publication of this article.
Supplemental Material
Supplemental material for this article is available online.
References
Supplementary Material
Please find the following supplemental material available below.
For Open Access articles published under a Creative Commons License, all supplemental material carries the same license as the article it is associated with.
For non-Open Access articles published, all supplemental material carries a non-exclusive license, and permission requests for re-use of supplemental material or any part of supplemental material shall be sent directly to the copyright owner as specified in the copyright notice associated with the article.
