How to simulate the friction between an irregular cable and a soft robot.

[3H2Oaaa]

Hi，everyone！
This is a problem that has been bothering me for a long time: I want to simulate a cable-driven soft robot, where the cable passes through the soft robot and presents an irregular curve. Now I want to simulate the friction between this cable and the soft robot. I tried using the Cosserat plugin to simulate this cable, but the generated cable is always a straight line, rather than the curve I want. What should I do? Are there tools that can let me customize the shape of the cable? I tried selecting some points in the soft robot and forcefully constraining the cable to these points, but once the simulation starts, powerful forces are generated inside the model that "tear" the whole model apart, causing the simulation to crash."

[hugtalbot]

Hi @3H2Oaaa

That's a very interesting point you are doing. So far the Cable Constraint is not allowing for having friction along the cable, as far as I know. Is there plan to cover such usecases @EulalieCoevoet @adagolodjo ?

[adagolodjo]

Hi @3H2Oaaa,

Welcome to the community!

• Regarding pre-bent cables with Cosserat, you can follow the tutorial here: tuto and example 2 with the bending_states parameter.

• Regarding cable friction with the environment, :-), I remember discussing this with @EulalieCoevoet a month ago. I'll let @EulalieCoevoet answer that, whether it's already been done or not.

If not, we know what needs to be done, we just haven't had the time yet. If you have a day, I think we can work on a first version that's only in Python.

Thank you @hugtalbot for tagging us.

[EulalieCoevoet]

Nothing has been implemented, no.

[3H2Oaaa]

@EulalieCoevoet @hugtalbot @adagolodjo
Hi everyone,

Thanks for the replies! Actually, I implemented a similar feature in Python about a week ago with the help of AI. Here is my implementation logic:

Point Selection & Initial Tension: I selected a series of points on the model to represent the cable path and applied an initial tensile force to the first node.

Force Calculation via Capstan Equation: Using the Capstan equation (to account for the tension loss due to friction over curved surfaces), I calculated the force at each node. Specifically, I determined the tension from both the preceding and succeeding nodes to compute the resultant force acting on each point.

Force Application: I used the ConstantForceField component to apply these calculated resultant forces to the respective cable points.

Force Mapping: Finally, I used the BarycentricMapping component to map these forces from the points onto the model's mesh. This effectively simulates the friction interaction between the cable and the environment.

[3H2Oaaa]

The following code is the controller I implemented, which mimics my simulation scenario. My objective is to regulate the model's bending sequence by specifically designing the cable channels. The cable is initially configured in a U-shape. For the forward path, the model accounts for kinetic friction (a portion of which is currently commented out). For the return path, I incorporate both kinetic and static friction. The reason for including static friction is that I have designed specific channels along the return path to increase the maximum static friction. This allows me to control the order of tension propagation, thereby managing the bending sequence of the model.`

def onAnimateBeginEvent(self, event):

# --- 0. Power Source: Smooth Tension Ramp-up ---
dt = self.mo_fwd.getContext().dt.value
if self.current_motor_F < self.max_F:
    self.current_motor_F += self.F_rate * dt
    self.current_motor_F = min(self.current_motor_F, self.max_F)
    print(f"[Unified Tendon] Current Motor Tension: {self.current_motor_F:.2f} N")

# ==========================================
# --- 1. Forward Path (fwd): Classic Nodal Resultant Force + Kinetic Friction Decay ---
# ==========================================
pos_fwd = self.mo_fwd.position.value
num_fwd = len(pos_fwd)
forces_fwd = np.zeros((num_fwd, 3))

current_T_fwd = self.current_motor_F

