Robot Gripper Simulator: Grip Force and Crush

Controls

Every control re-evaluates the whole grasp on input, so the plot tracks a slider as you drag it. There is nothing to start.

The left panel is the grasp. Each shaded wedge is a friction cone drawn about the contact’s face normal, and the dashed line between the contacts is the grasp line — it has to lie inside both cones or the object is ejected. The zig-zag between the dashed commanded jaw position and the pad on the object is the series compliance being deflected: that deflection is the grip force.

The right panel is what you get for what you command. The sloped line is F = k·Δc until the servo runs out and it goes flat. The green band is the usable window, the comb along the bottom axis is one servo step per tooth, and a tooth turns green when it lands inside the window. If none of them do, there is no setting that works.

Theory

A two-finger gripper has one knob and two walls, and the knob is not in the same units as the walls.

The walls are forces. Below the slip floor the object falls out; above the crush ceiling it is destroyed:

slip    n·μ·N  ≥  m·(g + a)·SF          →   N ≥ m(g + a)·SF / (μ·n)
crush   N ≤ F_crush

with n = 2 contacts. The acceleration term is not decoration — an arm swinging a load imparts several g at the tool, and it is the load case that actually matters. There is a third wall the servo puts in: N ≤ τ/L · k_duty, where L is the lever arm from horn centre to contact and k_duty derates the stall torque to what the motor can hold without cooking. So the real ceiling is min(F_crush, τ·k_duty/L).

The knob is a position. A position-controlled servo commands jaw travel, not force. What converts one into the other is the series stiffness k of everything between the horn and the object — linkage flex, finger flex, the pad, the object itself:

N = k · Δc          Δc = how far past first contact you drove the jaws

So the usable window, in the units you can actually command, is:

Δc_window = ( min(F_crush, τ·k_duty/L) − m(g + a)·SF/(μ·n) ) / k

and it scales as 1/k. That is the whole design. A rigid printed finger is around 25 N/mm; a foam pad puts about 4 N/mm in series; an extension spring, 0.8; a printed flexure, 0.35. Against that, a servo resolves about one degree, so it moves the jaws L·(π/180) per step — 0.524 mm on a 30 mm arm. Compare the two numbers and the answer is not close:

The third failure has nothing to do with force at all. Two point contacts with friction hold only if the line joining them lies inside both friction cones. For parallel jaws on a tapered object that reduces to:

holds  iff  tan(taper) < μ

N is nowhere in it. Squeezing harder does not help, has never helped, and is the first thing everyone tries. The full derivation is in friction, force closure and why two contacts is a bet.

Algorithm

There is no integration here — it is algebra, plus one call into the site’s motion planner so the lift acceleration is a real S-curve rather than a number somebody guessed. Each evaluation, in this order:

1. The servo’s force ceiling. F_stall = τ / L, then derate: F_cont = F_stall · 0.7.
2. Plan the lift with the S-curve planner, and take its peak acceleration.
3. The squeeze. demand = k · Δc, then N = min(demand, F_cont) — because the servo gives up before the spring does.
4. The demand, twice. needStill = m·g·SF/(μ·2) and needMoving = m·(g + a_peak)·SF/(μ·2). The gap between them is what the move costs.
5. The window. floor = needMoving, ceiling = min(F_crush, F_cont), and divide both by k to get the closure range you can command.
6. The resolution check. step = L·(π/180). If window < step there is no setting, and the lab says so rather than reporting a margin nobody can hit.
7. Force closure, independently of all of the above: tan(taper) < μ.
8. Walk the lift sample by sample, comparing the demand at that instant’s acceleration against the constant N you are holding with, and record the first moment it loses.

Step 8 is the only place time appears, and both sides of its comparison are normal forces — a subtlety worth stating because getting it wrong (comparing the friction force 2μN against a demand that has already been divided by μ) double-counts friction and reports every grasp failing while standing still.

Guided experiments

Each one isolates a single variable. Run them in order; they build.

1. A grasp that works

Load A grasp that works — a strawberry in printed flexure fingers, jaws driven 2 mm past contact. Grip force 0.70 N against 0.29 N needed and a 3 N crush limit. The window is 7.739 mm and 15 distinct servo positions land inside it.

What to observe: the green band on the right panel is wide, and fifteen teeth of the comb are green. This is what “designed” looks like: you could be a whole millimetre out in either direction and nothing would change.

2. The same berry, rigid fingers

Press P, or load The same berry, rigid fingers. Nothing about the object changed. The finger went from 0.35 N/mm to 25 N/mm.

What to observe: the window is 71× narrower, because 25/0.35 is 71. It scales as exactly 1/k, and you can check that by dragging the stiffness slider and watching the two numbers move against each other. Below one servo step, the comb has no green tooth and the verdict stops offering a margin, because there is not one.

3. The accidental clutch

Set the finger back to rigid and cycle the object with the O key: wooden block, M6 bolt, egg, PET bottle, paper cup, strawberry. Watch Settings that work.

What to observe: the “positions that work” column is zero for every object in the lab, and yet four of the six are held perfectly well. That is not a contradiction — it is the whole mechanism of a hobby gripper. A rigid gripper never lands inside its window; it overshoots and sits pinned at the servo’s own force ceiling of 4.11 N, and that works because 4.11 N happens to be below the crush limit of a block, a bolt, an egg and a bottle. The servo is acting as a clutch you did not design and cannot adjust. Push Servo stall torque up towards an MG996R and watch the egg row fail too: a bigger servo makes the gripper worse, because the accidental clutch moves up past the object.

