Operational-Space Controllers¶

Operational-space controllers work in task space (e.g., end-effector positions, orientations) rather than configuration space. They are ideal when the control objective is naturally expressed in Cartesian coordinates or other task-related quantities.

Overview¶

Operational-space control, pioneered by Khatib (1987), formulates robot control directly in the task space of interest. The key insight is to use the operational-space dynamics:

\[ \Lambda(q) \ddot{x} + \mu(q, \dot{q}) \dot{x} + p(q) = f \]

where:

\(\Lambda(q) = (J M^{-1} J^T)^{-1}\) is the operational-space inertia matrix
\(\mu(q, \dot{q})\) is the operational-space Coriolis matrix
\(p(q)\) represents operational-space forces from potential energy
\(f\) is the control force in operational space
\(J\) is the task Jacobian

Base Class¶

All operational-space controllers inherit from OperationalSpaceBaseController:

soromox.control.OperationalSpaceBaseController ¶

Bases: BaseController, ABC


              flowchart TD
              soromox.control.OperationalSpaceBaseController[OperationalSpaceBaseController]
              soromox.control.base_controller.BaseController[BaseController]

                              soromox.control.base_controller.BaseController --> soromox.control.OperationalSpaceBaseController
                


              click soromox.control.OperationalSpaceBaseController href "" "soromox.control.OperationalSpaceBaseController"
              click soromox.control.base_controller.BaseController href "" "soromox.control.base_controller.BaseController"

Abstract base class for operational-space controllers.

Operational-space controllers compute actuation inputs based on the current system state and a reference trajectory defined in operational (task) space. The controller uses an OperationalSpaceDynamics instance to transform between configuration space and operational space.

The reference trajectory should be specified in operational space coordinates (e.g., end-effector positions/orientations), and the controller computes the corresponding actuator inputs to track this trajectory.

Attributes:

Name	Type	Description
`robot`	`SoftRobot`	The soft robot system to be controlled (inherited from BaseController, should be set to operational_space_dynamics.robot).
`reference_trajectory`	`ReferenceTrajectory`	The desired trajectory to track in operational space.
`operational_space_dynamics`	`OperationalSpaceDynamics`	The OperationalSpaceDynamics instance that defines the task space and provides the necessary transformations (Jacobians, dynamically-consistent pseudo-inverse, etc.).

Note

Subclasses should set self.robot = operational_space_dynamics.robot in their __init__ method to ensure the robot attribute is properly initialized.

References

Khatib, O. (1987). A unified approach for motion and force control of robot manipulators: The operational space formulation. IEEE Journal on Robotics and Automation, 3(1), 43-53.

Natale, C. (2003). Interaction control of robot manipulators: Six-degrees-of-freedom tasks. Springer Science & Business Media.

call `abstractmethod` ¶

__call__(system_state: SystemState) -> tuple[Array, Any | None]

Compute the control action given the current system state.

This method is called at each control step to compute the actuation input based on the current state and the reference trajectory.

Implementations should be JAX-compatible (jittable) for use with the rollout methods in DynamicalSystem. Avoid Python control flow that depends on array values; use jax.lax primitives instead.

Parameters:

Name	Type	Description	Default
`system_state`	`SystemState`	The current state of the system, containing: - t (Array): Current simulation time - y (Array): Robot state vector (typically, configuration and velocity) - u (Optional[Array]): Previous actuation input (optional) - control_state (Optional[Any]): Internal controller state (optional) - environment_state (Optional[Any]): Environment state (optional)	required

Returns:

Name	Type	Description
`u_control`	`Array`	The control input to apply, shape (num_actuators,).
`control_state_dot`	`Optional[Any]`	Time derivative of the internal controller state as a PyTree (e.g., integrator error for integral control), or None if the controller is stateless.

Trajectory Trackers¶

OperationalSpaceImpedanceControlTracker¶

Full Actuation Required

This controller requires the system to be fully actuated (number of actuators equals number of DOFs, \(n = m\)). For under-actuated systems, consider using OperationalSpaceSynergisticController.