for i in range(num_fwd):
    p_i = pos_fwd[i]
    F_i = np.zeros(3)
    u_in, u_out = np.zeros(3), np.zeros(3)

    # 1.1 Calculate u_in (Direction toward the base)
    if i > 0:
        v_in = pos_fwd[i - 1] - p_i
        norm_in = np.linalg.norm(v_in)
        if norm_in > 1e-8: u_in = v_in / norm_in
    else:
        v_temp = pos_fwd[1] - pos_fwd[0]
        norm_temp = np.linalg.norm(v_temp)
        if norm_temp > 1e-8: u_in = -(v_temp / norm_temp)

    # 1.2 Calculate u_out (Direction toward the tip)
    if i < num_fwd - 1:
        v_out = pos_fwd[i + 1] - p_i
        norm_out = np.linalg.norm(v_out)
        if norm_out > 1e-8: u_out = v_out / norm_out

    # 1.3 Capstan Equation for kinetic friction decay (Excludes static friction to prevent abrupt zeroing)
    # if i > 0 and i < num_fwd - 1:
    #     # Incoming direction is -u_in, outgoing direction is u_out
    #     cos_angle = np.clip(np.dot(-u_in, u_out), -1.0, 1.0)
    #     theta = np.arccos(cos_angle)
    #
    #     # Pure kinetic friction exponential decay
    #     T_next = current_T_fwd * np.exp(-self.mu * theta)
    # else:
    #     # Points 0 and the last node do not calculate internal wrap angle loss separately
        T_next = current_T_fwd

    # 1.4 Core: Classic Bowstring Force (No local squeeze)
    # Formula: F_i = T_in * u_in + T_out * u_out
    F_i += current_T_fwd * u_in
    if i < num_fwd - 1:
        F_i += T_next * u_out

    forces_fwd[i] = F_i

    # Propagate the attenuated tension downstream
    current_T_fwd = T_next

# ==========================================
# --- 2. Bridging & Return Path (ret): Local Squeeze + Static Friction Truncation ---
# ==========================================
# current_T_fwd now represents the actual tension reaching the tip 
# after undergoing kinetic friction decay along the forward path.
T_transfer = current_T_fwd

pos_ret = self.mo_ret.position.value
num_ret = len(pos_ret)
forces_ret = np.zeros((num_ret, 3))

# 2.1 Physical Completion: Bridging tension at the U-turn
v_bridge = pos_ret[0] - pos_fwd[-1]
norm_bridge = np.linalg.norm(v_bridge)
if norm_bridge > 1e-8:
    u_bridge = v_bridge / norm_bridge
    forces_fwd[-1] += T_transfer * u_bridge
    forces_ret[0] -= T_transfer * u_bridge

# 2.2 Segmented compression and mixed static/kinetic friction loss on return path
current_T_ret = T_transfer

for i in range(num_ret - 1):
    p_i = pos_ret[i]
    p_next = pos_ret[i + 1]

    v_seg = p_next - p_i
    norm_seg = np.linalg.norm(v_seg)
    if norm_seg < 1e-8:
        continue
    u_seg = v_seg / norm_seg

    # --- Return Path: Mixed Friction State Machine ---
    if current_T_ret <= self.f_static:
        # Static friction lock: Tension fails to propagate to the next segment
        T_seg = current_T_ret
        T_next = 0.0
    else:
        T_seg = current_T_ret
        if i > 0:
            v_prev = pos_ret[i] - pos_ret[i - 1]
            u_prev = v_prev / np.linalg.norm(v_prev)
            cos_angle = np.clip(np.dot(u_prev, u_seg), -1.0, 1.0)
            theta = np.arccos(cos_angle)
        else:
            u_bridge_dir = v_bridge / norm_bridge if norm_bridge > 1e-8 else u_seg
            cos_angle = np.clip(np.dot(u_bridge_dir, u_seg), -1.0, 1.0)
            theta = np.arccos(cos_angle)

        # Subtract the static friction baseline, then apply kinetic friction decay
        T_next = (current_T_ret - self.f_static) * np.exp(-self.mu * theta)

    # --- Return Path Specific: Local Squeeze ---
    forces_ret[i] += T_seg * u_seg
    forces_ret[i + 1] -= T_seg * u_seg

    current_T_ret = T_next

    if current_T_ret <= 0:
        break

# --- 3. Unified Update of Force Field Data ---
self.ff_fwd.forces.value = forces_fwd.tolist()
self.ff_ret.forces.value = forces_ret.tolist()`

[3H2Oaaa]

The application of this controller is as follows:
robotNode.addObject(UnifiedTendonController( name='UnifiedController', mo_fwd=fwdNode.dofs, ff_fwd=fwdForceField, mo_ret=retNode.dofs, ff_ret=retForceField, max_F=10, F_rate=0.5, f_static=0.3, mu=0.045 ))

[adagolodjo]

Hi @3H2Oaaa,

Great! You can create a Python scene with this and submit a pull request. This will be your contribution to the plugin, and others will be able to benefit from it and improve it if needed.

Let me know if you'll have time to work on it.

Best regards,