The cost of holding that way is on the Servo load readout: 70% of stall, continuously, which is roughly 0.49 A through an SG90 that is not turning. That is how hobby servos die.

4. Squeeze harder, lose it anyway

Load A taper friction cannot hold: a bottle with 28° faces at μ 0.45, so the friction cone is ±24.2° and the grasp line falls outside it. Now drag Jaw closure from 0.5 mm to the top of its range.

What to observe: ten times the force, identical verdict, because N cancels out of tan(taper) < μ. Now leave the closure alone and drag μ instead. At 0.50 the cone is ±26.6° and it still ejects; at 0.53 it is ±27.9° and still ejects; at 0.55 the cone reaches ±28.8°, passes the 28° taper, and the grasp holds — at whatever force you happened to leave it. Watch the cone wedges on the left panel open past the dashed grasp line as you drag. Two hundredths of μ is the difference, and squeezing was never in the argument.

5. Sized on the bench, gone on the swing

Load Sized on the bench, gone on the swing: an egg in sprung fingers, 1.89 N of grip against 1.63 N needed standing still. It holds. Press the arm into a 250 mm lift in 0.9 s and it does not.

What to observe: the grip force never changed. The only thing that moved was the move. Slowing the lift from 0.9 s to 1.5 s fixes a grasp that a bench test said was fine, and it fails 40 ms into the move — before the arm has travelled a centimetre, which is why it looks like the gripper “just dropped it”. The shaded strip between the dashed standing still line and the solid slip floor on the right panel is exactly what the acceleration costs you.

6. The lever arm buys two things and sells a third

Set the object to the wooden block, the finger to padded, and drag Finger lever arm.

What to observe: short is better on both axes the lab measures — five times the force and five times finer resolution, from the same servo. The last column is the one the lab does not compute, because it is plain arithmetic: jaw travel is L·θ, so a 12 mm arm sweeping 120° opens 25 mm and cannot reach around a 65 mm bottle at all. The lever arm is sized by the largest thing you need to pick up, and force and resolution are whatever falls out. That is the trade, and it is why serious grippers use a linkage instead of bolting the finger to the horn.

7. What the safety factor actually costs

Back on the working berry-and-flexure preset, drag Safety factor from 1 to 6.

What to observe: the slip floor rises and the crush ceiling does not move, so the window narrows from 8.16 mm to 6.07 mm — 16 workable positions down to 12. A 6× safety factor costs you a quarter of your window and nothing else, which is cheap when there is 8 mm of it. On the rigid finger, where there is 0.1 mm, the same factor is the difference between a number and nothing. Compliance is what makes a safety factor affordable.

What you should observe

Pulling the seven together:

• Two walls in newtons, one knob in millimetres. The exchange rate is k, and it is the only number in the gripper you get to choose freely.
• The window scales as 1/k. Not approximately. Halve the stiffness, double the window, exactly.
• The wall is the servo’s step, not your patience. Below L·(π/180) there is no setting, and no firmware change reaches it.
• A rigid gripper works by stalling. It overshoots the window onto the servo’s force ceiling, and survives only while that ceiling is below the object’s crush limit. A bigger servo raises the ceiling and starts breaking things.
• Force closure ignores force. tan(taper) < μ is a geometry test, and squeezing is not in it.
• Grasps are sized on the move, not the pick. The acceleration term dominates as soon as the arm is quick.

Taking it to hardware

The twenty minutes is worth it for experiment 3. Everyone building a first gripper reaches for stiffer fingers when things slip, and experiment 3 is the argument that the stiffness was already the problem.

Source code

Sizing a gripper is four lines of arithmetic you should run before you print anything.

// --- what the servo can push with ---
const float TAU_STALL = 0.176f;   // N·m, SG90 at 4.8 V — derate for 6 V, derate more when warm
const float DUTY      = 0.70f;    // what it can hold without cooking itself
const float LEVER_MM  = 30.0f;    // horn centre to the contact patch. MEASURE THIS.

float jawForceN() { return (TAU_STALL * DUTY) / (LEVER_MM / 1000.0f); }

// --- what the object demands ---
// F = m(g + a)·SF / (mu · n).  `a` is the arm's peak acceleration, not zero.
float requiredN(float massKg, float mu, float peakAccel, float safety) {
  return (massKg * (9.80665f + peakAccel) * safety) / (mu * 2.0f);
}

// --- the check nobody runs ---
// A servo step of one degree moves the jaws L·(pi/180). If the force window
// divided by the series stiffness is smaller than that, no command works.
bool aimable(float crushN, float slipN, float stiffnessNperMM) {
  float windowMM = (min(crushN, jawForceN()) - slipN) / stiffnessNperMM;
  float stepMM   = LEVER_MM * (PI / 180.0f);
  return windowMM > stepMM;
}

And the drive itself, once the arithmetic says the design is possible. Command the closed position and let the compliance take up the difference — do not try to stop at the object:

const int OPEN_US   = 1900;
const int CLOSED_US = 1300;   // past contact, deliberately. The spring absorbs it.

void grip(bool closed) {
  gripper.writeMicroseconds(closed ? CLOSED_US : OPEN_US);
  delay(400);                 // it is a position loop with no feedback to you
}

There is no force feedback in that and there does not need to be, provided the window is wider than one step. That is the whole argument for compliance, and it is why a 40p extension spring replaces a load cell on most builds. When you do want to know whether the grasp worked, the cheapest answer is a microswitch on the finger rather than current sensing — the pick-and-place state machine covers where to put the check.