Operational-space impedance control combines selectable feedback linearization with moving-reference feedforward. Set feedback_linearization="full" (the default) or "partial".

Both modes cancel task-projected elasticity and damping, cancel gravity, feed forward \(\Lambda\ddot{x}^d\), and inject the requested stiffness and damping. They differ only in their Coriolis/centrifugal compensation:

Mode	Compensated task force	Result
`full`	\(\mu_x\dot{q}\)	Cancels the complete task-space Coriolis force
`partial`	\(\mu_x(I-\bar{J}J)\dot{q}\)	Cancels only null-space Coriolis coupling and retains \(\mu_x\bar{J}\dot{x}\)

Historical provenance

The partial mode follows the Cartesian impedance structure proposed in Section 3.3, equations 49 and 56–60, of Della Santina et al. (2020). That controller removes dynamic coupling from the residual/null-space degrees of freedom while deliberately retaining the natural task-space Coriolis term. The implementation here extends the paper's set-point law with desired velocity and acceleration feedforward for moving-reference tracking.

The full mode instead uses a Khatib-style operational-space nonlinear dynamic-decoupling structure. Section IV, equations 29–31, of Khatib (1987) compensates the complete operational-space centrifugal/Coriolis and gravity terms before applying desired acceleration and tracking feedback. The implementation here is not a verbatim reproduction: its stiffness and damping are physical task-space impedance forces, so the closed-loop error dynamics retain \(\Lambda\) rather than being presented as unit-mass dynamics.

With full linearization and \(e_x\) denoting the geometric correction from the current pose to the desired pose, the local closed-loop error dynamics become:

\[ \Lambda \ddot{e}_x + D_x \dot{e}_x + K_x e_x = 0 \]

where:

\(\Lambda\) is the operational-space inertia matrix (preserved)
\(D_x\) is the desired damping matrix
\(K_x\) is the desired stiffness matrix
\(x^d\), \(\dot{x}^d\), and \(\ddot{x}^d\) define the moving reference

The control law implements six key terms:

Cancel elastic and damping forces projected to task space
Cancel gravity
Apply the selected Coriolis cancellation
Feed forward desired acceleration: \(\Lambda\ddot{x}^d\)
Inject desired stiffness: \(K_x e_x\)
Inject desired damping: \(D_x (\dot{x}^d - \dot{x})\)

Choosing the mode

Use full when moving-reference tracking accuracy is the priority and the model is sufficiently accurate. Use partial when retaining the natural task-space velocity-dependent dynamics is desired. Partial mode generally exhibits more tracking error on fast trajectories because that term is intentionally not cancelled.

Gain scaling

Translational and rotational gains have different units and should be tuned separately. For approximately decoupled modes at a representative configuration, a useful initialization is \(K_i = \lambda_i\omega_{n,i}^2\) and \(D_i = 2\zeta_i\lambda_i\omega_{n,i}\), where \(\lambda_i\) is the corresponding operational-space inertia. Do not use the same numeric gains for position and orientation without accounting for this scaling.

Assumptions

The impedance controller assumes:

Full actuation: Number of actuators equals number of DOFs (\(n = m\))
Invertible actuation matrix: \(A(q)\) must be full rank
Stable null space: Typically satisfied when stiffness and damping matrices are positive definite

soromox.control.OperationalSpaceImpedanceControlTracker ¶

OperationalSpaceImpedanceControlTracker(operational_space_dynamics: OperationalSpaceDynamics, reference_trajectory: ReferenceTrajectory, K_x: float | Array, D_x: float | Array, feedback_linearization: FeedbackLinearizationMode = 'full')

