> Canonical HTML: https://kerfscript.mylasertools.com/models/tempo/

# Tempo anchor escapement

Tempo: a model of a Graham deadbeat escapement. A falling weight turns the escape wheel; its teeth push the two pallets of the anchor in turn, and the anchor swings the pendulum and lets the wheel on by half a tooth each beat. The hand stands dead still between beats. Wind the knob behind, start the pendulum swinging and set the beat with the crutch bolt.

This design has 75 parts on 5 sheets. Customize it in the [playground](https://kerfscript.mylasertools.com/playground/?model=tempo).

## Downloads

- [KerfScript source](https://kerfscript.mylasertools.com/models/tempo/tempo.kerf)
- [tempo-sheet-1.svg](https://kerfscript.mylasertools.com/models/tempo/tempo-sheet-1.svg)
- [tempo-sheet-1.dxf](https://kerfscript.mylasertools.com/models/tempo/tempo-sheet-1.dxf)
- [tempo-sheet-2.svg](https://kerfscript.mylasertools.com/models/tempo/tempo-sheet-2.svg)
- [tempo-sheet-2.dxf](https://kerfscript.mylasertools.com/models/tempo/tempo-sheet-2.dxf)
- [tempo-sheet-3.svg](https://kerfscript.mylasertools.com/models/tempo/tempo-sheet-3.svg)
- [tempo-sheet-3.dxf](https://kerfscript.mylasertools.com/models/tempo/tempo-sheet-3.dxf)
- [tempo-sheet-4.svg](https://kerfscript.mylasertools.com/models/tempo/tempo-sheet-4.svg)
- [tempo-sheet-4.dxf](https://kerfscript.mylasertools.com/models/tempo/tempo-sheet-4.dxf)
- [tempo-sheet-5.svg](https://kerfscript.mylasertools.com/models/tempo/tempo-sheet-5.svg)
- [tempo-sheet-5.dxf](https://kerfscript.mylasertools.com/models/tempo/tempo-sheet-5.dxf)

## Parts

| Part | Quantity | Size |
| --- | ---: | --- |
| Front plate | 1 | 223.2 × 380 mm |
| Front plate inner | 1 | 223.2 × 380 mm |
| Back plate | 2 | 223.2 × 380 mm |
| Base | 1 | 243.2 × 155.5 mm |
| Base lower | 1 | 243.2 × 155.5 mm |
| Pillar ring | 16 | 14 × 14 mm |
| Escape wheel | 2 | 142.6 × 143.2 mm |
| Anchor | 2 | 151.3 × 65.7 mm |
| Hand | 1 | 14 × 40.2 mm |
| Arbor spacer | 6 | 12 × 12 mm |
| Crutch | 2 | 22 × 78 mm |
| Pendulum rod | 2 | 14 × 255 mm |
| Bob face | 1 | 90 × 90 mm |
| Bob disc | 5 | 90 × 90 mm |
| Bob cheek | 4 | 37.7 × 88.8 mm |
| Click disc | 1 | 64 × 64 mm |
| Click ring | 1 | 64 × 64 mm |
| Ratchet wheel | 1 | 30 × 30 mm |
| Drum core | 3 | 10 × 10 mm |
| Drum flange | 1 | 44 × 44 mm |
| Winding knob | 2 | 34 × 34 mm |
| End collar | 1 | 16 × 16 mm |
| Weight base | 1 | 70 × 70 mm |
| Weight ring | 15 | 70 × 70 mm |
| Weight bail | 1 | 70 × 70 mm |
| Fit test | 1 | 130 × 52 mm |

## Settings

| Name | Default | Range or choices |
| --- | --- | --- |
| `pendulum_length` | `250` | 180 to 320 |
| `teeth` | `30` | 24 to 40 |
| `lift` | `3` | 2 to 4 |
| `bush_clearance` | `0.1` | 0 to 0.3 |
| `output` | `"all"` | All parts, Plates and base, Escape wheel and anchor, Crutch rod and bob, Drum ratchet and weight, Fit test |
| `amplitude` | `4` | 3 to 5.5 |
| `swing_phase` | `15` | 0 to 345 |
| `$thickness` | `3` | 2.8 to 3.2 |
| `$kerf` | `0.15` | 0 to 0.25 |

## Source

```kerf
// Tempo: a model of a Graham deadbeat escapement. A falling weight
// turns the escape wheel; its teeth push the two pallets of the anchor in
// turn, and the anchor swings the pendulum and lets the wheel on by half a
// tooth each beat. The hand stands dead still between beats. Wind the knob
// behind, start the pendulum swinging and set the beat with the crutch bolt.

/* [Clock] */
// Pendulum length in mm, from the anchor arbor to the centre of the bob
pendulum_length = 250; // [180:10:320]
// Teeth on the escape wheel; the wheel grows with them
teeth = 30; // [24:1:40]
// How far the impulse faces turn the anchor, in degrees
lift = 3; // [2:0.5:4]

/* [Fit] */
// Added to the 6 mm holes the brass bushes are glued into
bush_clearance = 0.1; // [0:0.05:0.3]

/* [Export] */
// All parts, or one group at a time
output = "all"; // [all:All parts, frame:Plates and base, escapement:Escape wheel and anchor, pendulum:Crutch rod and bob, drive:Drum ratchet and weight, coupon:Fit test]

/* [Assembly] */
// How far the pendulum swings each side in the assembled view, in degrees
amplitude = 4; // [3:0.5:5.5]
// Where the pendulum is in its swing, in degrees: 0 is hanging straight and moving right, 90 at the right end
swing_phase = 15; // [0:15:345]

/* [Material] */
// Sheet thickness
$thickness = 3; // [2.8:0.1:3.2]
// Beam width
$kerf = 0.15; // [0:0.01:0.25]

/* [Hidden] */
$material = "plywood";
$sheet = [600, 400];
$gap = 5;
$fn = 96;
t = $thickness;
L = pendulum_length;
N = teeth;
assert(L >= 180 && L <= 320, "Pendulum length: 180 to 320 mm");
assert(N == floor(N) && N >= 24 && N <= 40, "Teeth: whole numbers 24 to 40");
assert(lift >= 2 && lift <= 4, "Lift: 2 to 4 degrees");
assert(amplitude >= 3 && amplitude <= 5.5, "Amplitude: 3 to 5.5 degrees");
assert(bush_clearance >= 0 && bush_clearance <= 0.3, "Bush clearance: 0 to 0.3 mm");
assert(t >= 2.8 && t <= 3.2, "Thickness: 2.8 to 3.2 mm");
assert($kerf >= 0 && $kerf <= 0.25, "Kerf: 0 to 0.25 mm");
assert(contains(["all", "frame", "escapement", "pendulum", "drive", "coupon"], output), "Unknown output");

function polar(r, a) = [r * cos(a), r * sin(a)];
function rad(a) = a * PI / 180;

// Escapement, all angles in degrees. Every tooth is 15 mm from the next at
// the tips, so the wheel grows with its tooth count.
R = N * 15 / (2 * PI);
pitch_a = 360 / N;
// The anchor spans a whole number of teeth and a half: when one pallet holds
// a tooth, the other sits in a gap
span = floor(N / 4) + 0.5;
hs = span * pitch_a / 2;
// Anchor arbor above the wheel, where the lines to the two pallets touch
// the tip circle, so a tooth on a locking face pushes straight at the arbor
D = R / cos(hs);
rho = R * tan(hs);
// Lock: how far the anchor turns past a tooth before it can escape. Drop:
// how far the wheel turns free after each impulse. Swing: the largest
// pendulum swing the pallets are cut for.
lock = 1.5;
drop = 1.5;
swing = 5.5;
tip_w = 0.6;
tau = tip_w / R * 180 / PI;
// Pallet width in wheel degrees: half a tooth, less the drop
w = pitch_a / 2 - drop;
// The entry pallet unlocks at +c, the exit pallet at -c
c = (lift - lock) / 2;
// Tooth height: room for the deepest pallet at full swing
h = rad(swing - c + lift) * rho + 2;
Rr = R - h;
lean = 8;
d1 = h * tan(lean) / Rr * 180 / PI;
d2 = d1 + 0.33 * 15 / Rr * 180 / PI;

// Wheel tip positions, seen from the anchor arbor: where a tip locks and
// where it leaves each pallet
function tip(a) = polar(R, a) - [0, D];
function ang(p) = atan2(p[1], p[0]);
r_out = norm(tip(90 + hs + w / 2));
r_in = norm(tip(90 + hs - w / 2));
// Corners in the anchor's own frame: the anchor turns by +alpha, so a tip at
// world angle a meets the anchor at a - alpha
a_lock_e = ang(tip(90 + hs + w / 2)) - c;
a_end_e = ang(tip(90 + hs - w / 2)) - (c - lift);
a_lock_x = ang(tip(90 - hs + w / 2)) + c;
a_end_x = ang(tip(90 - hs - w / 2)) - (lift - c);
// The anchor's bow stays clear of the tips at full swing; the pallets reach
// up into it
band = R + rho * sin(swing) + 2;
ext = (band - R + 4) / rad(1) / rho - c;

// Frame: heights above the base top, depths forward from the back of the
// back plate. The plates are two plies, 4t + 1 apart.
gap = 4 * t + 1;
front_d = 2 * t + gap;
// Anchor arbor height: room for the bob below it, and for the wheel
zP = max(L + 70, D + R + 45);
zW = zP - D;
PW = 2 * (R + 40);
PH = zP + 54;
island = 0.45 * R;
pillars = [[-(PW / 2 - 12), zP + 34], [PW / 2 - 12, zP + 34], [-(PW / 2 - 12), zW - R - 20], [PW / 2 - 12, zW - R - 20]];
tabs = [-(PW / 2 - 32), PW / 2 - 32];
// Behind the back plate: a washer, a brass sleeve, the click disc and ring,
// then the drum, far enough back that the weight pot clears the plate
sleeve = 28;
core_r = 5;
core_d = -(1 + sleeve + 2 * t + 1.5 * t);
bob_d = 90;
period = 2 * PI * sqrt(L / 1000 / 9.81);
// How far the weight pot can fall, and how long that keeps it going
fall = zW - 40 - 17 * t;
run = fall / (2 * PI * core_r) * N * period;
// In front: the front face of the front plate, the hand on a washer, the
// crutch on two spacers and two washers, the rod and the bob round it
fp = front_d + 2 * t;
hand_d = fp + 1;
crutch_d = fp + 2 * t + 2;
rod_d = crutch_d + 2 * t;
bob_back = rod_d - 3 * t;
base_front = rod_d + 5 * t + 15;
base_back = -core_d + 35 + 12;

function fix2(v) = let (n = round(v * 100)) str(floor(n / 100), ".", n % 100 < 10 ? "0" : "", n % 100);
module label(s, p, size = 5) {
  score() translate(p) text(s, size = size, halign = "center", valign = "center");
}
module ring(od, id) {
  difference() {
    circle(d = od);
    circle(d = id);
  }
}

// Graham teeth: a straight front face leaning forward, so only the tip
// touches a locking face, and a curved back that leaves room for the
// pallets. The wheel turns clockwise from the front.
function tooth(k) = let (f = 90 + k * pitch_a) concat(
  [for (j = [1:5]) polar(Rr, f - pitch_a + d2 + j * (pitch_a + d1 - d2) / 6)],
  [polar(Rr, f + d1), polar(R, f), polar(R, f + tau)],
  [for (j = [1:8]) let (s = j / 8) polar(R - h * s, f + tau + d1 * s + (d2 - d1 - tau) * pow(s, 1.6))]
);

module escape_wheel() {
  difference() {
    polygon([for (k = [0:N - 1]) each tooth(k)]);
    circle(d = 4.1);
    // Six spokes
    for (k = [0:5]) offset(r = 3) offset(delta = -3) polygon(concat(
      [for (j = [0:6]) polar(15, k * 60 + 8 + j * 44 / 6)],
      [for (j = [6:-1:0]) polar(Rr - 7, k * 60 + 5 + j * 50 / 6)]));
  }
}

// Drawn with the anchor arbor at the origin and the wheel centre at
// [0, -D]. Each locking face is an arc round the arbor; each impulse face
// runs from the locking corner to a corner `lift` degrees deeper.
module anchor() {
  difference() {
    union() {
      circle(r = 11);
      translate([-8, -(D - band - 11)]) rect([16, D - band - 11]);
      polygon(concat(
        [for (j = [0:16]) [0, -D] + polar(band, 90 - hs - 9 + j * (2 * hs + 18) / 16)],
        [for (j = [16:-1:0]) [0, -D] + polar(band + 13, 90 - hs - 9 + j * (2 * hs + 18) / 16)]));
      // Entry pallet, on the left
      polygon(concat(
        [for (j = [0:8]) polar(r_out, a_lock_e - ext + j * ext / 8)],
        [polar(r_in, a_end_e)],
        [for (j = [0:8]) polar(r_in, a_end_e - j * (a_end_e - a_lock_e + ext) / 8)]));
      // Exit pallet, on the right
      polygon(concat(
        [for (j = [0:8]) polar(r_in, a_lock_x + j * ext / 8)],
        [for (j = [0:8]) polar(r_out, a_lock_x + ext - j * (a_lock_x + ext - a_end_x) / 8)]));
    }
    circle(d = 4.1);
  }
  label("IN", [0, -D] + polar(band + 6.5, 90 + hs - 2), 4);
  label("OUT", [0, -D] + polar(band + 6.5, 90 - hs + 2), 4);
}

module plate(front = false, outer = false) {
  difference() {
    union() {
      translate([-PW / 2, 0]) rect([PW, PH], r = 10);
      for (x = tabs) translate([x - 12, -2 * t]) rect([24, 2 * t + 1]);
    }
    for (p = [[0, zP], [0, zW]]) translate(p) circle(d = 6 + bush_clearance);
    for (p = pillars) translate(p) circle(d = 4.4);
    // Two windows onto the wheel and the pallets
    if (front) difference() {
      union() {
        translate([0, zW]) circle(r = R + 25);
        translate([0, zP]) circle(r = 30);
      }
      translate([0, zW]) circle(r = island);
      translate([0, zP]) circle(r = 15);
      translate([-9, 0]) rect([18, PH]);
    }
  }
  if (outer) {
    label("TEMPO", [0, zP + 42], 11);
    // One mark for every beat: the hand moves half a tooth each time
    for (k = [0:2 * N - 1]) score() hull() {
      translate([0, zW] + polar(island - 3, 90 - k * 180 / N)) circle(d = 0.4);
      translate([0, zW] + polar(island - (k % 5 == 0 ? 9 : 6), 90 - k * 180 / N)) circle(d = 0.4);
    }
  }
}

module base(top = false) {
  difference() {
    translate([-PW / 2 - 10, -base_front]) rect([PW + 20, base_front + base_back], r = 8);
    for (x = tabs) for (d = [0, front_d]) translate([x - 12.1, -d - 2 * t - 0.1]) rect([24.2, 2 * t + 0.2]);
  }
  if (top) {
    label("GRAHAM DEADBEAT ESCAPEMENT", [0, -base_front + 9], 5);
    label(str("WIND THE KNOB BEHIND, THEN SWING THE BOB ", round(swing - 2), " DEGREES"), [0, base_back - 9], 3.5);
  }
}

module hand() {
  difference() {
    union() {
      circle(r = 7);
      polygon([[-3, 0], [3, 0], [0.8, island - 6], [-0.8, island - 6]]);
      polygon([[-4, 0], [4, 0], [0, -14]]);
    }
    circle(d = 4.1);
  }
}

// The crutch is glued on the front of the anchor arbor. The rod hangs on
// bolt A and is held by bolt B in the curved slot: loosen B and swing the
// rod a little to put the clock in beat.
module crutch() {
  difference() {
    hull() {
      circle(r = 11);
      translate([0, -58]) circle(r = 9);
    }
    circle(d = 4.1);
    translate([0, -40]) circle(d = 3.4);
    for (a = [-10:2:10]) hull() {
      translate([0, -40] + polar(16, -90 + a)) circle(d = 3.4);
      translate([0, -40] + polar(16, -90 + a + 2)) circle(d = 3.4);
    }
  }
}

module rod() {
  difference() {
    translate([-7, -(L + 37)]) rect([14, L + 5], r = 3);
    translate([0, -40]) circle(d = 3.4);
    translate([0, -56]) circle(d = 3.4);
    hull() {
      translate([0, -(L - 27)]) circle(d = 4.4);
      translate([0, -(L + 27)]) circle(d = 4.4);
    }
  }
  // The top of the bob reads against these: higher is faster
  for (k = [-3:3]) score() hull() {
    translate([-6, -(L - bob_d / 2) + 5 * k]) circle(d = 0.4);
    translate([k == 0 ? 3 : -2, -(L - bob_d / 2) + 5 * k]) circle(d = 0.4);
  }
  label("F", [3.5, -(L - bob_d / 2) + 12], 3.5);
  label("S", [3.5, -(L - bob_d / 2) - 12], 3.5);
}

module bob_disc() {
  difference() {
    circle(d = bob_d);
    for (y = [-12, 12]) translate([0, y]) circle(d = 4.4);
  }
}

// Ratchet: the drum turns free on the arbor when you wind, and drives the
// click disc, glued to the arbor, when the weight pulls. Two flexible
// fingers in the click ring drop into the ratchet teeth.
rt = 12;
module ratchet() {
  difference() {
    polygon([for (k = [0:rt - 1]) each [polar(12.8, k * 30 + 2), polar(15, k * 30), polar(15, k * 30 + 3), polar(12.8, k * 30 + 26)]]);
    circle(d = 4.4);
  }
}

module click_ring() {
  difference() {
    union() {
      ring(64, 47);
      for (a = [0, 180]) {
        // Root block, finger and hook
        polygon(concat([for (j = [0:4]) polar(23.6, a - 14 + j * 3.5)], [for (j = [4:-1:0]) polar(17, a - 14 + j * 3.5)]));
        polygon(concat([for (j = [0:30]) polar(20, a + j * 5)], [for (j = [30:-1:0]) polar(17, a + j * 5)]));
        // The hook's end face lies on the line of a ratchet tooth's front
        polygon([polar(17.5, a + 150 - 2 * 2.5 / 2.2), polar(13.1, a + 150 + 2 * 1.9 / 2.2), polar(13.1, a + 147), polar(17.5, a + 132)]);
      }
    }
  }
}

// The assembled view. The pendulum and anchor turn alpha anticlockwise (seen
// from the front); the wheel turns theta clockwise from where it is drawn.
// With the exit pallet locked the wheel stands at theta_x; each impulse turns
// it on by the pallet width w while the anchor turns through the lift, then
// it drops onto the other pallet, half a tooth on.
alpha = amplitude * sin(swing_phase);
theta_x = (hs - w / 2) % pitch_a;
// Wheel turn after a pallet unlocks, u = 0 to 1 through the lift, kept a
// hair behind the impulse face
function impulse(u) = max(0, w * u - 0.05);
cycle = floor((swing_phase + 90) / 360);
psi = swing_phase - 360 * cycle;
theta = theta_x + pitch_a * cycle + (psi <= 90
    ? (alpha < -c ? 0 : alpha < lift - c ? impulse((alpha + c) / lift) : pitch_a / 2)
    : (alpha > c ? pitch_a / 2 : alpha > c - lift ? pitch_a / 2 + impulse((c - alpha) / lift) : pitch_a));
// A part in the plane of the plates, its origin at p (x, height above the
// base top) and its back face at depth d; world y points to the back
function at_front(p, d) = [p[0], -d, p[1] + 2 * t];
// Turned a degrees anticlockwise as seen from the front
function turned(a) = [90, -a, 0];
// A point of the pendulum, drawn with the anchor arbor at the origin
function swung(v) = [0, zP] + [v[0] * cos(alpha) - v[1] * sin(alpha), v[0] * sin(alpha) + v[1] * cos(alpha)];
click_d = -(1 + sleeve + t);
bob_at = swung([0, -L]);
// The weight pot hangs from the right of the drum, lower as the wheel turns
pot_top = zW + 2 * t - 40 - core_r * rad(theta);

if (output == "all" || output == "frame") step("Stand the plates in the base on the four pillar bolts") {
  part("Front plate", at = at_front([0, 0], fp - t), rotate = turned(0)) plate(true, true);
  part("Front plate inner", at = at_front([0, 0], front_d), rotate = turned(0)) plate(true, false);
  part("Back plate", qty = 2, at = [at_front([0, 0], 0), at_front([0, 0], t)], rotate = turned(0)) plate(false, false);
  part("Base", at = [0, 0, t]) base(true);
  part("Base lower", at = [0, 0, 0]) base(false);
  part("Pillar ring", qty = 16, at = [for (p = pillars, k = [0:3]) at_front(p, (2 + k) * t)], rotate = turned(0)) ring(14, 4.4);
}
if (output == "all" || output == "escapement") step("Fit the escape wheel and the anchor between the plates, and the hand in front") {
  part("Escape wheel", qty = 2, at = [for (k = [0:1]) at_front([0, zW], (3 + k) * t + 0.5)], rotate = turned(-theta)) escape_wheel();
  part("Anchor", qty = 2, at = [for (k = [0:1]) at_front([0, zP], (3 + k) * t + 0.5)], rotate = turned(alpha)) anchor();
  // The hand can go on the arbor at any angle; shown where the rod hides it least
  part("Hand", at = at_front([0, zW], hand_d), rotate = turned(-theta - 120)) hand();
  // Each side of the wheel and the anchor, and two under the crutch
  part("Arbor spacer", qty = 6, rotate = turned(0), at = [at_front([0, zW], 2 * t), at_front([0, zW], front_d - t),
    at_front([0, zP], 2 * t), at_front([0, zP], front_d - t), at_front([0, zP], fp), at_front([0, zP], fp + t)]) ring(12, 4.4);
}
if (output == "all" || output == "pendulum") step("Bolt the pendulum rod to the crutch and clamp the bob on") {
  part("Crutch", qty = 2, at = [for (k = [0:1]) at_front([0, zP], crutch_d + k * t)], rotate = turned(alpha)) crutch();
  part("Pendulum rod", qty = 2, at = [for (k = [0:1]) at_front([0, zP], rod_d + k * t)], rotate = turned(alpha)) rod();
  part("Bob face", at = at_front(bob_at, rod_d + 4 * t), rotate = turned(alpha)) {
    bob_disc();
    label(str("L ", L, " MM"), [0, 26], 5);
    label(str("T ", fix2(period), " S"), [0, -26], 5);
  }
  // Three behind the rod, two in front of it under the face
  part("Bob disc", qty = 5, at = [for (d = [0, 1, 2, 5, 6]) at_front(bob_at, bob_back + d * t)], rotate = turned(alpha)) bob_disc();
  // Either side of the rod, in its two layers
  part("Bob cheek", qty = 4, at = [for (k = [0:3]) at_front(bob_at, rod_d + floor(k / 2) * t)],
    rotate = [for (k = [0:3]) turned(alpha + 180 * (k % 2))]) intersection() {
      circle(d = bob_d);
      translate([7.3, -bob_d / 2]) rect([bob_d, bob_d]);
    }
}
if (output == "all" || output == "drive") step("Fit the winding drum behind and hang the weight pot on its string") {
  part("Click disc", at = at_front([0, zW], click_d), rotate = turned(-theta)) ring(64, 4.1);
  part("Click ring", at = at_front([0, zW], click_d - t), rotate = turned(-theta)) click_ring();
  part("Ratchet wheel", at = at_front([0, zW], click_d - t), rotate = turned(-theta)) ratchet();
  part("Drum core", qty = 3, at = [for (k = [1:3]) at_front([0, zW], click_d - (k + 1) * t)], rotate = turned(-theta)) ring(2 * core_r, 4.4);
  // Tie the string through the small hole
  part("Drum flange", at = at_front([0, zW], click_d - 5 * t), rotate = turned(-theta)) difference() {
    ring(44, 4.4);
    translate([0, core_r + 3]) circle(d = 1.6);
  }
  part("Winding knob", qty = 2, at = [for (k = [6:7]) at_front([0, zW], click_d - k * t)], rotate = turned(-theta)) difference() {
    union() {
      circle(r = 14);
      for (k = [0:11]) translate(polar(14, k * 30)) circle(r = 3);
    }
    circle(d = 4.4);
  }
  part("End collar", at = at_front([0, zW], click_d - 8 * t), rotate = turned(-theta)) ring(16, 4.1);
  part("Weight base", at = [core_r, -core_d, pot_top - 17 * t]) circle(d = 70);
  part("Weight ring", qty = 15, at = [for (k = [0:14]) [core_r, -core_d, pot_top - (16 - k) * t]]) ring(70, 54);
  part("Weight bail", at = [core_r, -core_d, pot_top - t]) difference() {
    union() {
      ring(70, 54);
      translate([-32, -5]) rect([64, 10]);
    }
    circle(d = 3);
  }
}
if (output == "all" || output == "coupon") part("Fit test", at = [PW / 2 + 40, -base_front, 0]) {
  difference() {
    rect([130, 52], r = 3);
    for (i = [0:3]) translate([16 + 26 * i, 16]) circle(d = 6 + 0.1 * i);
    for (i = [0:2]) translate([16 + 26 * i, 38]) circle(d = 4 + 0.1 * i);
    translate([92, 38]) circle(d = 4.4);
    translate([106, 38]) circle(d = 3.4);
    translate([118, 30]) rect([2 * t + 0.2, 16], center = true);
  }
  for (i = [0:3]) score() translate([16 + 26 * i, 4]) text(str(6 + 0.1 * i), size = 3, halign = "center");
  for (i = [0:2]) score() translate([16 + 26 * i, 26]) text(str(4 + 0.1 * i), size = 3, halign = "center");
}

echo(str("Tempo: pendulum ", L, " mm, period ", fix2(period), " s (2 pi root L/g), a tick every ", fix2(period / 2), " s; ", N, " teeth on a ", round(2 * R), " mm wheel, once round in ", round(N * period), " s; anchor spans ", span, " teeth, lift ", lift, ", lock ", lock, ", drop ", drop, " degrees; about ", round(run), " s per wind"));

// Assembly, depths forward from the back of the back plate: glue the
// laminates (each plate, the base, wheel, anchor, crutch and rod of 2; the
// bob of 3 discs, the 4 cheeks in two layers, 2 discs and the face; the knob
// of 2; the weight pot of base, 15 rings and bail). Glue 6 mm brass tube
// bushes into the arbor holes and stand both plates in the base on four M4 x
// 35 pillar bolts, 4 rings and a 1 mm washer on each. Epoxy the wheel and the
// anchor to 4 mm steel rod arbors between the plates, a spacer each side. In
// front go the hand on a washer and, on the anchor arbor, two spacers, two
// washers and the crutch. Behind: a washer, a 28 mm brass tube sleeve, the
// click disc and ring (epoxied to the arbor), then ratchet, three cores,
// flange and knob glued together and free to turn, and the end collar. Bolt
// the rod to the crutch with two M3 bolts, clamp the bob on with two M4 bolts
// and wing nuts, and hang the pot, with 200 to 500 g of sand or nuts in it,
// on string tied to the flange and wound on the cores.
```

Set power, speed and cut order in your laser software. See the [laser software guide](https://kerfscript.mylasertools.com/docs/compatibility/index.md).
