Virtual model control for compliant reaching under uncertainties

In plain words

A robot arm can be told where to go by a set of imaginary springs and dampers attached to its hand. The springs pull the hand toward the goal, and other imaginary springs push it away from obstacles. The arm then moves as the physics of that spring setup dictates. The controller never plans a path ahead of time and never solves for joint angles from a target position.

This makes the behaviour easy to predict. If the arm meets something it did not expect, such as a hand on its wrist or a plate in its path, it gives way in the way the springs would. The force it pushes back with is set by the spring stiffness, so the robot stays gentle. The cost is accuracy: the arm can stop a few centimetres short of the goal, and its path is not the shortest or smoothest.

The authors test six ways to design such spring setups on a small humanoid arm. They report that the design is intuitive and easy to extend, and that the arm handles an obstacle it could not see.

TL;DR

Virtual model control (VMC) builds the controller from virtual springs, dampers and optional extra masses, then converts the resulting virtual forces into joint torques with the transpose of each attachment point's Jacobian §2.1, eq. 1. Six designs are given: simple, geometric, moving-reference and force-driven reaching, plus obstacle and multi-obstacle avoidance §2.2, §2.3. Experiments on a Sciurus17 humanoid arm, with 17 DoF in total and Dynamixel current control, show predictable motion, compliance to an undetected human hand and to an undetected plate §3, §4. The paper gives no quantitative accuracy or trajectory-optimality numbers, and it states that accuracy and trajectory optimality are sacrificed [abstract].

Problem

Reaching in a cluttered, partly unknown space is hard for conventional pipelines. These pipelines combine sensing, state estimation, planning and feedback. Sampling-based planners such as PRM and RRT, and potential fields, are often run through inverse kinematics and high-gain joint-space PID. That makes the arm stiff and therefore sensitive to unknown obstacles §1. The paper's premise is that a controller which integrates planning and control can handle uncertainty more safely §1.

Method

Virtual model. A virtual model is a set of springs and dampers arranged in a mechanical structure and attached to the robot §2.1. Each virtual component produces a force \mathbf{f}_i at a robot point \mathbf{h}_i(\mathbf{q}). That force is mapped to joint torques through the Jacobian J_i(\mathbf{q}) = \partial \mathbf{h}_i / \partial \mathbf{q} §2.1. For a fully actuated robot, the torque command is the sum over all virtual components §2.1, eq. 1:

\boldsymbol{\tau} = \sum_i J_i(\mathbf{q})^\top \mathbf{f}_i eq. 1

Simple reaching (1). A spring of stiffness k and a damper of damping c join the end effector to a desired position \mathbf{x}_d §2.2. With \mathbf{x} = \mathbf{x}_d - \mathbf{x}_{EE} eq. 2:

\mathbf{f}_{EE} = k\,\mathbf{x} + c\,\dot{\mathbf{x}}, \qquad \mathbf{x} = \mathbf{x}_d - \mathbf{x}_{EE} eq. 2

The paper says this is classical PD control in end-effector space §2.2. Orientation is handled the same way with rotational springs and dampers §2.2.

Geometric reaching (2). The end effector connects through a spring and a damper to a virtual L-shaped body. That body has inertia I, rotates about the table, and has its own rotational spring k_\theta and damper c_\theta §2.2. The end-effector force then depends on the position g(\theta) set by the geometry of that body §2.2. The paper gives the equations for this design in §2.2 without a numbered label.

Moving-reference reaching (3). The target moves along a straight line from the start \mathbf{x}_0 to the goal \mathbf{x}_g: \mathbf{x}_d(t) = \mathbf{x}_0 + s(t)(\mathbf{x}_g - \mathbf{x}_0), with 0 \le s(t) \le 1. The scalar s(t) starts at zero and reaches one in finite time §2.2. The spring force of eq. 2 is then taken with the moving \mathbf{x}_d(t) §2.2. This limits the force needed to cover long distances.

Force-driven reaching (4). A virtual cart, with mass m and viscous friction b, is attached to the end effector through a spring and damper. The cart is pulled by a constant force \mathbf{f}_C along a straight path §2.2. Its dynamics are m\ddot{\mathbf{x}}_C + b\dot{\mathbf{x}}_C = \mathbf{f}_C + \mathbf{w}(\cdot), where \mathbf{w} is the reaction from the robot §2.2. If the end effector is blocked, the cart stops too, and the force the robot exerts is bounded by \mathbf{f}_C §2.2.

Obstacle avoidance (5, 6). Each obstacle is joined to the end effector by a repulsive, nonlinear spring and damper §2.3. The stiffness and damping grow as the separation shrinks §2.3. Forces from N obstacles add up §2.3. The spring is written with \mathbf{x}_i = \mathbf{x}_{EE} - \mathbf{x}_{o,i} and nonlinear k_i(|\mathbf{x}_i|) and c_i(\cdot) §2.3. Multiple obstacles use one spring per obstacle §4.2.

Control loop. The controller reads joint positions and velocities from the Dynamixel motors and updates each virtual mechanism's state, such as spring extension and damper velocity §3. It computes the virtual forces and maps them to torques with eq. 1 §3. The torques are converted to demanded currents with a linear approximation derived from the motor's performance graph §3. No inverse kinematics is used §3. The paper describes the loop in text and in a control-architecture figure fig. 3; no numbered algorithm is given.

# One control cycle of a virtual model controller  [§3] [eq. 1]
# Input:  joint_positions (n,), joint_velocities (n,), mechanisms
# Output: joint_currents (n,)