Bases: OperationalSpaceBaseController


              flowchart TD
              soromox.control.OperationalSpaceImpedanceControlTracker[OperationalSpaceImpedanceControlTracker]
              soromox.control.operational_space.base_controller.OperationalSpaceBaseController[OperationalSpaceBaseController]
              soromox.control.base_controller.BaseController[BaseController]

                              soromox.control.operational_space.base_controller.OperationalSpaceBaseController --> soromox.control.OperationalSpaceImpedanceControlTracker
                                soromox.control.base_controller.BaseController --> soromox.control.operational_space.base_controller.OperationalSpaceBaseController
                



              click soromox.control.OperationalSpaceImpedanceControlTracker href "" "soromox.control.OperationalSpaceImpedanceControlTracker"
              click soromox.control.operational_space.base_controller.OperationalSpaceBaseController href "" "soromox.control.operational_space.base_controller.OperationalSpaceBaseController"
              click soromox.control.base_controller.BaseController href "" "soromox.control.base_controller.BaseController"

Operational-space impedance controller for soft robots.

This controller supports two feedback-linearization modes:

"full" cancels the complete task-space Coriolis/centrifugal force. For a moving reference, the local closed-loop error dynamics become Λ ë_x + D_x ė_x + K_x e_x = 0.
"partial" cancels only the null-space Coriolis coupling μ_x (I - J_bar J) q̇. It preserves the natural task-space term μ_x J_bar ẋ instead of fully linearizing it.

Historical provenance

The "partial" mode follows the Cartesian impedance structure proposed by Della Santina et al. (2020, Sec. 3.3, Eqs. 49 and 56--60). That law compensates coupling from the residual/null-space dynamics while deliberately retaining the natural task-space Coriolis term. This implementation extends the paper's set-point formulation with desired velocity and acceleration feedforward for moving-reference tracking.
The "full" mode is a Khatib-style operational-space nonlinear dynamic-decoupling variant (Khatib, 1987, Sec. IV, Eqs. 29--31): it compensates the complete task-space Coriolis/centrifugal force before applying desired acceleration and tracking feedback. It is not a verbatim reproduction of Khatib's controller. Here the stiffness and damping are physical task-space impedance forces, so the closed-loop error dynamics retain the operational-space inertia Λ rather than being presented as unit-mass dynamics.

Here, Λ is the operational-space inertia matrix, D_x is the desired damping, K_x is the desired stiffness, and e_x is the geometric correction from the current pose to the desired pose. Full linearization is the default.

The control law is:

τ = A^{-1}(q) [
    J^T(q) J_bar^T(q) (τ_el(q) + D(q) q̇)     (Cancel elastic & damping forces on task)
    + G(q)                                    (Cancel gravity)
    + J^T(q) f_μ(q,q̇)                        (Selected Coriolis cancellation)
    + J^T(q) Λ(q) ẍ^d                         (Reference acceleration feedforward)
    + J^T(q) (K_x e_x + D_x (ẋ^d - ẋ))       (Desired task impedance)
]

where f_μ = μ_x q̇ in full mode and f_μ = μ_x (I - J_bar J) q̇ in partial mode.

with

A(q) is the actuation matrix (must be square and invertible)
J(q) is the operational space Jacobian
J_bar(q) = M^{-1} J^T Λ is the dynamically-consistent pseudo-inverse
Λ = (J M^{-1} J^T) is the operational space inertia matrix
τ_el(q) is the configuration-space elastic force
D(q) is the configuration-space damping matrix
G(q) is the configuration-space gravitational force
μ(q, q̇) is the operational space Coriolis matrix
K_x is the operational space stiffness gain matrix
D_x is the operational space damping gain matrix
x^d is the desired operational space position
ẋ^d and ẍ^d are the desired operational space velocity and acceleration
x is the current operational space position
ẋ is the current operational space velocity

Assumptions

(a) Full actuation: n = m (number of DOFs equals number of actuators) (b) The actuation matrix A(q) ∈ ℝ^{n×n} is invertible © The operational space has lower or equal dimensionality than the configuration space (o ≤ n) (d) The null space is asymptotically stable, typically satisfied when K(q) = S q with S ≻ 0 and D ≻ 0 (positive definite stiffness and damping)

Attributes:

Name	Type	Description
`robot`		The soft robot system to be controlled (inherited from BaseController, should be set to operational_space_dynamics.robot).
`operational_space_dynamics`		The OperationalSpaceDynamics instance.
`reference_trajectory`		The desired trajectory in operational space.
`K_x`	`Array`	Operational space stiffness gain matrix, shape (o, o) or (o,).
`D_x`	`Array`	Operational space damping gain matrix, shape (o, o) or (o,).
`feedback_linearization`	`FeedbackLinearizationMode`	Coriolis cancellation mode, either `"full"` or `"partial"`.

References

Khatib, O. (1987). A unified approach for motion and force control of robot manipulators: The operational space formulation. IEEE Journal on Robotics and Automation, 3(1), 43-53. https://doi.org/10.1109/JRA.1987.1087068

Ott, C. (2008). Cartesian impedance control of redundant and flexible-joint robots. Springer.

Della Santina, C., Katzschmann, R. K., Bicchi, A., & Rus, D. (2020). Model-based dynamic feedback control of a planar soft robot: trajectory tracking and interaction with the environment. The International Journal of Robotics Research, 39(4-5), 490-513. https://doi.org/10.1177/0278364919897292

Stölzle, M. (2025). Safe yet Precise Soft Robots: Incorporating Physics into Learned Models for Control. Dissertation, Delft University of Technology. https://doi.org/10.4233/uuid:24c1f667-8fd6-431a-bb78-11d22f8cb3da

Initialize the operational-space impedance controller.

Parameters:

Name	Type	Description	Default
`operational_space_dynamics`	`OperationalSpaceDynamics`	The OperationalSpaceDynamics instance that defines the task space and provides transformations between configuration and operational space.	required
`reference_trajectory`	`ReferenceTrajectory`	The desired trajectory in operational space. Must provide desired pose, velocity, and acceleration functions. `ReferenceTrajectory` derives missing velocity and acceleration functions automatically. The trajectory dimension must match the operational space dimension (n_operational_space).	required
`K_x`	`float \| Array`	Operational space stiffness gain. Can be: - A scalar (float): applied uniformly to all operational space dimensions. - A 1-d array of shape (o,): diagonal stiffness. - A 2-d array of shape (o, o): full stiffness matrix. Should be positive definite for stability.	required
`D_x`	`float \| Array`	Operational space damping gain. Same format options as K_x. Should be positive definite for stability.	required
`feedback_linearization`	`FeedbackLinearizationMode`	Coriolis cancellation mode: - `"full"` cancels all task-space Coriolis/centrifugal forces. - `"partial"` cancels only their null-space contribution. Defaults to `"full"`.	`'full'`

Raises:

Type	Description
`ValueError`	If the feedback-linearization mode is unknown, or if the actuation matrix is not square or not invertible.

call ¶

__call__(system_state: SystemState) -> tuple[Array, Any | None]

Compute the operational-space impedance control action.

This method cancels elastic, damping, and gravitational forces, applies the selected Coriolis cancellation mode, and injects the desired operational-space impedance behavior.

Parameters:

Name	Type	Description	Default
`system_state`	`SystemState`	The current state of the system, containing: - t: Current simulation time - y: Robot state vector [q, qd] (configuration and velocity)	required

Returns:

Name	Type	Description
`u_control`	`Array`	The control input, shape (num_actuators,).
`control_state_dot`	`Any \| None`	None (this controller is stateless).

OperationalSpaceSynergisticController¶

Synergistic control enables exact task execution in highly under-actuated soft robots by exploiting the dynamic coupling between actuation and operational spaces.

The control law is:

\[ \tau = P_{AM}(q) J^T(q) \left(K_p e_x + K_i \int e_x \, dt + K_d e_{\dot{x}}\right) \]

with:

\[ P_{AM}(q) = (J(q) M^{-1}(q) A(q))^{-1} J(q) M^{-1}(q), \quad e_x = x^d - x, \quad e_{\dot{x}} = \dot{x}^d - \dot{x} \]

