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

# Helix Archimedes screw marble lift

Helix: an Archimedes screw marble lift. Turn the crank and a screw of 120 stacked plates, each a step round from the last on a square bar, pushes 16 mm marbles up a trough of dowels. At the top they drop onto a chute and roll back down a zig-zag track behind the screw to a ramp that feeds the screw again near the bottom.

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

## Downloads

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

## Parts

| Part | Quantity | Size |
| --- | ---: | --- |
| Screw plate | 120 | 39.5 × 25.9 mm |
| Journal | 4 | 20 × 20 mm |
| Collar | 4 | 32 × 32 mm |
| Crank | 2 | 55 × 22 mm |
| Grip ring | 4 | 18 × 18 mm |
| Board | 1 | 312 × 348 mm |
| Base | 1 | 380 × 150 mm |
| Lower end plate | 2 | 100 × 58 mm |
| Upper end plate | 2 | 100 × 58 mm |
| Exit rib | 1 | 51.2 × 36.8 mm |
| Track floor 1 | 1 | 244.9 × 27 mm |
| Track rail 1 | 1 | 241.9 × 10 mm |
| Track floor 2 | 1 | 249.9 × 27 mm |
| Track rail 2 | 1 | 246.9 × 10 mm |
| Track floor 3 | 1 | 199.7 × 27 mm |
| Track rail 3 | 1 | 196.7 × 10 mm |
| End wall 1 | 1 | 27 × 13 mm |
| End wall 2 | 1 | 27 × 37.2 mm |
| End wall 3 | 1 | 27 × 37.5 mm |
| Exit floor | 1 | 32 × 79.3 mm |
| Exit wall | 2 | 79 × 17 mm |
| Exit front wall | 1 | 26 × 10 mm |
| Intake floor | 1 | 26 × 29.8 mm |
| Intake wall | 1 | 30 × 14.7 mm |
| Intake back wall | 1 | 30 × 39.9 mm |
| Ramp | 1 | 70 × 60.1 mm |
| Fit test | 1 | 150 × 60 mm |

## Settings

| Name | Default | Range or choices |
| --- | --- | --- |
| `flight` | `2` | Two plates, Three plates |
| `crank_radius` | `35` | 30 to 40 |
| `bar_clearance` | `0.2` | 0.1 to 0.3 |
| `bearing_clearance` | `0.4` | 0.3 to 0.6 |
| `crank_angle` | `90` | 0 to 360 |
| `output` | `"all"` | All parts, Screw and crank, Board base and end plates, Track chutes and ramp, Fit test |
| `$thickness` | `3` | 2.8 to 3.2 |
| `$kerf` | `0.15` | 0 to 0.25 |

## Source