def control_step(joint_positions, joint_velocities, mechanisms):
    # Forward kinematics gives each attachment point and its Jacobian  [§3]
    points, jacobians = forward_kinematics(joint_positions)

    # Spring extensions and damper velocities from the robot state  [§3]
    states = mechanism_states(mechanisms, points, joint_velocities)

    # Virtual force of every spring and damper  [§2.2] [§2.3]
    forces = [mechanism_force(m, s) for m, s in zip(mechanisms, states)]

    # Sum the joint torques from all virtual forces  [eq. 1]
    torques = sum(J.T @ f for J, f in zip(jacobians, forces))

    # Linear torque-to-current approximation  [§3]
    joint_currents = torque_to_current(torques)
    return joint_currents

The pseudocode is written from the paper's text, not from a published algorithm. forward_kinematics, mechanism_states, mechanism_force and torque_to_current are placeholders. Their formulas are not stated in full beyond what is cited above.

Hyperparameters

Results

Author-reported. Hardware: Sciurus17 humanoid, 17 DoF, Dynamixel motors with current control, run from a standard computer §3. The paper reports no repetitions, variance or statistics §4. Only one baseline appears: PID in joint space with inverse kinematics, in the human-blocking test §4.3.

Paper vs code

No official code.

Searched: the paper, its bibliography and LaTeX source contain no code link. The arXiv abstract page lists no code, project page or comments [arxiv.org/abs/2610.05695]. A GitHub repository search for "virtual model control" and "virtual-model-control" was run, and a GitHub user search for "fulvio forni" returned one account with only a course fork. The closest hit, Cambridge-Control-Lab/VMRobotControl.jl (MIT), is a general Julia library for virtual model controllers. Its README names no authors and does not cite this paper. Its owner is not shown to be the authors' lab, so it is not used here.

Pitfalls

• Units of r in the obstacle spring are not stated §4.2. The three pieces meet at 5, 10 and 20 cm only if r is in centimetres: at r = 5 both the first and second pieces give 20 N/m, and at r = 10 both the second and third give 2 N/m. Treat centimetres as the working unit. This is an inference from continuity, not a statement in the paper.
• Notation for the obstacle damping is inconsistent. §2.3 writes c_i(|\mathbf{x}_i|) in one equation and c_i(|\dot{\mathbf{x}}_i|_i) in the text below it. The damping law is not given in either place. The stiffness growing as length shrinks is confirmed by the piecewise law in §4.2.
• Damping term for a moving target. eq. 2 uses \dot{\mathbf{x}} with \mathbf{x} = \mathbf{x}_d - \mathbf{x}_{EE}. §2.2 does not say whether the velocity term uses \dot{\mathbf{x}}_d when the target moves eq. 4, §2.2. Implement the error derivative \dot{\mathbf{x}}_d - \dot{\mathbf{x}}_{EE} only after checking the code, which is not available (see Paper vs code).
• Cause of the 5 cm error is unclear. §4.1 says the 5 cm error of the moving reference is "as in the previous case" due to low stiffness. The previous case is the 15 N/m simple reach §4.1, fig. 4, while the moving reference run uses 45 N/m §4.1, fig. 5. The paper also says the force at the end of the trajectory does not overcome friction §4.1. The stiffness explanation therefore does not clearly fit the run it is attached to.
• Friction dominates at low stiffness. At 15 N/m the spring force at the end of the reach does not overcome friction §4.1, fig. 4. Whether a given stiffness is enough depends on the robot's friction, which is not measured.
• Torque-to-current error. The paper attributes the y-axis deviation during fast transients to the linear torque-to-current approximation and to arm inertia §4.1. A high-speed implementation should expect this error. It is not quantified.
• No stability proof or gain conditions. §2.1 argues stability through passivity of the interconnection and cites general theory. The paper gives no stability condition on k, c or the obstacle law for the nonlinear springs. Check passivity of the chosen parameters yourself.
• Local minima of obstacle springs. For a non-convex obstacle union the end effector can stall in an elastic potential minimum §4.2. The paper offers no fix beyond "an improved design".
• Gravity and nonlinear dynamics. The torque map eq. 1 is only a Jacobian transpose mapping. The paper does not say whether gravity compensation or other dynamics compensation is applied on the Sciurus17 §3. Torque commands are converted to current, so gravity sag is a plausible issue to test.
• Hidden costs. Virtual mechanisms are designed by hand for each task and tuned by trial and error §5. The paper names optimal design and tuning as open problems §5.
• Single platform, single trials. All experiments use one humanoid arm and one run per condition as far as the text shows §4. Repetitions are not stated.
• Obstacle detection is not part of the experiments. Obstacle position and radius are entered by hand §3. Vision-based detection is described only as a possible extension §3.
• Baseline details. The IK-based PID comparison gives no gains, rates or tuning §4.3. The 35.77 N figure is therefore hard to reproduce.

Lineage

• Builds on: Pratt et al. 2001 introduced virtual model control for walking bipedal robots §5. That paper is not in the wiki, so no link is given.
• Related work named by the paper: impedance control in end-effector space §5, virtual components for simulated characters §5, and virtual instruments for robot laparoscopy by Larby et al. §5.
• Compared against: inverse-kinematics PID in joint space §4.3. Planners PRM, RRT and potential fields are named in the introduction §1 but not compared experimentally.
• Superseded by: not stated.