where: - \(A(q)\) is the actuation matrix - \(M(q)\) is the inertia matrix - \(J(q)\) is the operational space Jacobian - \(K_p\) is the operational space proportional gain matrix - \(K_i\) is the operational space integral gain matrix - \(K_d\) is the operational space derivative gain matrix - \(e_x\) is the operational space pose error (geometric error for orientation) - \(x^d\) is the desired operational space pose - \(x\) is the current operational space pose - \(\dot{x}^d\) is the desired operational space velocity - \(\dot{x}\) is the current operational space velocity

The key insight is the use of a dynamically-consistent synergistic projector \(P_{AM}\) that maps operational-space PID control forces to actuator inputs while respecting the system's dynamic structure.

Assumptions

The synergistic controller assumes:

Under-actuation: The actuation space has lower dimensionality than the configuration space (\(m < n\)). For fully actuated systems, consider using the impedance control tracker.
Equal dimensions: The operational space dimension equals the actuation space dimension (\(o = m\))
Full-rank matrix: The matrix \(J(q) M^{-1}(q) A(q) \in \mathbb{R}^{m \times m}\) must be full-rank (invertible)

When to Use Synergistic Control

Synergistic control is ideal for:

Under-actuated soft robots where the number of actuators is less than the number of DOFs
Exact task execution when the task dimension matches the actuation dimension

soromox.control.OperationalSpaceSynergisticController ¶

OperationalSpaceSynergisticController(*args, **kwargs)

Bases: PIDController


              flowchart TD
              soromox.control.OperationalSpaceSynergisticController[OperationalSpaceSynergisticController]
              soromox.control.operational_space.pid_controller.PIDController[PIDController]
              soromox.control.operational_space.base_controller.OperationalSpaceBaseController[OperationalSpaceBaseController]
              soromox.control.closed_form_model_based_controller.ClosedFormModelBasedController[ClosedFormModelBasedController]
              soromox.control.base_controller.BaseController[BaseController]

                              soromox.control.operational_space.pid_controller.PIDController --> soromox.control.OperationalSpaceSynergisticController
                                soromox.control.operational_space.base_controller.OperationalSpaceBaseController --> soromox.control.operational_space.pid_controller.PIDController
                                soromox.control.base_controller.BaseController --> soromox.control.operational_space.base_controller.OperationalSpaceBaseController
                

                soromox.control.closed_form_model_based_controller.ClosedFormModelBasedController --> soromox.control.operational_space.pid_controller.PIDController
                                soromox.control.base_controller.BaseController --> soromox.control.closed_form_model_based_controller.ClosedFormModelBasedController
                




              click soromox.control.OperationalSpaceSynergisticController href "" "soromox.control.OperationalSpaceSynergisticController"
              click soromox.control.operational_space.pid_controller.PIDController href "" "soromox.control.operational_space.pid_controller.PIDController"
              click soromox.control.operational_space.base_controller.OperationalSpaceBaseController href "" "soromox.control.operational_space.base_controller.OperationalSpaceBaseController"
              click soromox.control.closed_form_model_based_controller.ClosedFormModelBasedController href "" "soromox.control.closed_form_model_based_controller.ClosedFormModelBasedController"
              click soromox.control.base_controller.BaseController href "" "soromox.control.base_controller.BaseController"

Synergistic controller for soft robots.

The control law is:

tau = P_AM @ J(q).T @ (Kp e_x + Ki integral_e_x + Kd e_dx)

P_AM = (J(q) M(q)^{-1} A(q))^{-1} J(q) M(q)^{-1}
e_x = x_des - x
e_dx = xd_des - xd
integral_e_x = integral of e_x dt

where

A(q) is the actuation matrix
M(q) is the inertia matrix
J(q) is the operational space Jacobian
Kp is the operational space proportional gain matrix
Ki is the operational space integral gain matrix
Kd is the operational space derivative gain matrix
e_x is the operational space pose error (geometric error for orientation)
e_dx is the operational space velocity error
x is the current operational space pose
x_des is the desired operational space pose
xd is the current operational space velocity
xd_des is the desired operational space velocity