```kerf
// Helix: an Archimedes screw marble lift. Turn the crank and a screw of 120
// stacked plates, each a step round from the last on a square bar, pushes
// 16 mm marbles up a trough of dowels. At the top they drop onto a chute and
// roll back down a zig-zag track behind the screw to a ramp that feeds the
// screw again near the bottom.

/* [Screw] */
// Plates the flight tooth spans: two leaves a longer pocket, three is stronger
flight = 2; // [2:Two plates, 3:Three plates]
// Crank handle radius
crank_radius = 35; // [30:5:40]

/* [Fit] */
// Added to the 10 mm square bar in every star-shaped hole
bar_clearance = 0.2; // [0.1:0.05:0.3]
// Added to the 20 mm journals in the end plate bearings
bearing_clearance = 0.4; // [0.3:0.1:0.6]

/* [Assembly] */
// Crank angle in the assembled view, anticlockwise seen from the crank; one
// turn lifts every marble one pitch
crank_angle = 90; // [0:15:360]

/* [Export] */
// All parts, or one group at a time
output = "all"; // [all:All parts, screw:Screw and crank, frame:Board base and end plates, track:Track chutes and ramp, coupon:Fit test]

/* [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;
D = 16;
assert(flight == 2 || flight == 3, "Flight: 2 or 3 plates");
assert(crank_radius >= 30 && crank_radius <= 40, "Crank radius: 30 to 40 mm");
assert(bar_clearance >= 0.1 && bar_clearance <= 0.3, "Bar clearance: 0.1 to 0.3 mm");
assert(bearing_clearance >= 0.3 && bearing_clearance <= 0.6, "Bearing clearance: 0.3 to 0.6 mm");
assert(crank_angle >= 0 && crank_angle <= 360, "Crank angle: 0 to 360 degrees");
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", "screw", "frame", "track", "coupon"], output), "Unknown output");

// The screw: plates 3 mm apart, each turned 30 degrees on from the last, so
// the flight climbs a 36 mm pitch in 12 plates. Tip radius 27.5, core 12.
plates = 120;
step = 30;
pitch = 12 * t;
tip = 27.5;
core = 12;
// Four 6 mm dowels on a 34 mm radius, at these angles from the bottom of
// the screw towards the front. The marble rides between the first two;
// the others only keep it in.
rod_r = 34;
rods = [0, 20, 45, 70];

// Assembly coordinates: x along the base, y towards the board, z up. The
// screw axis rises at 45 degrees from s = 0, the inner face of the lower end
// plate, 70 mm above the table. s is measured along the axis.
tilt = 45;
z0 = 70;
ct = cos(tilt);
st = sin(tilt);
avec = [ct, 0, st];
// Down the face of the end plates, and up it
dvec = [st, 0, -ct];
vvec = [-st, 0, ct];
function ax(s) = [s * ct, 0, z0 + s * st];
// D below the axis along the end plate, Y towards the board
function pt(s, Dn, Y) = ax(s) + dvec * Dn + [0, Y, 0];
// Along the axis: collars and screw, the end plates and the exit gap
s_screw = 0.5 + t;
s_top = s_screw + plates * t;
s_upper = s_top + t + 0.5;
// The two trough dowels stop at the exit rib; past it the marble falls
s_exit = s_upper - 33;
// The board's front face, and where the track runs in front of it
board_y = 58;
track_y = 34;

// Rotations as 3 x 3 matrices, turned into rotate = [x, y, z] by euler()
function mm(A, B) = [for (i = [0:2]) [for (j = [0:2]) A[i][0] * B[0][j] + A[i][1] * B[1][j] + A[i][2] * B[2][j]]];
function rz(r) = [[cos(r), -sin(r), 0], [sin(r), cos(r), 0], [0, 0, 1]];
// Parts square to the screw: drawn x towards the board, y up the end plate,
// thickness up the axis. The lower end's parts face down the axis instead,
// so their engraved side shows.
up_axis = [[0, vvec[0], avec[0]], [1, 0, 0], [0, vvec[2], avec[2]]];
down_axis = [[0, vvec[0], -avec[0]], [-1, 0, 0], [0, vvec[2], -avec[2]]];
// A feature drawn along +x lands at angle a round the screw, measured from
// the bottom towards the front, the way the screw turns
function turned_up(a) = euler(mm(up_axis, rz(-90 - a)));
function turned_down(a) = euler(mm(down_axis, rz(a - 90)));
theta = crank_angle;
// The ramp beside the trough: parallel to the axis, sloping 20 degrees down
// to the lowest dowel and just clear of the flight
kappa = 20;
ramp_d = 29 / cos(kappa);
ramp_e = [-sin(kappa) * st, cos(kappa), sin(kappa) * ct];
ramp_n = [-cos(kappa) * st, -sin(kappa), cos(kappa) * ct];
ramp_frame = [[avec[0], ramp_e[0], ramp_n[0]], [0, ramp_e[1], ramp_n[1]], [avec[2], ramp_e[2], ramp_n[2]]];
function ramp_l(Y) = Y / cos(kappa);

// Chutes: floors level along x and sloping 1 in 10 across. The exit chute
// catches the marble under the top of the screw; the intake chute takes it
// off the track to the ramp.
beta = atan(0.1);
function ze(y) = 262 - 0.1 * (y + 15);
function zi(y) = 120 + 0.1 * (y - 31);
hole_x = 271;
hole_y = 47.5;
// Track: three legs at a 0.085 slope. At each turn a marble on the lower
// leg passes 2 mm under the floor of the one above.
slope = 0.085;
sigma = atan(slope);
drop = t + D + 2;
l1 = ze(hole_y) - t / cos(beta) - D - 1;
function top1(x) = l1 + slope * (x - hole_x);
function top2(x) = top1(40) - drop - slope * (x - 40);
function top3(x) = top2(270) - drop + slope * (x - 270);
// [left end, right end, top at the left, rising to the right]. Each leg
// stops 17 mm short of the end wall below, room for a marble to drop past.
// The last stops over the intake's front wall, so a marble rolls off its
// end into the chute and the back wall stops it.
legs = [[40, 284, top1(40), 1], [19, 268, top2(19), -1], [89, 288, top3(89), 1]];

module ring(d, inner) {
  difference() {
    circle(d = d);
    circle(d = inner, $fn = 48);
  }
}

// Twelve-pointed hole: three squares 30 degrees apart, so a plate fits the
// square bar in any of twelve positions 30 degrees apart
module star_hole() {
  for (a = [0, 30, 60]) rotate(a) rect(10 + bar_clearance, center = true);
}

// One plate of the screw, its tooth along +x
module screw_plate() {
  g = flight * step;
  difference() {
    union() {
      circle(r = core);
      offset(r = 2) offset(delta = -2) polygon(concat(
        [for (i = [0:12]) let (a = -g / 2 + g * i / 12) [tip * cos(a), tip * sin(a)]],
        [for (i = [12:-1:0]) let (a = -g / 2 + g * i / 12) [9 * cos(a), 9 * sin(a)]]));
    }
    star_hole();
  }
  score() line([core + 2, 0], [tip - 3, 0]);
}

module round_part(d) {
  difference() {
    circle(d = d);
    star_hole();
  }
}

// Drawn in the down-axis frame; the arrow shows the way to turn it
module crank() {
  difference() {
    hull() {
      circle(r = 11);
      translate([crank_radius, 0]) circle(r = 9);
    }
    star_hole();
    translate([crank_radius, 0]) circle(d = 4.4, $fn = 32);
  }
  score() {
    translate([13, -3.5]) text("TURN", size = 4);
    line([crank_radius - 4, -6], [crank_radius - 4, 6]);
    line([crank_radius - 4, 6], [crank_radius - 6, 3]);
    line([crank_radius - 4, 6], [crank_radius - 2, 3]);
  }
}

// x towards the board, y up the plate, the axis at the origin
function rod_uv(a) = [-rod_r * sin(a), -rod_r * cos(a)];
module end_plate() {
  difference() {
    union() {
      hull() {
        circle(r = 17);
        for (a = rods) translate(rod_uv(a)) circle(r = 7);
        translate([0, -38]) rect([board_y, 52]);
      }
      for (v = [[-34, -20], [-6, 8]]) translate([board_y - 1, v[0]]) rect([t + 1, v[1] - v[0]]);
    }
    circle(d = 20 + bearing_clearance);
    for (a = rods) translate(rod_uv(a)) circle(d = 6.2, $fn = 32);
  }
}

// Holds the ends of the trough dowels. Its edge stays clear of the marble
// over the trough and of the flight elsewhere.
module exit_rib() {
  function arc(r, a0, a1) = [for (i = [0:16]) let (a = lerp(a0, a1, i / 16)) [-r * sin(a), -r * cos(a)]];
  difference() {
    polygon(concat(arc(41, -15, 82), arc(29.5, 82, 30), arc(33.5, 30, -15)));
    for (a = rods) translate(rod_uv(a)) circle(d = 6.2, $fn = 32);
  }
}

// x along the axis from s = 30, y up the slope from the axis' plane. Wide
// at the bottom, where a tab reaches the board; narrow beside the intake.
// A marble landing on it rolls down until the flight below catches it.
module ramp() {
  // The back edge stops where its lower corner meets the board
  lb = (board_y - t * sin(kappa)) / cos(kappa);
  le = (board_y + t - 0.05 - t * sin(kappa)) / cos(kappa);
  polygon([[0, ramp_l(3.5)], [70, ramp_l(3.5)], [70, ramp_l(29.5)], [32, ramp_l(29.5)], [32, lb],
    [28, lb], [28, le], [14, le], [14, lb], [0, lb]]);
}

// A track floor, length along the slope, 24 wide from the rail to the board
module leg_floor(L) {
  rect([L, board_y - track_y]);
  for (x = [12, L / 2 - 10, L - 32]) translate([x, board_y - track_y - 1]) rect([20, t + 1]);
}

// Chute side wall, drawn in y and z where it stands: on the floor line z(y)
// from y0 to the board, h tall, with a tab into the board
module chute_wall(z, y0, h, chamfer = 0) {
  polygon(concat([for (y = [y0, board_y]) [y, z(y)]],
    [[board_y, z(board_y) + 3], [board_y + t, z(board_y) + 3], [board_y + t, z(board_y) + 9.5], [board_y, z(board_y) + 9.5]],
    chamfer > 0 ? [[board_y, z(board_y) + h], [y0 + chamfer, z(y0 + chamfer) + h], [y0, z(y0) + h - chamfer]]
      : [[board_y, z(board_y) + h], [y0, z(y0) + h]]));
}

// A chute floor, x from x0 to x1, l up its slope; the tab reaches y = 61
module chute_floor(x0, x1, L, le, tab0, tab1) {
  translate([x0, 0]) rect([x1 - x0, L]);
  translate([tab0, L - 1]) rect([tab1 - tab0, le - L + 1]);
}

// End wall of a leg, standing across the channel on the floor at zb
module end_wall(zb, zt) {
  polygon([[track_y, zb], [board_y, zb], [board_y, zb + 3], [board_y + t, zb + 3], [board_y + t, zt - 3], [board_y, zt - 3], [board_y, zt], [track_y, zt]]);
}

// Slots, in the board's x and z, for a tab drawn in a turned frame
module slot_in(p, a, x0, x1, y0, y1, c = 0.12) {
  translate([p[0], p[2]]) rotate(a) translate([x0 - c, y0 - c]) rect([x1 - x0 + 2 * c, y1 - y0 + 2 * c]);
}

function leg_theta(g) = -g[3] * sigma;
function leg_origin(g) = [g[0] - t * sin(leg_theta(g)), track_y, g[2] - t * cos(leg_theta(g))];
function leg_len(g) = (g[1] - g[0]) / cos(sigma);
function leg_top(i, x) = i == 0 ? top1(x) : i == 1 ? top2(x) : top3(x);

// The backboard, drawn in x and z, with every slot that holds the frame
module board() {
  difference() {
    union() {
      translate([-20, t]) rect([312, 348 - t], r = 6);
      for (x = [-10, 120, 250]) translate([x, 0]) rect([30, t + 0.5]);
    }
    // End plates, both plies
    for (s0 = [-2 * t, s_upper]) for (v = [[-34, -20], [-6, 8]]) slot_in(ax(s0), tilt, 0, 2 * t, v[0], v[1]);
    // The ramp's tab passes the board at 20 degrees
    let (dmin = ramp_d - ((board_y + t - 0.05 - t * sin(kappa)) / cos(kappa)) * sin(kappa), dmax = ramp_d - board_y * tan(kappa) + t / cos(kappa))
      slot_in(ax(44), tilt, 0, 14, -dmax, -dmin);
    // Track floors and the end walls on them
    for (i = [0:2]) let (g = legs[i], L = leg_len(g)) for (x = [12, L / 2 - 10, L - 32])
      slot_in(leg_origin(g), -leg_theta(g), x, x + 20, 0, t);
    for (w = [[284 - t, top1(284), 13], [19, top2(19), top1(40) + 18 - top2(19)], [288 - t, top3(288), top2(270) + 18 - top3(288)]])
      slot_in([w[0], 0, w[1]], 0, 0, t, 3, w[2] - 3);
    // Chute floors and walls
    slot_in([262, 0, ze(board_y + t) - t / cos(beta)], 0, 0, 18, 0, ze(board_y) - ze(board_y + t) + t / cos(beta), 0.15);
    slot_in([68, 0, zi(board_y) - t / cos(beta)], 0, 0, 16, 0, zi(board_y + t) - zi(board_y) + t / cos(beta), 0.15);
    for (x = [255, 287 - t]) slot_in([x, 0, ze(board_y) + 3], 0, 0, t, 0, 6.5);
    for (x = [63, 89 - t]) slot_in([x, 0, zi(board_y) + 3], 0, 0, t, 0, 6.5);
  }
  engrave() translate([86, 290]) text("HELIX", size = 34, halign = "center");
  score() translate([86, 272]) text("ARCHIMEDES SCREW MARBLE LIFT", size = 6, halign = "center");
}

module base() {
  difference() {
    translate([-75, -75]) rect([380, 150], r = 6);
    for (x = [-10, 120, 250]) translate([x - 0.12, board_y - 0.12]) rect([30.24, t + 0.24]);
  }
  score() translate([-60, -64]) text("16 MM MARBLES  /  TURN THE CRANK ANTICLOCKWISE", size = 5);
}

module coupon() {
  difference() {
    rect([150, 60], r = 3);
    for (i = [0:2]) translate([20 + 25 * i, 42]) for (a = [0, 30, 60]) rotate(a) rect(10.1 + 0.1 * i, center = true);
    for (i = [0:3]) translate([18 + 30 * i, 16]) circle(d = 20.3 + 0.1 * i);
    for (i = [0:2]) translate([97 + 12 * i, 44]) circle(d = 6.1 + 0.1 * i, $fn = 32);
    translate([138, 40]) rect([t + 0.24, 14], center = true);
  }
  score() {
    translate([33, 52]) text("BAR +0.1 +0.2 +0.3", size = 3, halign = "center");
    translate([109, 52]) text("6.1 6.2 6.3", size = 3, halign = "center");
    translate([63, 2]) text("20.3   20.4   20.5   20.6", size = 3, halign = "center");
  }
}

// Placements of the parts that turn with the crank, at angle theta
ramp_at = ax(30) + dvec * (ramp_d + t * cos(kappa)) + [0, t * sin(kappa), 0];
// Outside face of the lower outer collar; the crank plies go on below it
crank_s = -3 * t - 0.5;
handle = dvec * (crank_radius * cos(theta)) + [0, -crank_radius * sin(theta), 0];

// The assembly steps, listed first so they number in build order
step("Glue the screw plates on the square bar, each turned one point on from the last");
step("Slide on the end plates, glue the journals in with a collar each side, and the crank plies below");
step("Push the trough dowels through the end plates, the lower two into the exit rib");
step("Glue the end plates, the floors, the end walls and the ramp into the board, and the board into the base");
step("Glue the rails and the chute walls onto the floors");
step("Bolt the grip on the crank");
if (output == "all" || output == "screw") {
  step("Glue the screw plates on the square bar, each turned one point on from the last")
    part("Screw plate", qty = plates, at = [for (j = [0:plates - 1]) ax(s_screw + j * t)],
      rotate = [for (j = [0:plates - 1]) turned_up(theta - step * j)]) screw_plate();
  step("Slide on the end plates, glue the journals in with a collar each side, and the crank plies below") {
    // Two in each bearing; the lower pair face down the axis
    part("Journal", qty = 4, at = [ax(0), ax(-t), ax(s_upper), ax(s_upper + t)],
      rotate = [turned_down(theta), turned_down(theta), turned_up(theta), turned_up(theta)]) round_part(20);
    // Inside and outside each end plate
    part("Collar", qty = 4, at = [ax(0.5), ax(-2 * t - 0.5), ax(s_top), ax(s_upper + 2 * t + 0.5)],
      rotate = [turned_up(theta), turned_down(theta), turned_up(theta), turned_up(theta)]) round_part(32);
    part("Crank", qty = 2, at = [ax(crank_s), ax(crank_s - t)], rotate = turned_down(theta)) crank();
  }
  // On a 6 mm sleeve over the handle bolt, below the crank and a washer
  step("Bolt the grip on the crank")
    part("Grip ring", qty = 4, at = [for (k = [0:3]) ax(crank_s - 2 * t - 0.8 - k * t) + handle], rotate = turned_down(theta)) ring(18, 6.4);
}
if (output == "all" || output == "frame") {
  step("Glue the end plates, the floors, the end walls and the ramp into the board, and the board into the base") {
    part("Board", at = [0, board_y + t, 0], rotate = [90, 0, 0]) board();
    part("Base", at = [0, 0, 0]) base();
  }
  step("Slide on the end plates, glue the journals in with a collar each side, and the crank plies below") {
    part("Lower end plate", qty = 2, at = [ax(0), ax(-t)], rotate = euler(down_axis)) mirror([1, 0]) end_plate();
    part("Upper end plate", qty = 2, at = [ax(s_upper), ax(s_upper + t)], rotate = euler(up_axis)) end_plate();
  }
  step("Push the trough dowels through the end plates, the lower two into the exit rib")
    part("Exit rib", at = ax(s_exit - t), rotate = euler(up_axis)) exit_rib();
}
if (output == "all" || output == "track") {
  for (i = [0:2]) let (g = legs[i], L = leg_len(g)) {
    step("Glue the end plates, the floors, the end walls and the ramp into the board, and the board into the base")
      part(str("Track floor ", i + 1), at = leg_origin(g), rotate = [0, leg_theta(g), 0]) leg_floor(L);
    // Rails stop at the end walls
    step("Glue the rails and the chute walls onto the floors")
      let (x0 = i == 1 ? g[0] + t : g[0], x1 = i == 1 ? g[1] : g[1] - t)
        part(str("Track rail ", i + 1), at = [x0, track_y + t, leg_top(i, x0)], rotate = [90, leg_theta(g), 0])
          rect([(x1 - x0) / cos(sigma), 10]);
  }
  step("Glue the end plates, the floors, the end walls and the ramp into the board, and the board into the base") {
    part("End wall 1", at = [284 - t, 0, 0], rotate = [90, 0, 90]) end_wall(top1(284), top1(284) + 13);
    part("End wall 2", at = [19, 0, 0], rotate = [90, 0, 90]) end_wall(top2(19), top1(40) + 18);
    part("End wall 3", at = [288 - t, 0, 0], rotate = [90, 0, 90]) end_wall(top3(288), top2(270) + 18);
    // The exit chute runs from in front of the trough to the board; the
    // marble rolls back and drops through the hole onto the first leg
    let (L = (board_y + 18) / cos(beta), le = (board_y + t - 0.1 + 18) / cos(beta))
      part("Exit floor", at = [0, -18 - t * sin(beta), ze(-18) - t * cos(beta)], rotate = [-beta, 0, 0])
        difference() {
          chute_floor(255, 287, L, le, 262, 280);
          translate([hole_x, (hole_y + 18) / cos(beta)]) circle(d = 20);
        }
  }
  step("Glue the rails and the chute walls onto the floors") {
    part("Exit wall", qty = 2, at = [[255, 0, 0], [287 - t, 0, 0]], rotate = [90, 0, 90]) chute_wall(function(y) ze(y), -18, 10, 6);
    part("Exit front wall", at = [0, -15, 0], rotate = [90, 0, 0]) translate([255 + t, ze(-18)]) rect([32 - 2 * t, 10]);
  }
  step("Glue the end plates, the floors, the end walls and the ramp into the board, and the board into the base")
    let (L = (board_y - 31 - t * sin(beta)) / cos(beta), le = (board_y + t - 0.4 - 31) / cos(beta))
      part("Intake floor", at = [0, 31 + t * sin(beta), zi(31) - t * cos(beta)], rotate = [beta, 0, 0])
        chute_floor(63, 89, L, le, 68, 84);
  step("Glue the rails and the chute walls onto the floors") {
    part("Intake wall", at = [89 - t, 0, 0], rotate = [90, 0, 90]) chute_wall(function(y) zi(y), 31, 12);
    // Tall enough to catch a marble flying off the last leg
    part("Intake back wall", at = [63, 0, 0], rotate = [90, 0, 90]) chute_wall(function(y) zi(y), 31, top3(89) + 18 - zi(31));
  }
  step("Glue the end plates, the floors, the end walls and the ramp into the board, and the board into the base")
    part("Ramp", at = ramp_at, rotate = euler(ramp_frame)) ramp();
}
// The fit test lies on the table beside the base
if (output == "all" || output == "coupon") part("Fit test", at = [330, -60, 0]) coupon();

echo(str("Helix: ", plates, " plates on a 10 mm square bar, ", pitch, " mm pitch, ", plates / 12, " turns; lifts ",
  round(((s_exit - 55) * st) * 10) / 10, " mm; track legs at ", round(sigma * 10) / 10, " degrees"));

// Assembly: thread the screw plates onto a 10 mm square bar (aluminium or
// hardwood, 395 mm), each turned one point of its star (30 degrees) on from
// the last, always the same way, and glue them; the scored lines spiral
// round. Glue a collar at each end of the stack. Glue each pair of end
// plates, slide them on, then glue two journals into each bearing (free to
// turn in it), a collar outside each, and the two crank plies outside the
// lower collar. Push four 6 mm dowels through both end plates; the two
// lowest end in the exit rib, 33 mm short of the upper plate. Glue the end
// plates, chutes, track floors, end walls and ramp into the board, the board
// into the base, and the rails and walls onto the floors. The grip is four
// rings on a 6 mm brass sleeve, on an M4 x 25 bolt through the crank with a
// washer each side and a nyloc nut. Turn the crank anticlockwise as you face
// it, and drop 16 mm glass marbles into the intake chute.
```

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