Models / Ascent marble lift
Ascent marble lift
Ascent: a hand-cranked marble lift. Turn the crank clockwise and a pocket in the laminated wheel carries one marble up the left side, over the top and down to an opening in the shroud on the right, where it drops out and rolls down a sloping chute into a covered catch box.
40 parts on 10 sheets, shown together. Each sheet has its own cut file.
Source
// Ascent: a hand-cranked marble lift. Turn the crank clockwise and a pocket
// in the laminated wheel carries one marble up the left side, over the top
// and down to an opening in the shroud on the right, where it drops out and
// rolls down a sloping chute into a covered catch box.
/* [Mechanism] */
// Measured diameter of the marble; sets the pockets and the wheel thickness
marble_diameter = 16; // [14:1:18]
// Radius of the pocket wheel
wheel_radius = 110; // [105:5:115]
// Number of pockets round the wheel
pockets = 6; // [5, 6]
/* [Material] */
// Sheet thickness
$thickness = 3; // [2.8:0.1:3.2]
// Beam width
$kerf = 0.15; // [0:0.01:0.25]
/* [Assembly] */
// Crank angle in the assembled view, clockwise seen from the front
crank_angle = 0; // [0:5:360]
/* [Export] */
// All parts, or one group at a time
output = "all"; // [all:All parts, wheel:Wheel and crank, frame:Frame, chute:Chute and catch, coupon:Fit test]
/* [Hidden] */
$material = "plywood";
$sheet = [600, 400];
$gap = 5;
$fn = 144;
t = $thickness;
D = marble_diameter;
R = wheel_radius;
// Centre of the round end of each pocket
pocket_r = R - D - 4;
pocket_w = D + 2;
// Wheel layers: at least the marble plus 2 mm thick. The shroud has one
// more, so the wheel has half a sheet to spare on each side.
layers = ceil((D + 2) / t);
cheek_gap = (layers + 1) * t;
outer = R + 20;
// Shaft height above the base
axle_height = R + 110;
assert(D >= 14 && D <= 18, "Marble: 14 to 18 mm");
assert(R >= 105 && R <= 115, "Wheel radius: 105 to 115 mm");
assert(pockets == 5 || pockets == 6, "Pockets: 5 or 6");
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(crank_angle >= 0 && crank_angle <= 360, "Crank angle: 0 to 360 degrees");
assert(contains(["all", "wheel", "frame", "chute", "coupon"], output), "Unknown output");
module hole(p, d = 4.4) {
translate(p) circle(d = d, $fn = 48);
}
module ring(d, inner) {
difference() {
circle(d = d);
circle(d = inner, $fn = 48);
}
}
module capsule(a, b, r) {
hull() {
translate(a) circle(r = r);
translate(b) circle(r = r);
}
}
// Part of an annulus between radii r1 and r2, from angle a to angle b
module sector(a, b, r1, r2) {
polygon(concat(
[for (i = [0:40]) let (q = lerp(a, b, i / 40)) [r2 * cos(q), r2 * sin(q)]],
[for (i = [40:-1:0]) let (q = lerp(a, b, i / 40)) [r1 * cos(q), r1 * sin(q)]]
));
}
// Six M4 bolts through the cheeks and shroud, none in the release opening
module bolt_holes() {
for (a = [0, 60, 120, 180, 240, 285]) hole([(R + 13) * cos(a), (R + 13) * sin(a)]);
}
// Each pocket is a slot open at the rim: the marble rests in its round end
// on the way up and slides out against the shroud on the way down. The
// rounded slots between the pockets only take weight off.
module wheel() {
difference() {
circle(r = R);
hole([0, 0], 6.5);
for (i = [0:pockets - 1]) rotate(-90 + i * 360 / pockets) union() {
translate([pocket_r, 0]) circle(d = pocket_w);
translate([pocket_r, -pocket_w / 2]) rect([R - pocket_r + 3, pocket_w]);
}
for (a = [0:360 / pockets:359]) rotate(a) capsule([30, 0], [pocket_r - 24, 0], 6);
}
score() translate([-16, 0]) text("CW", size = 6);
}
// A ring 2 mm clear of the wheel keeps the marble in its pocket, except
// between -65 and -25 degrees, where it lets the marble out to the chute
module shroud() {
difference() {
circle(r = outer);
circle(r = R + 2);
sector(-65, -25, R + 1, outer + 2);
bolt_holes();
}
}
// The chute's side walls are part of the cheeks: 24 mm high above the floor
// line y = -110 - 0.25 (x - 65), a 1 in 4 slope that stays clear of the wheel
module chute_side() {
polygon([[65, -110], [258, -158.25], [258, -134.25], [65, -86]]);
}
// Both cheeks, seen from the front with the shaft at the origin: the round
// cover, the stand down to the base, the chute wall and a leg under it. The
// front one has windows onto the wheel, slots too narrow for the marble to
// pass, and the loading port under the gate.
module cheek(front = false) {
difference() {
union() {
circle(r = outer);
translate([-75, -axle_height]) rect([150, axle_height - outer + 12]);
chute_side();
translate([194, -axle_height]) rect([12, axle_height - 130]);
}
// For an 8 mm bush
hole([0, 0], 8.2);
bolt_holes();
if (front) {
for (a = [0:60:300]) sector(a + 12, a + 48, 24, pocket_r - D / 2 - 6);
// Viewing slots round the rim, none at the bottom where the loading
// port and the gate's pivot are
for (a = [-180, -60, 0, 60, 120]) sector(a + 8, a + 48, R - D / 2 - 4, R - D / 2 + 2);
// Loading port, in line with a pocket pointing straight down
hole([0, -(R + 2 - D / 2)], D + 2);
hole([D / 2 + 13, -(R + 2 - D / 2)]);
}
}
if (front) score() translate([0, -170]) text("ASCENT", size = 8, halign = "center");
if (front) score() translate([65, -56]) text("PAUSE", size = 4);
}
module base() {
difference() {
translate([90, 0]) rect([450, 110], center = true, r = 4);
// Optional holes to clamp the base down; the gussets are glued
for (x = [-60, 60]) for (y = [-35, 35]) hole([x, y]);
for (x = [125, 185]) for (y = [-35, 35]) hole([x, y]);
}
score() translate([-120, 40]) text("ONE MARBLE / CLOCKWISE / MANUAL RELOAD", size = 4);
}
module catch_square() {
rect([50, 50], center = true);
}
module catch_wall(w) {
rect([w, 22], center = true);
}
module gusset() {
difference() {
polygon([[0, 0], [40, 0], [0, 55]]);
hole([10, 12]);
}
}
// Swings on an M4 pivot to uncover the loading port; a wingnut holds it shut
module gate() {
difference() {
hull() {
circle(d = D + 12);
translate([D / 2 + 13, 0]) circle(d = 12);
}
hole([D / 2 + 13, 0]);
}
score() translate([-6, -2]) text("LOAD", size = 3);
}
module crank() {
difference() {
capsule([0, 0], [35, 0], 12);
hole([0, 0], 6.5);
hole([35, 0]);
}
}
// Test holes for the 6 mm shaft and grip sleeve, and a slot for the sheet
module coupon() {
difference() {
rect([90, 40], center = true);
for (i = [0:3]) hole([-30 + i * 20, 0], 6 + i * 0.2);
translate([-20, 12]) rect([40, t + 0.2], center = true);
}
score() translate([-35, -15]) text("6.0 / 6.2 / 6.4 / 6.6", size = 3);
}
// The assembled view, z up from the table, the shaft along y with the front
// towards -y. Parts drawn in the front view stand up with their back face
// at depth z0 (front is +z0). At crank angle 0 a pocket points 45 degrees
// down to the right, into the release opening.
turn = -15 - crank_angle;
crank_z = -40;
slope = atan2(158.25 - 110, 258 - 65);
// The axle stands axle_height above the base
centre = axle_height + t;
floor_top = centre - 158.25;
function depth(z0, x = 0, y = 0) = [x, -z0, centre + y];
function facing(b = 0) = [90, -b, 0];
across = [90, 0, 90];
// Hub rings: two behind the crank and two in front of it
hub_z = [crank_z - 3 * t, crank_z - 2 * t, crank_z + t, crank_z + 2 * t];
// The assembly steps, listed first so they number in build order
step("Glue the wheel layers on the shaft");
step("Bolt the rear cheek, the shroud rings and the front cheek round the wheel, and pivot the gate on the front");
step("Glue the cheeks onto the base with the gussets");
step("Glue in the chute floor and build the catch box on its pedestals");
step("Glue the hub rings and the crank on the shaft and bolt on the grip");
if (output == "all" || output == "wheel") {
step("Glue the wheel layers on the shaft")
part("Wheel", qty = layers, at = [for (k = [0:layers - 1]) depth(-layers * t / 2 + k * t)], rotate = facing(turn)) wheel();
step("Glue the hub rings and the crank on the shaft and bolt on the grip") {
part("Crank", qty = 2, at = [depth(crank_z - t), depth(crank_z)], rotate = facing(turn)) crank();
part("Hub ring", qty = 4, at = [for (z = hub_z) depth(z)], rotate = facing(turn)) ring(28, 6.5);
// The grip turns with the crank, 35 mm out
part("Grip", qty = 4, at = [for (k = [1:4]) depth(crank_z - t - 0.8 - k * t) + [35 * cos(turn), 0, 35 * sin(turn)]], rotate = facing(turn))
ring(18, 6.4);
}
}
if (output == "all" || output == "frame") {
step("Bolt the rear cheek, the shroud rings and the front cheek round the wheel, and pivot the gate on the front") {
part("Rear cheek", at = depth(-cheek_gap / 2 - t), rotate = facing()) cheek(false);
part("Front cheek", at = depth(cheek_gap / 2), rotate = facing()) cheek(true);
part("Shroud", qty = layers + 1, at = [for (k = [0:layers]) depth(-cheek_gap / 2 + k * t)], rotate = facing()) shroud();
}
step("Glue the cheeks onto the base with the gussets")
part("Base", at = [0, 0, 0]) base();
step("Bolt the rear cheek, the shroud rings and the front cheek round the wheel, and pivot the gate on the front")
part("Loading gate", at = depth(cheek_gap / 2 + t, 0, -(R + 2 - D / 2)), rotate = facing()) gate();
// Two behind the stand and two in front, at x = -50 and 50
step("Glue the cheeks onto the base with the gussets")
part("Gusset", qty = 4, at = [[-50 + t / 2, -cheek_gap / 2 - t, t], [50 + t / 2, -cheek_gap / 2 - t, t],
[-50 - t / 2, cheek_gap / 2 + t, t], [50 - t / 2, cheek_gap / 2 + t, t]],
rotate = [[90, 0, 270], [90, 0, 270], across, across])
gusset();
}
if (output == "all" || output == "chute") step("Glue in the chute floor and build the catch box on its pedestals") {
// Its top face on the floor line, from (65, -110) to (258, -158.25)
part("Chute floor", at = [(65 + 258) / 2 - t * sin(slope), 0, centre - (110 + 158.25) / 2 - t * cos(slope)], rotate = [0, slope, 0])
rect([198.94, cheek_gap], center = true);
part("Catch floor", at = [283, 0, floor_top - t]) catch_square();
part("Catch lid", at = [283, 0, floor_top + 22]) catch_square();
part("Catch side wall", qty = 2, at = [[283, 25, floor_top + 11], [283, 3 - 25, floor_top + 11]], rotate = facing()) catch_wall(50);
part("Catch end wall", at = [308 - t, 0, floor_top + 11], rotate = across) catch_wall(50 - 2 * t);
// From the base up to the underside of the catch floor
part("Catch pedestal", qty = 2, at = [[283, 20, t + (floor_top - 2 * t) / 2], [283, t - 20, t + (floor_top - 2 * t) / 2]], rotate = facing())
rect([40, axle_height - 158.25 - t], center = true);
}
// The fit test lies on the table in front of the stand
if (output == "all" || output == "coupon") part("Fit test", at = [0, -110, 0]) coupon();
echo(str("Ascent: ", layers, " wheel layers in a ", cheek_gap, " mm cheek gap, ", 2 * R, " mm wheel, ", D, " mm marble"));
// Assembly, front view, shaft at the origin: glue the wheel layers on a rod
// and the shroud rings on the six bolts, and sand the pockets smooth. Epoxy
// a 6 mm steel shaft (80 mm) into the wheel, centred on it, and an 8 mm brass
// bush into each cheek. Bolt rear cheek, shroud and front cheek with six M4
// x 40 bolts, the front nuts only finger tight, with a shaft collar outside
// each cheek. Pivot the gate on a countersunk M4 bolt, its head flush inside
// the front cheek. Glue the cheeks onto the base with the gussets, the chute
// floor between the cheek walls, and the catch floor on its pedestals with
// two side walls and the end wall on top; tape the lid on. On the shaft
// behind the rear collar glue two hub rings, the two crank layers and two
// more rings, then bolt the grip (four rings on a 6 mm sleeve) to the crank.