Assumptions

(A) Under-actuation: The actuation space has lower dimensionality than the configuration space (m < n). If full actuation, consider using, for example, the impedance control tracker. (B) The operational space has equal dimensionality of the actuation space (o = m). (C) The matrix J(q) M^{-1}(q) A(q) ∈ ℝ^{m×m} is full-rank.

Attributes:

Name	Type	Description
`robot`		The soft robot system to be controlled (inherited from BaseController, should be set to operational_space_dynamics.robot).
`operational_space_dynamics`		The OperationalSpaceDynamics instance.
`reference_trajectory`		The desired trajectory in operational space.
`pid_control`	`PIDControl`	The PIDControl instance containing gains and saturation. Note: Gains should be sized for the operational coordinates (n_o).

References

Della Santina, C., Pallottino, L., Rus, D., & Bicchi, A. (2019). Exact task execution in highly under-actuated soft limbs: an operational space based approach. IEEE Robotics and Automation Letters, 4(3), 2508-2515.

Initialize the synergistic controller.

Raises:

Type	Description
`ValueError`	If either assumption (A) or (B) is not met.

model_based_term ¶

model_based_term(system_state: SystemState) -> tuple[Array, Any | None]

Compute the model-based feedforward control term.

This term typically computes the control input required to achieve the desired trajectory based on the system dynamics model (e.g., inverse dynamics, gravity compensation).

The default implementation returns zero control input. Subclasses can override this method to provide model-based feedforward control.

Parameters:

Name	Type	Description	Default
`system_state`	`SystemState`	The current state of the system.	required

Returns:

Name	Type	Description
`u_model`	`Array`	Model-based control input, shape (num_actuators,).
`control_state_dot`	`Optional[Any]`	Time derivative of the internal controller state contributed by this term, or None.

error_based_feedback_term ¶

error_based_feedback_term(system_state: SystemState) -> tuple[Array, PIDControllerState | None]

Compute the PID feedback control term in operational space.

This method computes the PID control action based on the tracking error in the selected operational coordinates only (selected via task-selector).

Parameters:

Name	Type	Description	Default
`system_state`	`SystemState`	The current state of the system, containing: - t: Current simulation time - y: Robot state vector [q, qd] (configuration and velocity) - control_state: PIDControllerState containing integral error of shape (n_o,), or None if not using integral control.	required

Returns:

Name	Type	Description
`f_x`	`Array`	The operational space forcing action, shape (n_o,).
`control_state_dot`	`PIDControllerState \| None`	Time derivative of the PIDControllerState, or None if no control state is being tracked.

update_gains ¶

update_gains(gains: dict[str, Array]) -> PIDController

This function updates the gains of the PID controller.

Parameters:

Name	Type	Description	Default
`gains`	`dict[str, Array]`	proportional, integral, and derivative gains	required

Returns:

Name	Type	Description
`updated_self`	`PIDController`	self object with updated gains

call ¶

__call__(system_state: SystemState) -> tuple[Array, PIDControllerState | None]

Compute the synergistic control action.

This method implements the synergistic control law to track the desired trajectory.

Parameters:

Name	Type	Description	Default
`system_state`	`SystemState`	The current state of the system, containing: - t: Current simulation time - y: Robot state vector [q, qd] (configuration and velocity)	required

Returns:

Name	Type	Description
`tau_control`	`Array`	The control input, shape (num_actuators,).
`control_state_dot`	`PIDControllerState \| None`	PIDControllerState derivative if tracking integral error, otherwise None.

Usage Examples¶

Impedance Control (Fully Actuated Systems)¶

import jax.numpy as jnp
from soromox.control import OperationalSpaceImpedanceControlTracker, ReferenceTrajectory
from soromox.coordinate_transformations import OperationalSpaceDynamics

