Skip to content

Self-Centering 3-Jaw Chuck ​

Self-Centering 3-Jaw Chuck, rendered in the brepjs playground
Mechanical · 205 lines▶ Run it in the playground

A 100 mm self-centring scroll chuck in cutaway, with a bar in its jaws. The key turns a bevel pinion, the pinion turns the scroll, and the spiral rib moves the three jaws by one pitch for each turn of the scroll, so the keyTurns parameter sets the grip diameter. The outline, the centring recess, the tapped mounting holes with their helical M8 thread, the key square and the 3.3 kg catalogue mass are published figures, and the kernel measures 2.69 kg. The scroll, the bevel teeth and the jaws are a display model.

Code ​

This is the full program. The playground runs it in your browser without a change.

ts
import { box, clone, compound, cut, cutAll, cylinder, extrude, face, fuse, fuseAll, getSolids, interpolateCurve, line, loft, measureVolume, polygon, revolve, rotate, translate, unwrap, wire } from 'brepjs/quick';
import { color } from 'brepjs/playground';

// 100 mm self-centring 3-jaw scroll chuck in cutaway, with a bar in the jaws. The axis is Z, units are millimetres.
// The outline, the mounting and the mass are published figures. The scroll, the bevel gears and the jaws are a display model.
interface ChuckParams {
  keyTurns?: number; // turns of the chuck key, 0 to 9. Each turn moves the three jaws by one sixth of the scroll pitch.
  cutaway?: number; // degrees of the body and the back plate to cut away (0 = closed chuck)
}

type P2 = [number, number];
type P3 = [number, number, number];
type Shape = ReturnType<typeof cylinder>;

// Kernel shapes live in WASM memory. Every temporary goes through own(). freeing() runs a build and then frees them all.
const owned: { delete(): void }[] = [];
const own = <T extends { delete(): void }>(s: T): T => {
  owned.push(s);
  return s;
};
const freeing = <T,>(build: () => T): T => { try { return build(); } finally { owned.splice(0).forEach((s) => s.delete()); } }; // also when the build throws

// ---- published figures (size 100, plain back)
const OD = 100;
const HEIGHT = 50; // body without the jaws
const JAW_TOP = 68; // height with the jaws
const BORE = 20;
const RECESS = { d: 70, depth: 3 }; // centring recess in the back
const MOUNT = { circle: 83, d: 8, minor: 6.647, pitch: 1.25, depth: 7, count: 3 }; // tapped M8 holes for screws from the rear, coarse thread, right hand
const KEY = 8; // square of the chuck key
const CATALOGUE_KG = 3.3;
const STEEL = 7.85e-3; // grams per cubic millimetre

// ---- display model
const SCROLL = { pitch: 6, r0: 17, turns: 4.15, z0: 24.9, z1: 31, top: 35, bore: 14.5, r: 43.5 }; // spiral: centre radius r0 + pitch for each turn
const GEAR = { pinion: 10, crown: 60, rIn: 31, rOut: 38, z: 17, backlash: 0.06 }; // bevel pair, apex on the chuck axis at height z
const BACK = 8; // thickness of the back plate
const JAW = { tip: 8, length: 36, half: 7, tongue: 10, tooth: 1.8 };
const MAX_TURNS = 9;
const TAU = 2 * Math.PI;
const TAN20 = Math.tan(TAU / 18);