# Create operational space dynamics (defines the task space)
osd = OperationalSpaceDynamics(
    robot=robot,
    forward_kinematics_fn=lambda q: robot.end_effector_position(q),
)

# Define reference trajectory in operational space
ts = jnp.linspace(0, 10, 1000)
x_des = jnp.zeros((len(ts), osd.n_operational_space))
# ... fill in desired trajectory ...

ref_traj = ReferenceTrajectory(ts=ts, x_des_ts=x_des)

# Create impedance controller (requires full actuation: n = m)
controller = OperationalSpaceImpedanceControlTracker(
    operational_space_dynamics=osd,
    reference_trajectory=ref_traj,
    K_x=100.0,  # Stiffness (scalar, vector, or matrix)
    D_x=10.0,   # Damping (scalar, vector, or matrix)
    feedback_linearization="full",  # Or "partial"
)

Synergistic Control (Under-Actuated Systems)¶

import jax.numpy as jnp
from soromox.control import (
    OperationalSpaceSynergisticController,
    PIDControl,
    ReferenceTrajectory,
)
from soromox.coordinate_transformations import OperationalSpaceDynamics

# Create operational space dynamics (defines the task space)
# IMPORTANT: n_operational_space must equal n_actuators (o = m)
osd = OperationalSpaceDynamics(
    robot=robot,
    forward_kinematics_fn=lambda q: robot.end_effector_position(q),
)

# Verify that operational space dimension matches actuation dimension
assert osd.n_operational_space == robot.num_actuators, \
    "SynergisticController requires o = m (operational space = actuation space)"

# Define reference trajectory in operational space
ts = jnp.linspace(0, 10, 1000)
x_des = jnp.zeros((len(ts), osd.n_operational_space))
# ... fill in desired trajectory ...

ref_traj = ReferenceTrajectory(ts=ts, x_des_ts=x_des)

# Define PID gains in operational space
Kp = 100.0 * jnp.ones((osd.n_operational_space,))
Ki = 10.0 * jnp.ones((osd.n_operational_space,))
Kd = 5.0 * jnp.ones((osd.n_operational_space,))
pid_control = PIDControl(Kp, Ki, Kd)

# Create synergistic controller (for under-actuated systems: m < n, o = m)
controller = OperationalSpaceSynergisticController(
    operational_space_dynamics=osd,
    reference_trajectory=ref_traj,
    pid_control=pid_control,
)

References¶

The operational-space formulation for robot control was developed in the following foundational works:

Khatib, O. (1987). A unified approach for motion and force control of robot manipulators: The operational space formulation. IEEE Journal on Robotics and Automation, 3(1), 43-53.
Ott, C. (2008). Cartesian impedance control of redundant and flexible-joint robots. Springer.

For soft robot applications:

Della Santina, C., Katzschmann, R. K., Bicchi, A., & Rus, D. (2020). Model-based dynamic feedback control of a planar soft robot: trajectory tracking and interaction with the environment. The International Journal of Robotics Research, 39(4-5), 490-513.

For synergistic control of under-actuated soft robots:

Della Santina, C., Pallottino, L., Rus, D., & Bicchi, A. (2019). Exact task execution in highly under-actuated soft limbs: an operational space based approach. IEEE Robotics and Automation Letters, 4(3), 2508-2515.

Operational-Space Controllers¶

Overview¶

Base Class¶

soromox.control.OperationalSpaceBaseController ¶

__call__ abstractmethod ¶

Trajectory Trackers¶

OperationalSpaceImpedanceControlTracker¶

soromox.control.OperationalSpaceImpedanceControlTracker ¶

__call__ ¶

OperationalSpaceSynergisticController¶

soromox.control.OperationalSpaceSynergisticController ¶

model_based_term ¶

error_based_feedback_term ¶

update_gains ¶

__call__ ¶

Usage Examples¶

Impedance Control (Fully Actuated Systems)¶

Synergistic Control (Under-Actuated Systems)¶

References¶

call `abstractmethod` ¶

call ¶

call ¶