const bx = (x0: number, x1: number, y0: number, y1: number, z0: number, z1: number): Shape =>
  own(box(x1 - x0, y1 - y0, z1 - z0, { at: [(x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2] }));
// A closed (r, z) profile, revolved about the axis.
const lathe = (pts: P2[], angle = TAU): Shape => own(unwrap(revolve(own(unwrap(polygon(pts.map(([r, z]): P3 => [r, 0, z])))), { axis: [0, 0, 1], angle }))) as Shape;
const ring = (r0: number, r1: number, z0: number, z1: number): Shape => lathe([[r0, z0], [r1, z0], [r1, z1], [r0, z1]]);
// A closed (x, y) outline, extruded from z0 to z1.
const plate = (pts: P2[], z0: number, z1: number): Shape => own(unwrap(extrude(own(unwrap(polygon(pts.map(([x, y]): P3 => [x, y, z0])))), z1 - z0))) as Shape;
const fused = (parts: Shape[]): Shape => own(unwrap(fuseAll(parts))) as Shape;
const minus = (s: Shape, tools: Shape[]): Shape => own(unwrap(cutAll(s, tools))) as Shape;
const about = (s: Shape, deg: number): Shape => own(rotate(s, deg) as Shape);
const thirds = (s: Shape, offset = 0): Shape[] => [0, 120, 240].map((a) => about(s, a + offset));
const volume = (s: Shape): number => unwrap(measureVolume(s));
// A ruled solid between two closed outlines.
const ruled = (a: P3[], b: P3[]): Shape => {
  const loop = (pts: P3[]) => own(unwrap(wire(pts.map((p, i) => own(line(p, pts[(i + 1) % pts.length]!))))));
  return own(unwrap(loft([loop(a), loop(b)]))) as Shape;
};
// The thread of a tapped hole about +Z: one helical tooth, a smooth loft, from the wall of the hole (radius major) in to the minor radius.
const holeThread = (major: number, minor: number, pitch: number, z0: number, z1: number): Shape => {
  const sections = 12; // in each turn
  const wall = major * 0.998; // a hair clear of the wall
  const half = 0.42 * pitch;
  const n = Math.round(((z1 - z0 - 2 * half) / pitch) * sections);
  const loops = Array.from({ length: n + 1 }, (_, j) => {
    const z = z0 + half + ((z1 - z0 - 2 * half) * j) / n;
    const a = (TAU * z) / pitch;
    const pts: P3[] = [[wall, -half], [minor, 0], [wall, half]].map(([r, dz]): P3 => [r! * Math.cos(a), r! * Math.sin(a), z + dz!]);
    return own(unwrap(wire(pts.map((p, i) => own(line(p, pts[(i + 1) % 3]!))))));
  });
  return own(unwrap(loft(loops, { ruled: false }))) as Shape;
};
// Scale a point toward the apex of the bevel pair.
const toApex = (k: number) => ([x, y, z]: P3): P3 => [x * k, y * k, GEAR.z + (z - GEAR.z) * k];

// Bevel pinion along +X: an involute outline at the large end, ruled toward the apex, with a journal and a key socket.
const bevelPinion = (): Shape => {
  const m = (2 * GEAR.rOut) / GEAR.crown;
  const rp = (m * GEAR.pinion) / 2;
  const rb = rp * Math.cos(TAU / 18);
  const inv = (r: number): number => { const a = Math.acos(Math.min(1, rb / r)); return Math.tan(a) - a; };
  const halfAt = (r: number): number => TAU / (4 * GEAR.pinion) - GEAR.backlash / rp + inv(rp) - inv(r); // half angle of a tooth at radius r
  const radii = [rp - 0.8 * m, rb, rb + 0.25 * (rp - rb), rp, rp + 0.5 * m, rp + m];
  const outline: P3[] = [];
  for (let t = 0; t < GEAR.pinion; t++) {
    const c = (t * TAU) / GEAR.pinion;
    const flank = radii.map((r): P2 => [r, halfAt(r)]);
    for (const [r, h] of flank) outline.push([GEAR.rOut, r * Math.sin(c - h), GEAR.z + r * Math.cos(c - h)]);
    for (const [r, h] of flank.reverse()) outline.push([GEAR.rOut, r * Math.sin(c + h), GEAR.z + r * Math.cos(c + h)]);
  }
  const teeth = ruled(outline, outline.map(toApex(GEAR.rIn / GEAR.rOut)));
  const neck = own(cylinder(rp - 0.9 * m, 1.2, { at: [GEAR.rOut - 0.5, 0, GEAR.z], axis: [1, 0, 0] }));
  const journal = own(cylinder(7, OD / 2 - 1 - GEAR.rOut, { at: [GEAR.rOut + 0.4, 0, GEAR.z], axis: [1, 0, 0] }));
  return minus(fused([teeth, neck, journal]), [bx(OD / 2 - 9, OD / 2, -KEY / 2, KEY / 2, GEAR.z - KEY / 2, GEAR.z + KEY / 2)]);
};

// One tooth of the crown gear on the back of the scroll: a rack tooth, ruled toward the apex.
const crownTooth = (): Shape => {
  const m = (2 * GEAR.rOut) / GEAR.crown;
  const zp = GEAR.z + GEAR.rOut / (GEAR.crown / GEAR.pinion); // pitch line at the large end
  const half = (h: number): number => (Math.PI * m) / 4 - GEAR.backlash + h * TAN20;
  const k = GEAR.rIn / GEAR.rOut;
  const root = 1.3 * m; // straight above this height, so that two teeth do not meet
  const up = (SCROLL.z0 + 0.4 - GEAR.z) / k + GEAR.z - zp; // the small end also goes into the plate
  const outer: P3[] = [[GEAR.rOut, -half(-0.55 * m), zp - 0.55 * m], [GEAR.rOut, half(-0.55 * m), zp - 0.55 * m], [GEAR.rOut, half(root), zp + root], [GEAR.rOut, half(root), zp + up], [GEAR.rOut, -half(root), zp + up], [GEAR.rOut, -half(root), zp + root]];
  return about(ruled(outer, outer.map(toApex(k))), 180 / GEAR.crown); // a space, not a tooth, at angle 0
};

function chuck({ keyTurns = 4.5, cutaway = 120 }: ChuckParams = {}) {
  const t = Math.min(Math.max(keyTurns, 0), MAX_TURNS);
  const scrollTurn = (-360 * t * GEAR.pinion) / GEAR.crown; // degrees. The key turns the scroll through the bevel pair.
  const travel = (-scrollTurn / 360) * SCROLL.pitch; // the law of the scroll: one pitch for each turn
  const grip = JAW.tip + travel;

  // Scroll: a plate with the spiral rib on the front and the crown gear on the back.
  const at = (a: number, side: number): P3 => {
    const r = SCROLL.r0 + (SCROLL.pitch * a) / TAU + (side * SCROLL.pitch) / 4;
    return [r * Math.cos(a), r * Math.sin(a), SCROLL.z1 - 0.5];
  };
  // One spline for each sixth of a turn. A long spline makes the booleans slow.
  const arcs = Math.ceil(SCROLL.turns * 6);
  const piece = (i: number, side: number, back: boolean) => {
    const pts = Array.from({ length: 5 }, (_, j) => at(((i + (back ? 1 - j / 4 : j / 4)) / arcs) * SCROLL.turns * TAU, side));
    return own(unwrap(interpolateCurve(pts)));
  };
  const count = Array.from({ length: arcs }, (_, i) => i);
  const end = SCROLL.turns * TAU;
  const band = own(unwrap(face(own(unwrap(wire([
    ...count.map((i) => piece(i, 1, false)), own(line(at(end, 1), at(end, -1))),
    ...count.reverse().map((i) => piece(i, -1, true)), own(line(at(0, -1), at(0, 1))),
  ]))) as never)));
  const rib = own(unwrap(extrude(band, SCROLL.top - SCROLL.z1 + 0.5))) as Shape;
  const tooth = crownTooth();
  const crown = Array.from({ length: GEAR.crown }, (_, i) => about(tooth, (i * 360) / GEAR.crown));
  const disc = fused([ring(SCROLL.bore, SCROLL.r, SCROLL.z0, SCROLL.z1), rib]);
  const scroll = rotate(own(unwrap(fuse(disc, own(compound(crown))))), scrollTurn) as Shape; // one boolean for all the teeth

  // Jaw: a stepped top, a base with two tongues, and three arc teeth. The teeth of each jaw are one third of a pitch further out.
  const mid = (MAX_TURNS / 2) * (SCROLL.pitch * GEAR.pinion) / GEAR.crown; // the teeth are true arcs at the middle of the travel
  const jaw = (n: number): Shape => {
    const x0 = JAW.tip;
    const x1 = JAW.tip + JAW.length;
    const side: P3[] = [[x0, 0, SCROLL.top], [x0, 0, JAW_TOP], [x0 + 12, 0, JAW_TOP], [x0 + 12, 0, JAW_TOP - 6], [x0 + 24, 0, JAW_TOP - 6], [x0 + 24, 0, JAW_TOP - 12], [x1, 0, JAW_TOP - 12], [x1, 0, SCROLL.top]];
    const body = own(unwrap(extrude(own(unwrap(polygon(side.map(([x, , z]): P3 => [x, -JAW.half, z])))), [0, 2 * JAW.half, 0]))) as Shape;
    const teeth = [0, 1, 2].map((k) => {
      const r = SCROLL.r0 + SCROLL.pitch * (n / 3 + k + 0.5) - (n === 2 ? SCROLL.pitch : 0) + mid;
      const arc = (rr: number, sign: number): P2[] => Array.from({ length: 7 }, (_, i): P2 => {
        const a = sign * Math.asin(5 / rr) * (i / 3 - 1);
        return [rr * Math.cos(a) - mid, rr * Math.sin(a)];
      });
      return plate([...arc(r + JAW.tooth / 2, 1), ...arc(r - JAW.tooth / 2, -1)], SCROLL.z1 + 0.5, SCROLL.top + 0.5);
    });
    const whole = fused([body, bx(x0, x1, -JAW.tongue, JAW.tongue, 39, 44), ...teeth]);
    return rotate(own(translate(whole, [travel, 0, 0])), 120 * n) as Shape;
  };
  const jaws = [0, 1, 2].map(jaw);

  // Pinions: three, between the jaws. The key turns one of them.
  const pinion = own(rotate(bevelPinion(), 360 * t, { at: [0, 0, GEAR.z], axis: [1, 0, 0] }) as Shape);
  const pinions = [60, 180, 300].map((a) => rotate(pinion, a) as Shape);

  // Body: a rim and a front with three T slots, on a hub that carries the scroll. The back plate closes it.
  const R = OD / 2;
  const blank = lathe([[BORE / 2, BACK], [R, BACK], [R, HEIGHT - 1.5], [R - 1.5, HEIGHT], ...[42, 32].flatMap((g): P2[] => [[g, HEIGHT], [g - 0.4, HEIGHT - 0.5], [g - 0.8, HEIGHT]]), [BORE / 2, HEIGHT]]);
  const slot = fused([bx(0, R + 1, -JAW.half, JAW.half, SCROLL.top, HEIGHT + 1), bx(0, R + 1, -JAW.tongue, JAW.tongue, 39, 44)]);
  const pocket = fused([own(cylinder(7.9, 14, { at: [30, 0, GEAR.z], axis: [1, 0, 0] })), own(cylinder(7, 8, { at: [43, 0, GEAR.z], axis: [1, 0, 0] }))]);
  const body = minus(blank, [ring(SCROLL.bore, SCROLL.r + 1, 21, SCROLL.top), ...thirds(slot), ...thirds(pocket, 60)]);
  const tapped = own(cylinder(MOUNT.d / 2, MOUNT.depth + 0.5, { at: [MOUNT.circle / 2, 0, -0.5] }));
  const threads = thirds(own(translate(holeThread(MOUNT.d / 2, MOUNT.minor / 2, MOUNT.pitch, 0, MOUNT.depth), [MOUNT.circle / 2, 0, 0]) as Shape));
  const back = minus(lathe([[BORE / 2, RECESS.depth], [RECESS.d / 2, RECESS.depth], [RECESS.d / 2, 0], [R - 1, 0], [R, 1], [R, BACK], [BORE / 2, BACK]]), thirds(tapped));

  // The bar in the jaws. It stands on the face of the chuck.
  const bar = cylinder(grip, 44, { at: [0, 0, HEIGHT] });

  // Mass from the kernel volumes of the complete chuck.
  const kg = ([scroll, ...jaws, ...pinions, body, back, ...threads].reduce((sum, s) => sum + volume(s), 0) * STEEL) / 1000;

  // Cutaway: a wedge of the body and the back plate, centred on +X.
  const wedge = own(rotate(lathe([[0, -1], [OD, -1], [OD, JAW_TOP], [0, JAW_TOP]], (Math.max(cutaway, 1) * Math.PI) / 180), -cutaway / 2) as Shape);
  const open = (s: Shape): Shape => (cutaway > 0 ? (unwrap(cut(s, wedge)) as Shape) : (translate(s, [0, 0, 0]) as Shape));
  // The thread of a hole that the cutaway removes goes with it. A hole on the cut shows its thread in section.
  const reach = (Math.asin(MOUNT.d / MOUNT.circle) * 360) / TAU + 0.5; // half angle of a hole
  const openThread = (s: Shape, n: number): Shape[] => {
    const from = Math.abs(n === 2 ? -120 : 120 * n) - cutaway / 2; // degrees from the cut face
    if (from < -reach) return [];
    if (cutaway <= 0 || from > reach) return [translate(s, [0, 0, 0]) as Shape];
    return getSolids(own(unwrap(cut(s, wedge)))).map((piece) => unwrap(clone(piece)) as Shape);
  };
  return { body: open(body), back: open(back), threads: threads.flatMap(openThread), scroll, jaws, pinions, bar, grip, travel, kg };
}

const part = freeing(() => chuck());
console.log('Jaw travel: ' + part.travel.toFixed(2) + ' mm from the scroll pitch. The jaws hold a bar of ' + (2 * part.grip).toFixed(1) + ' mm.');
console.log('Mass: ' + part.kg.toFixed(2) + ' kg from the kernel volumes. The catalogue has ' + CATALOGUE_KG + ' kg.');

export default [
  color(part.body, '#c3c9d1'),
  color(part.back, '#8d97a3'),
  ...part.threads.map((s) => color(s, '#8d97a3')),
  color(part.scroll, '#ff5a1f'),
  ...part.pinions.map((s) => color(s, '#12b5b0')),
  ...part.jaws.map((s) => color(s, '#48515c')),
  color(part.bar, '#d3a956'),
];

Functions used ​

box clone compound cut cutAll cylinder extrude face fuse fuseAll getSolids interpolateCurve line loft measureVolume polygon revolve rotate translate unwrap wire color

▶ Run Self-Centering 3-Jaw Chuck in the playground

Released under the Apache 2.0 License.