//////////////////////////////////////////////////////////////////////////////////////////////
// LibFile: gears.scad
// Spur Gears, Bevel Gears, Racks, Worms and Worm Gears.
// Inspired by code by Leemon Baird, 2011, Leemon@Leemon.com
// Includes:
// include <BOSL2/std.scad>
// include <BOSL2/gears.scad>
// FileGroup: Parts
// FileSummary: Gears, racks, worms, and worm gears.
//////////////////////////////////////////////////////////////////////////////////////////////
_GEAR_PITCH = 5;
_GEAR_HELICAL = 0;
_GEAR_THICKNESS = 10;
_GEAR_PA = 20;
$parent_gear_type = undef;
$parent_gear_pitch = undef;
$parent_gear_teeth = undef;
$parent_gear_pa = undef;
$parent_gear_helical = undef;
$parent_gear_thickness = undef;
$parent_gear_dir = undef;
$parent_gear_travel = 0;
function _inherit_gear_param(name, val, pval, dflt, invert=false) =
is_undef(val)
? is_undef(pval)
? dflt
: (invert?-1:1)*pval
: is_undef(pval)
? assert(is_finite(val), str("Invalid ",name," value: ",val))
val
: (invert?-1:1)*val;
function _inherit_gear_pitch(fname,pitch,circ_pitch,diam_pitch,mod,warn=true) =
pitch != undef?
assert(is_finite(pitch) && pitch>0)
warn? echo(str(
"WARNING: The use of the argument pitch= in ", fname,
" is deprecated. Please use circ_pitch= instead."
)) pitch : pitch :
circ_pitch != undef?
assert(is_finite(circ_pitch) && circ_pitch>0)
circ_pitch :
diam_pitch != undef?
assert(is_finite(diam_pitch) && diam_pitch>0)
pitch_value(diam_pitch=diam_pitch) :
mod != undef?
assert(is_finite(mod) && mod>0)
pitch_value(mod) :
$parent_gear_pitch != undef? $parent_gear_pitch :
5;
function _inherit_gear_pa(pressure_angle) =
_inherit_gear_param("pressure_angle", pressure_angle, $parent_gear_pa, dflt=20);
function _inherit_gear_helical(helical,invert=false) =
_inherit_gear_param("helical", helical, $parent_gear_helical, dflt=0, invert=invert);
function _inherit_gear_thickness(thickness) =
_inherit_gear_param("thickness", thickness, $parent_gear_thickness, dflt=10);
// Section: Terminology
// The outline of a gear is a smooth circle (the "pitch circle") which has
// mountains and valleys added so it is toothed. There is an inner
// circle (the "root circle") that touches the base of all the teeth, an
// outer circle that touches the tips of all the teeth, and the invisible
// pitch circle in between them. There is also a "base circle", which can
// be smaller than all three of the others, which controls the shape of
// the teeth. The side of each tooth lies on the path that the end of a
// string would follow if it were wrapped tightly around the base circle,
// then slowly unwound. That shape is an "involute", which gives this
// type of gear its name.
// Section: Gears
// Function&Module: spur_gear()
// Synopsis: Creates a spur gear, helical gear, or internal ring gear.
// SynTags: Geom, VNF
// Topics: Gears, Parts
// See Also: rack(), spur_gear(), spur_gear2d(), bevel_gear()
// Usage: As a Module
// spur_gear(circ_pitch, teeth, thickness, [shaft_diam], [hide=], [pressure_angle=], [clearance=], [backlash=], [helical=], [slices=], [internal=], [herringbone=]) [ATTACHMENTS];
// spur_gear(mod=, teeth=, thickness=, [shaft_diam=], ...) [ATTACHMENTS];
// Usage: As a Function
// vnf = spur_gear(circ_pitch, teeth, thickness, [shaft_diam=], ...);
// vnf = spur_gear(mod=, teeth=, thickness=, [shaft_diam=], ...);
// Description:
// Creates a involute spur gear, helical gear, or a mask for an internal ring gear. The module `spur_gear()` gives an involute
// spur gear, with reasonable defaults for all the parameters. Normally, you should just choose the
// first 4 parameters, and let the rest be default values. Spur gears have straight teeth and
// mesh together on parallel shafts without creating any axial thrust. The teeth engage suddenly across their
// entire width, creating stress and noise. Helical gears have angled teeth and engage more gradually, so they
// run more smoothly and quietly, however they do produce thrust along the gear axis. This can be
// circumvented using herringbone or double helical gears, which have no axial thrust and also self-align.
// Helical gears can mesh along shafts that are not parallel, where the angle between the shafts is
// the sum of the helical angles of the two gears.
// .
// The module `spur_gear()` gives a gear in
// the XY plane, centered on the origin, with one tooth centered on the positive Y axis. The most
// important function is `mesh_radius()`, which tells how far apart to space gears that are meshing, and
// `outer_radius()`, which gives the size of the region filled by the gear. A gear has a "pitch
// circle", which is an invisible circle that cuts through the middle of each tooth (though not the
// exact center). In order for two gears to mesh, their pitch circles should just touch. So the
// distance between their centers should be `mesh_radius()` for one, plus `mesh_radius()` for the
// other, which gives the overall meshing distance. In order for two gears to mesh, they must
// have the same `pitch` and `pressure_angle` parameters. `pitch` gives the number of millimeters
// of arc around the pitch circle covered by one tooth and one space between teeth. The
// `pressure_angle` controls how flat or bulged the sides of the teeth are. Common values include
// 14.5 degrees and 20 degrees, and occasionally 25. The default here is 20 degrees.
// The ratio of `teeth` for two meshing gears gives how many times one will make a full revolution
// when the the other makes one full revolution. If the two numbers are coprime (i.e. are not both
// divisible by the same number greater than 1), then every tooth on one gear will meet every tooth
// on the other, for more even wear. So coprime numbers of teeth are good.
// Normally, If the number of teeth is too few, gear tooth shapes may be undercut to allow meshing
// with other gears. If this is the case, profile shifting will automatically be applies to enlarge
// the teeth, removing the undercut. This may add to the distance needed between gears.
// If you with to override this correction, you can use `profile_shift=0`, or set it to a specific
// value like 0.5.
// Arguments:
// circ_pitch = The circular pitch, or distance in mm between teeth around the pitch circle.
// teeth = Total number of teeth around the entire perimeter
// thickness = Thickness of gear in mm
// shaft_diam = Diameter of the hole in the center, in mm. Default: 0 (no shaft hole)
// ---
// hide = Number of teeth to delete to make this only a fraction of a circle
// pressure_angle = Controls how straight or bulged the tooth sides are. In degrees.
// clearance = Clearance gap at the bottom of the inter-tooth valleys.
// backlash = Gap between two meshing teeth, in the direction along the circumference of the pitch circle
// helical = Teeth are slanted around the spur gear at this angle away from the gear axis of rotation.
// slices = Number of vertical layers to divide gear into. Useful for refining gears with `helical`.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// internal = If true, create a mask for difference()ing from something else.
// profile_shift = Profile shift factor x.
// herringbone = If true, and helical is set, creates a herringbone gear.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#subsection-anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#subsection-spin). Default: `0`
// orient = Vector to rotate top towards, after spin. See [orient](attachments.scad#subsection-orient). Default: `UP`
// Side Effects:
// If internal is true then the default tag is "remove"
// Example: Spur Gear
// spur_gear(circ_pitch=5, teeth=20, thickness=8, shaft_diam=5);
// Example: Metric Gear
// spur_gear(mod=2, teeth=20, thickness=8, shaft_diam=5);
// Example: Helical Gear
// spur_gear(
// circ_pitch=5, teeth=20, thickness=10,
// shaft_diam=5, helical=-30, slices=12,
// $fa=1, $fs=1
// );
// Example: Herringbone Gear
// spur_gear(
// circ_pitch=5, teeth=20, thickness=10, shaft_diam=5,
// helical=30, herringbone=true, slices=5
// );
// Example(Big): Effects of Profile Shifting.
// circ_pitch=5; teeth=7; thick=10; shaft=5; strokewidth=0.2;
// pr = pitch_radius(circ_pitch, teeth);
// left(10) {
// profile_shift = 0;
// mr = mesh_radius(circ_pitch,teeth,profile_shift=profile_shift);
// back(mr) spur_gear(circ_pitch, teeth, thick, shaft, profile_shift=profile_shift);
// rack(circ_pitch, teeth=3, thickness=thick, height=5, orient=BACK);
// color("black") up(thick/2) linear_extrude(height=0.1) {
// back(mr) dashed_stroke(circle(r=pr), width=strokewidth, closed=true);
// dashed_stroke([[-7.5,0],[7.5,0]], width=strokewidth);
// }
// }
// right(10) {
// profile_shift = 0.59;
// mr = mesh_radius(circ_pitch,teeth,profile_shift=profile_shift);
// back(mr) spur_gear(circ_pitch, teeth, thick, shaft, profile_shift=profile_shift);
// rack(circ_pitch, teeth=3, thickness=thick, height=5, orient=BACK);
// color("black") up(thick/2) linear_extrude(height=0.1) {
// back(mr)
// dashed_stroke(circle(r=pr), width=strokewidth, closed=true);
// dashed_stroke([[-7.5,0],[7.5,0]], width=strokewidth);
// }
// }
// Example(Anim,Frames=8,VPT=[0,30,0],VPR=[0,0,0],VPD=300): Assembly of Gears
// n1 = 11; //red gear number of teeth
// n2 = 20; //green gear
// n3 = 6; //blue gear
// n4 = 16; //orange gear
// n5 = 9; //gray rack
// circ_pitch = 9; //all meshing gears need the same `circ_pitch` (and the same `pressure_angle`)
// thickness = 6;
// hole = 3;
// rack_base = 12;
// r1 = mesh_radius(circ_pitch,n1);
// r2 = mesh_radius(circ_pitch,n2);
// r3 = mesh_radius(circ_pitch,n3);
// r4 = mesh_radius(circ_pitch,n4);
// r5 = mesh_radius(circ_pitch,n5);
// a1 = $t * 360 / n1;
// a2 = -$t * 360 / n2 + 180/n2;
// a3 = -$t * 360 / n3 - 3*90/n3;
// a4 = -$t * 360 / n4 - 3.5*180/n4;
// color("#f77") zrot(a1) spur_gear(circ_pitch,n1,thickness,hole);
// color("#7f7") back(r1+r2) zrot(a2) spur_gear(circ_pitch,n2,thickness,hole);
// color("#77f") right(r1+r3) zrot(a3) spur_gear(circ_pitch,n3,thickness,hole);
// color("#fc7") left(r1+r4) zrot(a4) spur_gear(circ_pitch,n4,thickness,hole,hide=n4-3);
// color("#ccc") fwd(r1) right(circ_pitch*$t)
// rack(pitch=circ_pitch,teeth=n5,thickness=thickness,height=rack_base,anchor=CENTER,orient=BACK);
// Example: Helical gears meshing with non-parallel shafts
// ang1 = 30;
// ang2 = 10;
// circ_pitch = 5;
// n = 20;
// r1 = mesh_radius(circ_pitch,n,helical=ang1);
// r2 = mesh_radius(circ_pitch,n,helical=ang2);
// left(r1) spur_gear(
// circ_pitch, teeth=n, thickness=10,
// shaft_diam=5, helical=ang1, slices=12,
// gear_spin=-90
// );
// right(r2)
// xrot(ang1+ang2)
// spur_gear(
// circ_pitch=circ_pitch, teeth=n, thickness=10,
// shaft_diam=5, helical=ang2, slices=12,
// gear_spin=90-180/n
// );
// Example(Anim,Frames=36,VPT=[0,0,0],VPR=[55,0,25],VPD=375): Planetary Gear Assembly
// rteeth=56; pteeth=16; cteeth=24;
// circ_pitch=5; thick=10; pa=20;
// cr = mesh_radius(circ_pitch,cteeth);
// pr = mesh_radius(circ_pitch,pteeth);
// ring_gear(
// circ_pitch=circ_pitch,
// teeth=rteeth,
// thickness=thick,
// pressure_angle=pa);
// for (a=[0:3]) {
// zrot($t*90+a*90) back(cr+pr) {
// color("green")
// spur_gear(
// circ_pitch=circ_pitch,
// teeth=pteeth,
// thickness=thick,
// shaft_diam=5,
// pressure_angle=pa,
// spin=-$t*90*rteeth/pteeth);
// }
// }
// color("orange")
// zrot($t*90*rteeth/cteeth+$t*90+180/cteeth)
// spur_gear(
// circ_pitch=circ_pitch,
// teeth=cteeth,
// thickness=thick,
// shaft_diam=5,
// pressure_angle=pa);
function spur_gear(
circ_pitch,
teeth,
thickness,
shaft_diam = 0,
hide = 0,
pressure_angle,
clearance,
backlash = 0.0,
helical,
interior,
internal,
profile_shift,
slices,
herringbone=false,
diam_pitch,
mod,
pitch,
gear_spin = 0,
anchor = CENTER,
spin = 0,
orient = UP
) =
let(
dummy = !is_undef(interior) ? echo("In spur_gear(), the argument 'interior=' has been deprecated, and may be removed in the future. Please use 'internal=' instead."):0,
internal = first_defined([internal,interior,false]),
circ_pitch = _inherit_gear_pitch("spur_gear()", pitch, circ_pitch, diam_pitch, mod),
PA = _inherit_gear_pa(pressure_angle),
helical = _inherit_gear_helical(helical, invert=!internal),
thickness = _inherit_gear_thickness(thickness),
profile_shift = default(profile_shift, auto_profile_shift(teeth,PA))
)
assert(is_integer(teeth) && teeth>3)
assert(is_finite(thickness) && thickness>0)
assert(is_finite(shaft_diam) && shaft_diam>=0)
assert(is_integer(hide) && hide>=0 && hide<teeth)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(helical) && abs(helical)<90)
assert(is_bool(herringbone))
assert(slices==undef || (is_integer(slices) && slices>0))
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(is_finite(gear_spin))
let(
pr = pitch_radius(circ_pitch, teeth, helical),
circum = 2 * PI * pr,
twist = 360*thickness*tan(helical)/circum,
slices = default(slices, ceil(twist/360*segs(pr)+1)),
rgn = spur_gear2d(
circ_pitch = circ_pitch,
teeth = teeth,
pressure_angle = PA,
hide = hide,
helical = helical,
clearance = clearance,
backlash = backlash,
internal = internal,
profile_shift = profile_shift,
shaft_diam = shaft_diam
),
rvnf = herringbone
? zrot(twist/2, p=linear_sweep(rgn, height=thickness, twist=twist, slices=slices, center=true))
: let(
wall_vnf = linear_sweep(rgn, height=thickness/2, twist=twist/2, slices=ceil(slices/2), center=false, caps=false),
cap_vnf = vnf_from_region(rgn, transform=up(thickness/2)*zrot(twist/2))
)
vnf_join([
wall_vnf, zflip(p=wall_vnf),
cap_vnf, zflip(p=cap_vnf),
]),
vnf = zrot(gear_spin, p=rvnf)
) reorient(anchor,spin,orient, h=thickness, r=pr, p=vnf);
module spur_gear(
circ_pitch,
teeth,
thickness,
shaft_diam = 0,
hide = 0,
pressure_angle,
clearance,
backlash = 0.0,
helical,
internal,
interior,
profile_shift,
slices,
herringbone=false,
pitch,
diam_pitch,
mod,
gear_spin = 0,
anchor = CENTER,
spin = 0,
orient = UP
) {
dummy = !is_undef(interior) ? echo("In spur_gear(), the argument 'interior=' has been deprecated, and may be removed in the future. Please use 'internal=' instead."):0;
internal = first_defined([internal,interior,false]);
circ_pitch = _inherit_gear_pitch("spur_gear()", pitch, circ_pitch, diam_pitch, mod);
PA = _inherit_gear_pa(pressure_angle);
helical = _inherit_gear_helical(helical, invert=!internal);
thickness = _inherit_gear_thickness(thickness);
profile_shift = default(profile_shift, auto_profile_shift(teeth,PA));
checks =
assert(is_integer(teeth) && teeth>3)
assert(is_finite(thickness) && thickness>0)
assert(is_finite(shaft_diam) && shaft_diam>=0)
assert(is_integer(hide) && hide>=0 && hide<teeth)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(helical) && abs(helical)<90)
assert(is_bool(herringbone))
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(slices==undef || (is_integer(slices) && slices>0))
assert(is_finite(gear_spin));
pr = pitch_radius(circ_pitch, teeth, helical);
circum = 2 * PI * pr;
twist = 360*thickness*tan(helical)/circum;
slices = default(slices, ceil(twist/360*segs(pr)+1));
default_tag("remove", internal) {
attachable(anchor,spin,orient, r=pr, l=thickness) {
zrot(gear_spin)
if (herringbone) {
zflip_copy() down(0.01)
linear_extrude(
height=thickness/2+0.01, center=false,
twist=twist/2, slices=ceil(slices/2),
convexity=teeth/2
) {
spur_gear2d(
circ_pitch = circ_pitch,
teeth = teeth,
pressure_angle = PA,
hide = hide,
helical = helical,
clearance = clearance,
backlash = backlash,
internal = internal,
profile_shift = profile_shift,
shaft_diam = shaft_diam
);
}
} else {
zrot(twist/2)
linear_extrude(
height=thickness, center=true,
twist=twist, slices=slices,
convexity=teeth/2
) {
spur_gear2d(
circ_pitch = circ_pitch,
teeth = teeth,
pressure_angle = PA,
hide = hide,
helical = helical,
clearance = clearance,
backlash = backlash,
internal = internal,
profile_shift = profile_shift,
shaft_diam = shaft_diam
);
}
}
union() {
$parent_gear_type = "spur";
$parent_gear_pitch = circ_pitch;
$parent_gear_teeth = teeth;
$parent_gear_pa = PA;
$parent_gear_helical = helical;
$parent_gear_thickness = thickness;
union() children();
}
}
}
}
// Function&Module: spur_gear2d()
// Synopsis: Creates a 2D spur gear or internal ring gear.
// SynTags: Geom, Region
// Topics: Gears, Parts
// See Also: rack(), spur_gear(), spur_gear2d(), bevel_gear()
// Usage: As Module
// spur_gear2d(circ_pitch, teeth, [hide=], [pressure_angle=], [clearance=], [backlash=], [internal=]) [ATTACHMENTS];
// spur_gear2d(mod=, teeth=, [hide=], [pressure_angle=], [clearance=], [backlash=], [internal=]) [ATTACHMENTS];
// Usage: As Function
// rgn = spur_gear2d(circ_pitch, teeth, [hide=], [pressure_angle=], [clearance=], [backlash=], [internal=]);
// rgn = spur_gear2d(mod=, teeth=, [hide=], [pressure_angle=], [clearance=], [backlash=], [internal=]);
// Description:
// When called as a module, creates a 2D involute spur gear. When called as a function,
// returns a 2D region for the 2D involute spur gear. Normally, you should just specify the
// first 2 parameters `circ_pitch` and `teeth`, and let the rest be default values.
// Meshing gears must match in `circ_pitch`, `pressure_angle`, and `helical`, and be separated by
// the sum of their meshing radii, which can be found with `mesh_radius()`.
// Arguments:
// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// teeth = Total number of teeth around the spur gear.
// hide = Number of teeth to delete to make this only a fraction of a circle
// pressure_angle = Controls how straight or bulged the tooth sides are. In degrees.
// ---
// hide = Number of teeth to delete to make this only a fraction of a circle
// clearance = Gap between top of a tooth on one gear and bottom of valley on a meshing gear (in millimeters)
// backlash = Gap between two meshing teeth, in the direction along the circumference of the pitch circle
// helical = The angle of the rack teeth away from perpendicular to the gear axis of rotation. Stretches out the tooth shapes. Used to match helical spur gear pinions. Default: 0
// internal = If true, create a mask for difference()ing from something else.
// profile_shift = Profile shift factor x.
// shaft_diam = If given, the diameter of the central shaft hole.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#subsection-anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#subsection-spin). Default: `0`
// Example(2D): Typical Gear Shape
// spur_gear2d(circ_pitch=5, teeth=20, shaft_diam=5);
// Example(2D): By Metric Module
// spur_gear2d(mod=2, teeth=20, shaft_diam=5);
// Example(2D): By Imperial Gear Pitch
// spur_gear2d(diam_pitch=10, teeth=20, shaft_diam=5);
// Example(2D): Lower Pressure Angle
// spur_gear2d(circ_pitch=5, teeth=20, pressure_angle=14);
// Example(2D): Partial Gear
// spur_gear2d(circ_pitch=5, teeth=20, hide=15, pressure_angle=20);
// Example(2D): Effects of Profile Shifting.
// circ_pitch=5; teeth=7; shaft=5; strokewidth=0.2;
// module the_gear(profile_shift=0) {
// $fn=72;
// pr = pitch_radius(circ_pitch,teeth);
// mr = mesh_radius(circ_pitch,teeth,profile_shift=profile_shift);
// back(mr) {
// spur_gear2d(circ_pitch, teeth, shaft_diam=shaft, profile_shift=profile_shift);
// up(0.1) color("black")
// dashed_stroke(circle(r=pr), width=strokewidth, closed=true);
// }
// }
// module the_rack() {
// $fn=72;
// rack2d(circ_pitch, teeth=3, height=5);
// up(0.1) color("black")
// dashed_stroke([[-7.5,0],[7.5,0]], width=strokewidth);
// }
// left(10) { the_gear(0); the_rack(); }
// right(10) { the_gear(0.59); the_rack(); }
// Example(2D): Planetary Gear Assembly
// rteeth=56; pteeth=16; cteeth=24;
// circ_pitch=5; pa=20;
// cr = mesh_radius(circ_pitch, cteeth);
// pr = mesh_radius(circ_pitch, pteeth);
// ring_gear2d(
// circ_pitch=circ_pitch,
// teeth=rteeth,
// pressure_angle=pa);
// for (a=[0:3]) {
// zrot(a*90) back(cr+pr) {
// color("green")
// spur_gear2d(
// circ_pitch=circ_pitch,
// teeth=pteeth,
// pressure_angle=pa);
// }
// }
// color("orange")
// zrot(180/cteeth)
// spur_gear2d(
// circ_pitch=circ_pitch,
// teeth=cteeth,
// pressure_angle=pa);
// Example(2D): Called as a Function
// rgn = spur_gear2d(circ_pitch=8, teeth=16, shaft_diam=5);
// region(rgn);
function spur_gear2d(
circ_pitch,
teeth,
hide = 0,
pressure_angle,
clearance,
backlash = 0.0,
internal,
interior,
profile_shift,
helical,
shaft_diam = 0,
pitch,
diam_pitch,
mod,
gear_spin = 0,
anchor = CENTER,
spin = 0
) = let(
dummy = !is_undef(interior) ? echo("In spur_gear2d(), the argument 'interior=' has been deprecated, and may be removed in the future. Please use 'internal=' instead."):0,
internal = first_defined([internal,interior,false]),
circ_pitch = _inherit_gear_pitch("spur_gear2d()", pitch, circ_pitch, diam_pitch, mod),
PA = _inherit_gear_pa(pressure_angle),
helical = _inherit_gear_helical(helical, invert=!internal),
profile_shift = default(profile_shift, auto_profile_shift(teeth,PA))
)
assert(is_integer(teeth) && teeth>3)
assert(is_finite(shaft_diam) && shaft_diam>=0)
assert(is_integer(hide) && hide>=0 && hide<teeth)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(is_finite(helical) && abs(helical)<90)
assert(is_finite(gear_spin))
let(
pr = pitch_radius(circ_pitch, teeth, helical=helical),
tooth = _gear_tooth_profile(
circ_pitch=circ_pitch,
teeth=teeth,
pressure_angle=PA,
clearance=clearance,
backlash=backlash,
profile_shift=profile_shift,
helical=helical,
internal=internal
),
perim = [
for (i = [0:1:teeth-1-hide])
each zrot(-i*360/teeth+gear_spin, p=tooth),
if (hide>0) [0,0],
],
rgn = [
list_unwrap(deduplicate(perim)),
if (shaft_diam>0 && !hide)
reverse(circle(d=shaft_diam)),
]
) reorient(anchor,spin, two_d=true, r=pr, p=rgn);
module spur_gear2d(
circ_pitch,
teeth,
hide = 0,
pressure_angle,
clearance,
backlash = 0.0,
internal,
interior,
profile_shift,
helical,
shaft_diam = 0,
pitch,
diam_pitch,
mod,
gear_spin = 0,
anchor = CENTER,
spin = 0
) {
dummy = !is_undef(interior) ? echo("In spur_gear2d(), the argument 'interior=' has been deprecated, and may be removed in the future. Please use 'internal=' instead."):0;
internal = first_defined([internal,interior,false]);
circ_pitch = _inherit_gear_pitch("spur_gear2d()", pitch, circ_pitch, diam_pitch, mod);
PA = _inherit_gear_pa(pressure_angle);
helical = _inherit_gear_helical(helical, invert=!internal);
profile_shift = default(profile_shift, auto_profile_shift(teeth,PA));
checks =
assert(is_integer(teeth) && teeth>3)
assert(is_finite(shaft_diam) && shaft_diam>=0)
assert(is_integer(hide) && hide>=0 && hide<teeth)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(is_finite(helical) && abs(helical)<90)
assert(is_finite(gear_spin));
rgn = spur_gear2d(
circ_pitch = circ_pitch,
teeth = teeth,
hide = hide,
pressure_angle = PA,
clearance = clearance,
helical = helical,
backlash = backlash,
profile_shift = profile_shift,
internal = internal,
shaft_diam = shaft_diam
);
pr = pitch_radius(circ_pitch, teeth, helical=helical);
attachable(anchor,spin, two_d=true, r=pr) {
zrot(gear_spin) region(rgn);
union() {
$parent_gear_type = "spur2D";
$parent_gear_pitch = circ_pitch;
$parent_gear_teeth = teeth;
$parent_gear_pa = PA;
$parent_gear_helical = helical;
$parent_gear_thickness = 0;
union() children();
}
}
}
// Module: ring_gear()
// Synopsis: Creates a 3D ring gear.
// SynTags: Geom
// Topics: Gears, Parts
// See Also: rack(), ring_gear2d(), spur_gear(), spur_gear2d(), bevel_gear()
// Usage:
// ring_gear(circ_pitch, teeth, thickness, [backing], [pressure_angle=], [helical=], [herringbone=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
// ring_gear(mod=, teeth=, thickness=, backing=, [pressure_angle=], [helical=], [herringbone=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
// ring_gear(diam_pitch=, teeth=, thickness=, backing=, [pressure_angle=], [helical=], [herringbone=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
// Description:
// Creates a 3D involute ring gear. Normally, you should just specify the
// first 3 parameters `circ_pitch`, `teeth`, and `thickness`, and let the rest be default values.
// Meshing gears must match in `circ_pitch`, `pressure_angle`, and `helical`, and be separated by
// the sum of their profile shifts and pitch radii, which can be found with `mesh_radius()`.
// Arguments:
// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// teeth = Total number of teeth around the spur gear.
// thickness = Thickness of ring gear in mm
// backing = The width of the ring gear backing, in mm.
// pressure_angle = Controls how straight or bulged the tooth sides are. In degrees.
// ---
// helical = The angle of the rack teeth away from perpendicular to the gear axis of rotation. Stretches out the tooth shapes. Used to match helical spur gear pinions. Default: 0
// herringbone = If true, and helical is set, creates a herringbone gear.
// profile_shift = Profile shift factor x for tooth profile.
// clearance = Gap between top of a tooth on one gear and bottom of valley on a meshing gear (in millimeters)
// backlash = Gap between two meshing teeth, in the direction along the circumference of the pitch circle
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#subsection-anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#subsection-spin). Default: `0`
// orient = Vector to rotate top towards, after spin. See [orient](attachments.scad#subsection-orient). Default: `UP`
// Example:
// ring_gear(circ_pitch=5, teeth=48, thickness=10);
// Example: Adjusting Backing
// ring_gear(circ_pitch=5, teeth=48, thickness=10, backing=30);
// Example(Med): Adjusting Pressure Angle
// ring_gear(circ_pitch=5, teeth=48, thickness=10, pressure_angle=28);
// Example(Med): Tooth Profile Shifting
// ring_gear(circ_pitch=5, teeth=48, thickness=10, profile_shift=0.5);
// Example(Med): Helical Ring Gear
// ring_gear(circ_pitch=5, teeth=48, thickness=10, helical=30);
// Example(Med): Herringbone Ring Gear
// ring_gear(circ_pitch=5, teeth=48, thickness=10, helical=30, herringbone=true);
module ring_gear(
circ_pitch,
teeth,
thickness = 10,
backing = 10,
pressure_angle,
helical,
herringbone = false,
profile_shift,
clearance,
backlash = 0.0,
pitch,
diam_pitch,
mod,
slices,
gear_spin = 0,
anchor = CENTER,
spin = 0,
orient = UP
) {
circ_pitch = _inherit_gear_pitch("ring_gear()",pitch, circ_pitch, diam_pitch, mod);
PA = _inherit_gear_pa(pressure_angle);
helical = _inherit_gear_helical(helical);
thickness = _inherit_gear_thickness(thickness);
profile_shift = default(profile_shift, auto_profile_shift(teeth,PA));
checks =
assert(is_integer(teeth) && teeth>3)
assert(is_finite(thickness) && thickness>0)
assert(is_finite(backing) && backing>0)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(is_finite(helical) && abs(helical)<90)
assert(is_bool(herringbone))
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(slices==undef || (is_integer(slices) && slices>0))
assert(is_finite(gear_spin));
pr = pitch_radius(circ_pitch, teeth, helical=helical);
ar = outer_radius(circ_pitch, teeth, helical=helical, profile_shift=profile_shift, internal=true);
circum = 2 * PI * pr;
twist = 360*thickness*tan(helical)/circum;
slices = default(slices, ceil(twist/360*segs(pr)+1));
attachable(anchor,spin,orient, h=thickness, r=pr) {
zrot(gear_spin)
if (herringbone) {
zflip_copy() down(0.01)
linear_extrude(height=thickness/2, center=false, twist=twist/2, slices=ceil(slices/2), convexity=teeth/4) {
difference() {
circle(r=ar+backing);
spur_gear2d(
circ_pitch = circ_pitch,
teeth = teeth,
pressure_angle = PA,
helical = helical,
clearance = clearance,
backlash = backlash,
profile_shift = profile_shift,
internal = true
);
}
}
} else {
zrot(twist/2)
linear_extrude(height=thickness,center=true, twist=twist, convexity=teeth/4) {
difference() {
circle(r=ar+backing);
spur_gear2d(
circ_pitch = circ_pitch,
teeth = teeth,
pressure_angle = PA,
helical = helical,
clearance = clearance,
backlash = backlash,
profile_shift = profile_shift,
internal = true
);
}
}
}
children();
}
}
// Module: ring_gear2d()
// Synopsis: Creates a 2D ring gear.
// SynTags: Geom
// Topics: Gears, Parts
// See Also: rack(), spur_gear(), spur_gear2d(), bevel_gear()
// Usage:
// ring_gear2d(circ_pitch, teeth, [backing], [pressure_angle=], [helical=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
// ring_gear2d(mod=, teeth=, [backing=], [pressure_angle=], [helical=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
// ring_gear2d(diam_pitch=, teeth=, [backing=], [pressure_angle=], [helical=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
// Description:
// Creates a 2D involute ring gear. Normally, you should just specify the
// first 2 parameters `circ_pitch` and `teeth`, and let the rest be default values.
// Meshing gears must match in `circ_pitch`, `pressure_angle`, and `helical`, and be separated by
// the sum of their profile shifts and pitch radii, which can be found with `mesh_radius()`.
// Arguments:
// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// teeth = Total number of teeth around the spur gear.
// backing = The width of the ring gear backing, in mm.
// pressure_angle = Controls how straight or bulged the tooth sides are. In degrees.
// ---
// helical = The angle of the rack teeth away from perpendicular to the gear axis of rotation. Stretches out the tooth shapes. Used to match helical spur gear pinions. Default: 0
// profile_shift = Profile shift factor x for tooth profile.
// clearance = Gap between top of a tooth on one gear and bottom of valley on a meshing gear (in millimeters)
// backlash = Gap between two meshing teeth, in the direction along the circumference of the pitch circle
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#subsection-anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#subsection-spin). Default: `0`
// Example(2D;Big):
// circ_pitch=5; teeth1=50; teeth2=16;
// pr1 = pitch_radius(circ_pitch, teeth1);
// pr2 = pitch_radius(circ_pitch, teeth2);
// ring_gear2d(circ_pitch=circ_pitch, teeth=teeth1);
// back(pr1-pr2) spur_gear2d(circ_pitch=circ_pitch, teeth=teeth2);
module ring_gear2d(
circ_pitch,
teeth,
backing = 10,
pressure_angle,
helical,
profile_shift,
clearance,
backlash = 0.0,
pitch,
diam_pitch,
mod,
gear_spin = 0,
anchor = CENTER,
spin = 0
) {
circ_pitch = _inherit_gear_pitch("ring_gear2d()",pitch, circ_pitch, diam_pitch, mod);
PA = _inherit_gear_pa(pressure_angle);
helical = _inherit_gear_helical(helical);
profile_shift = default(profile_shift, auto_profile_shift(teeth,PA));
checks =
assert(is_integer(teeth) && teeth>3)
assert(is_finite(backing) && backing>0)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(is_finite(helical) && abs(helical)<90)
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(is_finite(gear_spin));
pr = pitch_radius(circ_pitch, teeth, helical=helical);
ar = outer_radius(circ_pitch, teeth, helical=helical, profile_shift=profile_shift, internal=true);
attachable(anchor,spin, two_d=true, r=pr) {
zrot(gear_spin)
difference() {
circle(r=ar+backing);
spur_gear2d(
circ_pitch = circ_pitch,
teeth = teeth,
pressure_angle = PA,
helical = helical,
clearance = clearance,
backlash = backlash,
profile_shift = profile_shift,
internal = true
);
}
children();
}
}
// Function&Module: rack()
// Synopsis: Creates a straight or helical gear rack.
// SynTags: Geom, VNF
// Topics: Gears, Parts
// See Also: rack2d(), spur_gear(), spur_gear2d(), bevel_gear()
// Usage: As a Module
// rack(pitch, teeth, thickness, height, [pressure_angle=], [backlash=], [clearance=], [helical=]) [ATTACHMENTS];
// rack(mod=, teeth=, thickness=, height=, [pressure_angle=], [backlash]=, [clearance=], [helical=]) [ATTACHMENTS];
// Usage: As a Function
// vnf = rack(pitch, teeth, thickness, height, [pressure_angle=], [backlash=], [clearance=], [helical=]);
// vnf = rack(mod=, teeth=, thickness=, height=, [pressure_angle=], [backlash=], [clearance=], [helical=]);
// Description:
// This is used to create a 3D rack, which is a linear bar with teeth that a gear can roll along.
// A rack can mesh with any gear that has the same `pitch` and `pressure_angle`.
// When called as a function, returns a 3D [VNF](vnf.scad) for the rack.
// When called as a module, creates a 3D rack shape.
// Arguments:
// pitch = The pitch, or distance in mm between teeth along the rack. Matches up with circular pitch on a spur gear. Default: 5
// teeth = Total number of teeth along the rack. Default: 20
// thickness = Thickness of rack in mm (affects each tooth). Default: 5
// height = Height of rack in mm, from tooth top to back of rack. Default: 10
// ---
// pressure_angle = Controls how straight or bulged the tooth sides are. In degrees. Default: 20
// backlash = Gap between two meshing teeth, in the direction along the circumference of the pitch circle. Default: 0
// clearance = Clearance gap at the bottom of the inter-tooth valleys.
// helical = The angle of the rack teeth away from perpendicular to the rack length. Used to match helical spur gear pinions. Default: 0
// profile_shift = Profile shift factor x.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#subsection-anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#subsection-spin). Default: `0`
// orient = Vector to rotate top towards, after spin. See [orient](attachments.scad#subsection-orient). Default: `UP`
// Extra Anchors:
// "adendum" = At the tips of the teeth, at the center of rack.
// "adendum-left" = At the tips of the teeth, at the left end of the rack.
// "adendum-right" = At the tips of the teeth, at the right end of the rack.
// "adendum-back" = At the tips of the teeth, at the back of the rack.
// "adendum-front" = At the tips of the teeth, at the front of the rack.
// "dedendum" = At the base of the teeth, at the center of rack.
// "dedendum-left" = At the base of the teeth, at the left end of the rack.
// "dedendum-right" = At the base of the teeth, at the right end of the rack.
// "dedendum-back" = At the base of the teeth, at the back of the rack.
// "dedendum-front" = At the base of the teeth, at the front of the rack.
// Example(VPR=[60,0,325],VPD=130):
// rack(pitch=5, teeth=10, thickness=5, height=5, pressure_angle=20);
// Example: Rack for Helical Gear
// rack(pitch=5, teeth=10, thickness=5, height=5, pressure_angle=20, helical=30);
// Example: Alternate Helical Gear
// rack(pitch=5, teeth=10, thickness=5, height=5, pressure_angle=20, helical=-30);
// Example: Metric Rack
// rack(mod=2, teeth=10, thickness=5, height=5, pressure_angle=20);
// Example(Anim,VPT=[0,0,12],VPD=100,Frames=6): Rack and Pinion
// teeth1 = 16; teeth2 = 16;
// pitch = 5; thick = 5; helical = 30;
// pr = pitch_radius(pitch, teeth2, helical=helical);
// right(pr*2*PI/teeth2*$t)
// rack(pitch, teeth1, thickness=thick, height=5, helical=helical);
// up(pr)
// spur_gear(
// pitch, teeth2,
// thickness=thick,
// helical=helical,
// shaft_diam=5,
// orient=BACK,
// gear_spin=180-$t*360/teeth2);
module rack(
pitch,
teeth,
thickness,
height = 10,
pressure_angle,
backlash = 0.0,
clearance,
helical,
profile_shift = 0,
gear_travel=0,
circ_pitch,
diam_pitch,
mod,
anchor = CENTER,
spin = 0,
orient = UP
) {
pitch = _inherit_gear_pitch("rack()",pitch, circ_pitch, diam_pitch, mod, warn=false);
PA = _inherit_gear_pa(pressure_angle);
helical = _inherit_gear_helical(helical);
thickness = _inherit_gear_thickness(thickness);
checks=
assert(is_integer(teeth) && teeth>0)
assert(is_finite(thickness) && thickness>0)
assert(is_finite(height) && height>0)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(helical) && abs(helical)<90)
//assert(is_bool(herringbone))
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(is_finite(gear_travel));
trans_pitch = pitch / cos(helical);
a = _adendum(pitch, profile_shift);
d = _dedendum(pitch, clearance, profile_shift);
l = teeth * trans_pitch;
anchors = [
named_anchor("adendum", [0,0,a], BACK),
named_anchor("adendum-left", [-l/2,0,a], LEFT),
named_anchor("adendum-right", [ l/2,0,a], RIGHT),
named_anchor("adendum-front", [0,-thickness/2,a], DOWN),
named_anchor("adendum-back", [0, thickness/2,a], UP),
named_anchor("dedendum", [0,0,-d], BACK),
named_anchor("dedendum-left", [-l/2,0,-d], LEFT),
named_anchor("dedendum-right", [ l/2,0,-d], RIGHT),
named_anchor("dedendum-front", [0,-thickness/2,-d], DOWN),
named_anchor("dedendum-back", [0, thickness/2,-d], UP),
];
size = [l, thickness, 2*height];
attachable(anchor,spin,orient, size=size, anchors=anchors) {
right(gear_travel)
skew(sxy=tan(helical)) xrot(90) {
linear_extrude(height=thickness, center=true, convexity=teeth*2) {
rack2d(
pitch = pitch,
teeth = teeth,
height = height,
pressure_angle = PA,
backlash = backlash,
clearance = clearance,
helical = helical,
profile_shift = profile_shift
);
}
}
children();
}
}
function rack(
pitch,
teeth,
thickness,
height = 10,
pressure_angle,
backlash = 0.0,
clearance,
helical,
profile_shift = 0,
circ_pitch,
diam_pitch,
mod,
gear_travel=0,
anchor = CENTER,
spin = 0,
orient = UP
) =
let(
pitch = _inherit_gear_pitch("rack()",pitch, circ_pitch, diam_pitch, mod, warn=false),
PA = _inherit_gear_pa(pressure_angle),
helical = _inherit_gear_helical(helical),
thickness = _inherit_gear_thickness(thickness)
)
assert(is_integer(teeth) && teeth>0)
assert(is_finite(thickness) && thickness>0)
assert(is_finite(height) && height>0)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(helical) && abs(helical)<90)
//assert(is_bool(herringbone))
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(is_finite(gear_travel))
let(
trans_pitch = pitch / cos(helical),
a = _adendum(pitch, profile_shift),
d = _dedendum(pitch, clearance, profile_shift),
l = teeth * trans_pitch,
path = rack2d(
pitch = pitch,
teeth = teeth,
height = height,
pressure_angle = PA,
backlash = backlash,
clearance = clearance,
helical = helical,
profile_shift = profile_shift
),
vnf = linear_sweep(path, height=thickness, anchor="origin", orient=FWD),
m = product([
right(gear_travel),
if (helical) skew(sxy=tan(helical)),
]),
out = apply(m, vnf),
size = [l, thickness, 2*height],
anchors = [
named_anchor("adendum", [0,0,a], BACK),
named_anchor("adendum-left", [-l/2,0,a], LEFT),
named_anchor("adendum-right", [ l/2,0,a], RIGHT),
named_anchor("adendum-front", [0,-thickness/2,a], DOWN),
named_anchor("adendum-back", [0, thickness/2,a], UP),
named_anchor("dedendum", [0,0,-d], BACK),
named_anchor("dedendum-left", [-l/2,0,-d], LEFT),
named_anchor("dedendum-right", [ l/2,0,-d], RIGHT),
named_anchor("dedendum-front", [0,-thickness/2,-d], DOWN),
named_anchor("dedendum-back", [0, thickness/2,-d], UP),
]
) reorient(anchor,spin,orient, size=size, anchors=anchors, p=out);
// Function&Module: rack2d()
// Synopsis: Creates a 2D gear rack.
// SynTags: Geom, Path
// Topics: Gears, Parts
// See Also: rack(), spur_gear(), spur_gear2d(), bevel_gear()
// Usage: As a Module
// rack2d(pitch, teeth, height, [pressure_angle=], [backlash=], [clearance=]) [ATTACHMENTS];
// rack2d(mod=, teeth=, height=, [pressure_angle=], [backlash=], [clearance=]) [ATTACHMENTS];
// Usage: As a Function
// path = rack2d(pitch, teeth, height, [pressure_angle=], [backlash=], [clearance=]);
// path = rack2d(mod=, teeth=, height=, [pressure_angle=], [backlash=], [clearance=]);
// Description:
// This is used to create a 2D rack, which is a linear bar with teeth that a gear can roll along.
// A rack can mesh with any gear that has the same `pitch` and `pressure_angle`.
// When called as a function, returns a 2D path for the outline of the rack.
// When called as a module, creates a 2D rack shape.
// Arguments:
// pitch = The pitch, or distance in mm between teeth along the rack. Matches up with circular pitch on a spur gear. Default: 5
// teeth = Total number of teeth along the rack
// height = Height of rack in mm, from pitch line to back of rack.
// ---
// pressure_angle = Controls how straight or bulged the tooth sides are. In degrees.
// backlash = Gap between two meshing teeth, in the direction along the circumference of the pitch circle
// clearance = Clearance gap at the bottom of the inter-tooth valleys.
// helical = The angle of the rack teeth away from perpendicular to the rack length. Stretches out the tooth shapes. Used to match helical spur gear pinions. Default: 0
// profile_shift = Profile shift factor x for tooth shape.
// gear_travel = The distance the rack should be moved by linearly. Default: 0
// rounding = If true, rack tips and valleys are slightly rounded. Default: true
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#subsection-anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#subsection-spin). Default: `0`
// Extra Anchors:
// "adendum" = At the tips of the teeth, at the center of rack.
// "adendum-left" = At the tips of the teeth, at the left end of the rack.
// "adendum-right" = At the tips of the teeth, at the right end of the rack.
// "dedendum" = At the height of the teeth, at the center of rack.
// "dedendum-left" = At the height of the teeth, at the left end of the rack.
// "dedendum-right" = At the height of the teeth, at the right end of the rack.
// Example(2D):
// rack2d(pitch=5, teeth=10, height=10, pressure_angle=20);
// Example(2D): Called as a Function
// path = rack2d(pitch=8, teeth=8, height=10, pressure_angle=20);
// polygon(path);
function rack2d(
pitch,
teeth,
height = 10,
pressure_angle,
backlash = 0,
clearance,
helical,
profile_shift = 0,
circ_pitch,
diam_pitch,
mod,
gear_travel = 0,
rounding = true,
anchor = CENTER,
spin = 0
) = let(
pitch = _inherit_gear_pitch("rack2d()",pitch, circ_pitch, diam_pitch, mod, warn=false),
PA = _inherit_gear_pa(pressure_angle),
helical = _inherit_gear_helical(helical)
)
assert(is_integer(teeth) && teeth>0)
assert(is_finite(height) && height>0)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(helical) && abs(helical)<90)
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(is_finite(gear_travel))
let(
adendum = _adendum(pitch, profile_shift),
dedendum = _dedendum(pitch, clearance, profile_shift)
)
assert(dedendum < height, "height= is not large enough.")
let(
trans_pitch = pitch / cos(helical),
trans_pa = atan(tan(PA)/cos(helical)),
tthick = trans_pitch/PI * (PI/2 + 2*profile_shift * tan(PA)) - backlash,
l = teeth * trans_pitch,
ax = ang_adj_to_opp(trans_pa, adendum),
dx = ang_adj_to_opp(trans_pa, dedendum),
clear = dedendum - adendum,
poff = tthick/2 - backlash,
tooth = [
[-trans_pitch/2, -dedendum],
if (rounding) each arc(n=4, r=clear, corner=[
[-trans_pitch/2, -dedendum],
[-poff-dx, -dedendum],
[-poff+ax, +adendum],
]) else [-poff-dx, -dedendum],
if (rounding) each arc(n=4, r=trans_pitch/16, corner=[
[-poff-dx, -dedendum],
[-poff+ax, +adendum],
[+poff-ax, +adendum],
]) else [-poff+ax, +adendum],
if (rounding) each arc(n=4, r=trans_pitch/16, corner=[
[-poff+ax, +adendum],
[+poff-ax, +adendum],
[+poff+dx, -dedendum],
]) else [+poff-ax, +adendum],
if (rounding) each arc(n=4, r=clear, corner=[
[+poff-ax, +adendum],
[+poff+dx, -dedendum],
[+trans_pitch/2, -dedendum],
]) else [+poff+dx, -dedendum],
[+trans_pitch/2, -dedendum],
],
path2 = [
for(m = xcopies(trans_pitch,n=teeth))
each apply(m,tooth)
],
path = right(gear_travel, p=[
[path2[0].x, -height],
each path2,
[last(path2).x, -height],
]),
size=[l,2*height],
anchors = [
named_anchor("adendum", [ 0, adendum,0], BACK),
named_anchor("adendum-left", [-l/2, adendum,0], LEFT),
named_anchor("adendum-right", [ l/2, adendum,0], RIGHT),
named_anchor("dedendum", [ 0,-dedendum,0], BACK),
named_anchor("dedendum-left", [-l/2,-dedendum,0], LEFT),
named_anchor("dedendum-right", [ l/2,-dedendum,0], RIGHT),
]
) reorient(anchor,spin, two_d=true, size=size, anchors=anchors, p=path);
module rack2d(
pitch,
teeth,
height = 10,
pressure_angle,
backlash = 0.0,
clearance,
helical,
profile_shift = 0,
gear_travel = 0,
circ_pitch,
diam_pitch,
mod,
anchor = CENTER,
spin = 0
) {
pitch = _inherit_gear_pitch("rack2d()",pitch, circ_pitch, diam_pitch, mod, warn=false);
PA = _inherit_gear_pa(pressure_angle);
helical = _inherit_gear_helical(helical);
checks =
assert(is_integer(teeth) && teeth>0)
assert(is_finite(height) && height>0)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(helical) && abs(helical)<90)
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(is_finite(gear_travel));
trans_pitch = pitch / cos(helical);
a = _adendum(pitch, profile_shift);
d = _dedendum(pitch, clearance, profile_shift);
l = teeth * trans_pitch;
path = rack2d(
pitch = pitch,
teeth = teeth,
height = height,
pressure_angle = PA,
backlash = backlash,
clearance = clearance,
helical = helical,
profile_shift= profile_shift
);
size = [l, 2*height];
anchors = [
named_anchor("adendum", [ 0, a,0], BACK),
named_anchor("adendum-left", [-l/2, a,0], LEFT),
named_anchor("adendum-right", [ l/2, a,0], RIGHT),
named_anchor("dedendum", [ 0,-d,0], BACK),
named_anchor("dedendum-left", [-l/2,-d,0], LEFT),
named_anchor("dedendum-right", [ l/2,-d,0], RIGHT),
];
attachable(anchor,spin, two_d=true, size=size, anchors=anchors) {
right(gear_travel) polygon(path);
children();
}
}
// Function&Module: bevel_gear()
// Synopsis: Creates a straight or spiral bevel gear.
// SynTags: Geom, VNF
// Topics: Gears, Parts
// See Also: rack(), rack2d(), spur_gear(), spur_gear2d(), bevel_pitch_angle(), bevel_gear()
// Usage: As a Module
// bevel_gear(circ_pitch, teeth, face_width, [pitch_angle=]|[mate_teeth=], [shaft_diam=], [hide=], [pressure_angle=], [clearance=], [backlash=], [cutter_radius=], [spiral_angle=], [left_handed=], [slices=], [internal=]);
// bevel_gear(mod=, teeth=, face_width=, [pitch_angle=]|[mate_teeth=], [shaft_diam=], [hide=], [pressure_angle=], [clearance=], [backlash=], [cutter_radius=], [spiral_angle=], [left_handed=], [slices=], [internal=]);
// Usage: As a Function
// vnf = bevel_gear(circ_pitch, teeth, face_width, [pitch_angle=]|[mate_teeth=], [hide=], [pressure_angle=], [clearance=], [backlash=], [cutter_radius=], [spiral_angle=], [left_handed=], [slices=], [internal=]);
// vnf = bevel_gear(mod=, teeth=, face_width=, [pitch_angle=]|[mate_teeth=], [hide=], [pressure_angle=], [clearance=], [backlash=], [cutter_radius=], [spiral_angle=], [left_handed=], [slices=], [internal=]);
// Description:
// Creates a (potentially spiral) bevel gear. The module `bevel_gear()` gives a bevel gear, with
// reasonable defaults for all the parameters. Normally, you should just choose the first 4
// parameters, and let the rest be default values. In straight bevel gear sets, when each tooth
// engages it inpacts the corresponding tooth. The abrupt tooth engagement causes impact stress
// which makes them more prone to breakage. Spiral bevel gears have teeth formed along spirals so
// they engage more gradually, resulting in a less abrupt transfer of force, so they are quieter
// in operation and less likely to break.
// .
// The module `bevel_gear()` gives a gear in the XY plane, centered on the origin, with one tooth
// centered on the positive Y axis. The various functions below it take the same parameters, and
// return various measurements for the gear. The most important function is `mesh_radius()`, which tells
// how far apart to space gears that are meshing, and `outer_radius()`, which gives the size of the
// region filled by the gear. A gear has a "pitch circle", which is an invisible circle that cuts
// through the middle of each tooth (though not the exact center). In order for two gears to mesh,
// their pitch circles should just touch, if no profile shifting is done). So the distance between
// their centers should be `mesh_radius()` for one, plus `mesh_radius()` for the other, which gives
// the radii of their pitch circles and profile shifts. In order for two gears to mesh, they must
// have the same `circ_pitch` and `pressure_angle` parameters. `circ_pitch` gives the number of millimeters
// of arc around the pitch circle covered by one tooth and one space between teeth. The `pressure_angle`
// controls how flat or bulged the sides of the teeth are. Common values include 14.5 degrees and 20
// degrees, and occasionally 25. The default here is 20 degrees. Larger numbers bulge out more,
// giving stronger teeth. The ratio of `teeth` for two meshing gears gives how many times one will make a full
// revolution when the the other makes one full revolution. If the two numbers are coprime (i.e.
// are not both divisible by the same number greater than 1), then every tooth on one gear will meet
// every tooth on the other, for more even wear. So coprime numbers of teeth are good.
// Arguments:
// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm. Default: 5
// teeth = Total number of teeth around the entire perimeter. Default: 20
// face_width = Width of the toothed surface in mm, from inside to outside. Default: 10
// ---
// pitch_angle = Angle of beveled gear face. Default: 45
// mate_teeth = The number of teeth in the gear that this gear will mate with. Overrides `pitch_angle` if given.
// shaft_diam = Diameter of the hole in the center, in mm. Module use only. Default: 0 (no shaft hole)
// hide = Number of teeth to delete to make this only a fraction of a circle. Default: 0
// pressure_angle = Controls how straight or bulged the tooth sides are. In degrees. Default: 20
// clearance = Clearance gap at the bottom of the inter-tooth valleys.
// backlash = Gap between two meshing teeth, in the direction along the circumference of the pitch circle. Default: 0
// cutter_radius = Radius of spiral arc for teeth. If 0, then gear will not be spiral. Default: 0
// spiral_angle = The base angle for spiral teeth. Default: 0
// left_handed = If true, the gear returned will have a left-handed spiral. Default: false
// slices = Number of vertical layers to divide gear into. Useful for refining gears with `spiral`. Default: 1
// internal = If true, create a mask for difference()ing from something else.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#subsection-anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#subsection-spin). Default: `0`
// orient = Vector to rotate top towards, after spin. See [orient](attachments.scad#subsection-orient). Default: `UP`
// Extra Anchors:
// "apex" = At the pitch cone apex for the bevel gear.
// "pitchbase" = At the natural height of the pitch radius of the beveled gear.
// "flattop" = At the top of the flat top of the bevel gear.
// Side Effects:
// If internal is true then the default tag is "remove"
// Example: Beveled Gear
// bevel_gear(
// circ_pitch=5, teeth=36, face_width=10, shaft_diam=5,
// pitch_angle=45, spiral_angle=0
// );
// Example: Spiral Beveled Gear and Pinion
// t1 = 16; t2 = 28;
// bevel_gear(
// circ_pitch=5, teeth=t1, mate_teeth=t2,
// slices=12, anchor="apex", orient=FWD
// );
// bevel_gear(
// circ_pitch=5, teeth=t2, mate_teeth=t1, left_handed=true,
// slices=12, anchor="apex", spin=180/t2
// );
// Example(Anim,Frames=4,VPD=175): Manual Spacing of Pinion and Gear
// t1 = 14; t2 = 28; circ_pitch=5;
// back(pitch_radius(circ_pitch, t2)) {
// yrot($t*360/t1)
// bevel_gear(
// circ_pitch=circ_pitch, teeth=t1, mate_teeth=t2, shaft_diam=5,
// slices=12, orient=FWD
// );
// }
// down(pitch_radius(circ_pitch, t1)) {
// zrot($t*360/t2)
// bevel_gear(
// circ_pitch=circ_pitch, teeth=t2, mate_teeth=t1, left_handed=true,
// shaft_diam=5, slices=12, spin=180/t2
// );
// }
function bevel_gear(
circ_pitch,
teeth,
face_width = 10,
pitch_angle = 45,
mate_teeth,
hide = 0,
pressure_angle = 20,
clearance,
backlash = 0.0,
cutter_radius = 30,
spiral_angle = 35,
left_handed = false,
slices = 5,
internal,
interior,
pitch,
diam_pitch,
mod,
anchor = "pitchbase",
spin = 0,
orient = UP
) = let(
dummy = !is_undef(interior) ? echo("In bevel_gear(), the argument 'interior=' has been deprecated, and may be removed in the future. Please use 'internal=' instead."):0,
internal = first_defined([internal,interior,false]),
circ_pitch = _inherit_gear_pitch("bevel_gear()",pitch, circ_pitch, diam_pitch, mod),
PA = _inherit_gear_pa(pressure_angle),
spiral_angle = _inherit_gear_helical(spiral_angle, invert=!internal),
face_width = _inherit_gear_thickness(face_width),
slices = cutter_radius==0? 1 : slices,
pitch_angle = is_undef(mate_teeth)? pitch_angle : atan(teeth/mate_teeth),
pr = pitch_radius(circ_pitch, teeth),
rr = _root_radius(circ_pitch, teeth, clearance, internal),
pitchoff = (pr-rr) * sin(pitch_angle),
ocone_rad = opp_ang_to_hyp(pr, pitch_angle),
icone_rad = ocone_rad - face_width,
cutter_radius = cutter_radius==0? 1000 : cutter_radius,
midpr = (icone_rad + ocone_rad) / 2,
radcp = [0, midpr] + polar_to_xy(cutter_radius, 180+spiral_angle),
angC1 = law_of_cosines(a=cutter_radius, b=norm(radcp), c=ocone_rad),
angC2 = law_of_cosines(a=cutter_radius, b=norm(radcp), c=icone_rad),
radcpang = v_theta(radcp),
sang = radcpang - (180-angC1),
eang = radcpang - (180-angC2),
profile = reverse(_gear_tooth_profile(
circ_pitch = circ_pitch,
teeth = teeth,
pressure_angle = PA,
clearance = clearance,
backlash = backlash,
internal = internal,
center = true
)),
verts1 = [
for (v = lerpn(0,1,slices+1)) let(
p = radcp + polar_to_xy(cutter_radius, lerp(sang,eang,v)),
ang = v_theta(p)-90,
dist = norm(p)
) [
let(
u = dist / ocone_rad,
m = up((1-u) * pr / tan(pitch_angle)) *
up(pitchoff) *
zrot(ang/sin(pitch_angle)) *
back(u * pr) *
xrot(pitch_angle) *
scale(u)
)
for (tooth=[0:1:teeth-1])
each apply(xflip() * zrot(360*tooth/teeth) * m, path3d(profile))
]
],
botz = verts1[0][0].z,
topz = last(verts1)[0].z,
thickness = abs(topz - botz),
cpz = (topz + botz) / 2,
vertices = [for (x=verts1) reverse(x)],
sides_vnf = vnf_vertex_array(vertices, caps=false, col_wrap=true, reverse=true),
top_verts = last(vertices),
bot_verts = vertices[0],
gear_pts = len(top_verts),
face_pts = gear_pts / teeth,
top_faces =[
for (i=[0:1:teeth-1], j=[0:1:(face_pts/2)-1]) each [
[i*face_pts+j, (i+1)*face_pts-j-1, (i+1)*face_pts-j-2],
[i*face_pts+j, (i+1)*face_pts-j-2, i*face_pts+j+1]
],
for (i=[0:1:teeth-1]) each [
[gear_pts, (i+1)*face_pts-1, i*face_pts],
[gear_pts, ((i+1)%teeth)*face_pts, (i+1)*face_pts-1]
]
],
vnf1 = vnf_join([
[
[each top_verts, [0,0,top_verts[0].z]],
top_faces
],
[
[each bot_verts, [0,0,bot_verts[0].z]],
[for (x=top_faces) reverse(x)]
],
sides_vnf
]),
lvnf = left_handed? vnf1 : xflip(p=vnf1),
vnf = down(cpz, p=lvnf),
anchors = [
named_anchor("pitchbase", [0,0,pitchoff-thickness/2]),
named_anchor("flattop", [0,0,thickness/2]),
named_anchor("apex", [0,0,hyp_ang_to_opp(ocone_rad,90-pitch_angle)+pitchoff-thickness/2])
]
) reorient(anchor,spin,orient, vnf=vnf, extent=true, anchors=anchors, p=vnf);
module bevel_gear(
circ_pitch,
teeth,
face_width = 10,
pitch_angle = 45,
mate_teeth,
shaft_diam = 0,
pressure_angle = 20,
clearance = undef,
backlash = 0.0,
cutter_radius = 30,
spiral_angle = 35,
left_handed = false,
slices = 5,
internal,
interior,
pitch,
diam_pitch,
mod,
anchor = "pitchbase",
spin = 0,
orient = UP
) {
dummy = !is_undef(interior) ? echo("In bevel_gear(), the argument 'interior=' has been deprecated, and may be removed in the future. Please use 'internal=' instead."):0;
internal = first_defined([internal,interior,false]);
circ_pitch = _inherit_gear_pitch("bevel_gear()",pitch, circ_pitch, diam_pitch, mod);
PA = _inherit_gear_pa(pressure_angle);
spiral_angle = _inherit_gear_helical(spiral_angle, invert=!internal);
face_width = _inherit_gear_thickness(face_width);
slices = cutter_radius==0? 1 : slices;
pitch_angle = is_undef(mate_teeth)? pitch_angle : atan(teeth/mate_teeth);
pr = pitch_radius(circ_pitch, teeth);
ipr = pr - face_width*sin(pitch_angle);
rr = _root_radius(circ_pitch, teeth, clearance, internal);
pitchoff = (pr-rr) * sin(pitch_angle);
vnf = bevel_gear(
circ_pitch = circ_pitch,
teeth = teeth,
face_width = face_width,
pitch_angle = pitch_angle,
pressure_angle = PA,
clearance = clearance,
backlash = backlash,
cutter_radius = cutter_radius,
spiral_angle = spiral_angle,
left_handed = left_handed,
slices = slices,
internal = internal,
anchor=CENTER
);
axis_zs = [for (p=vnf[0]) if(norm(point2d(p)) < EPSILON) p.z];
thickness = max(axis_zs) - min(axis_zs);
anchors = [
named_anchor("pitchbase", [0,0,pitchoff-thickness/2]),
named_anchor("flattop", [0,0,thickness/2]),
named_anchor("apex", [0,0,adj_ang_to_opp(pr,90-pitch_angle)+pitchoff-thickness/2])
];
default_tag("remove",internal) {
attachable(anchor,spin,orient, r1=pr, r2=ipr, h=thickness, anchors=anchors) {
difference() {
vnf_polyhedron(vnf, convexity=teeth/2);
if (shaft_diam > 0) {
cylinder(h=2*thickness+1, r=shaft_diam/2, center=true, $fn=max(12,segs(shaft_diam/2)));
}
}
children();
}
}
}
// Function&Module: worm()
// Synopsis: Creates a worm that will mate with a worm gear.
// SynTags: Geom, VNF
// Topics: Gears, Parts
// See Also: worm(), worm_gear(), rack(), rack2d(), spur_gear(), spur_gear2d(), bevel_pitch_angle(), bevel_gear()
// Usage: As a Module
// worm(circ_pitch, d, l, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
// worm(mod=, d=, l=, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
// Usage: As a Function
// vnf = worm(circ_pitch, d, l, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
// vnf = worm(mod=, d=, l=, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
// Description:
// Creates a worm shape that can be matched to a worm gear.
// Arguments:
// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm. Default: 5
// d = The diameter of the worm. Default: 30
// l = The length of the worm. Default: 100
// starts = The number of lead starts. Default: 1
// left_handed = If true, the gear returned will have a left-handed spiral. Default: false
// pressure_angle = Controls how straight or bulged the tooth sides are. In degrees. Default: 20
// backlash = Gap between two meshing teeth, in the direction along the circumference of the pitch circle. Default: 0
// clearance = Clearance gap at the bottom of the inter-tooth valleys.
// profile_shift = Profile shift factor x.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#subsection-anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#subsection-spin). Default: `0`
// orient = Vector to rotate top towards, after spin. See [orient](attachments.scad#subsection-orient). Default: `UP`
// Example:
// worm(circ_pitch=8, d=30, l=50, $fn=72);
// Example: Multiple Starts.
// worm(circ_pitch=8, d=30, l=50, starts=3, $fn=72);
// Example: Left Handed
// worm(circ_pitch=8, d=30, l=50, starts=3, left_handed=true, $fn=72);
// Example: Called as Function
// vnf = worm(circ_pitch=8, d=35, l=50, starts=2, left_handed=true, pressure_angle=20, $fn=72);
// vnf_polyhedron(vnf);
function worm(
circ_pitch,
d=30, l=100,
starts=1,
left_handed=false,
pressure_angle,
backlash=0,
clearance,
profile_shift,
diam_pitch,
mod,
pitch,
anchor=CENTER,
spin=0,
orient=UP
) =
let(
circ_pitch = _inherit_gear_pitch("worm()", pitch, circ_pitch, diam_pitch, mod),
PA = _inherit_gear_pa(pressure_angle),
profile_shift = default(profile_shift, 0)
)
assert(is_integer(starts) && starts>0)
assert(is_finite(l) && l>0)
//assert(is_finite(shaft_diam) && shaft_diam>=0)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_bool(left_handed))
assert(is_finite(profile_shift) && abs(profile_shift)<1)
//assert(is_finite(gear_spin))
let(
helical = asin(starts * circ_pitch / PI / d),
trans_pitch = circ_pitch / cos(helical),
tooth = xflip(
p=select(rack2d(
pitch=circ_pitch,
teeth=1,
pressure_angle=PA,
clearance=clearance,
backlash=backlash,
helical=helical,
profile_shift=profile_shift
), 1, -2)
),
rack_profile = [
for (t = xcopies(trans_pitch, n=2*ceil(l/trans_pitch)+1))
each apply(t, tooth)
],
steps = max(36, segs(d/2)),
step = 360 / steps,
zsteps = ceil(l / circ_pitch * cos(helical) / starts * steps),
zstep = l / zsteps,
profiles = [
for (j = [0:1:zsteps]) [
for (i = [0:1:steps-1]) let(
u = i / steps - 0.5,
ang = 360 * (1 - u) + 90,
z = j*zstep - l/2,
zoff = circ_pitch * starts * u / cos(helical),
h = lookup(z+zoff, rack_profile)
)
cylindrical_to_xyz(d/2+h, ang, z)
]
],
vnf1 = vnf_vertex_array(profiles, caps=true, col_wrap=true, style="alt"),
vnf = left_handed? xflip(p=vnf1) : vnf1
) reorient(anchor,spin,orient, d=d, l=l, p=vnf);
module worm(
circ_pitch,
d=15, l=100,
starts=1,
left_handed=false,
pressure_angle,
backlash=0,
clearance,
profile_shift=0,
pitch,
diam_pitch,
mod,
gear_spin=0,
anchor=CENTER,
spin=0,
orient=UP
) {
circ_pitch = _inherit_gear_pitch("worm()", pitch, circ_pitch, diam_pitch, mod);
PA = _inherit_gear_pa(pressure_angle);
profile_shift = default(profile_shift, auto_profile_shift(starts,PA));
checks =
assert(is_integer(starts) && starts>0)
assert(is_finite(l) && l>0)
//assert(is_finite(shaft_diam) && shaft_diam>=0)
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_bool(left_handed))
assert(is_finite(gear_spin))
assert(is_finite(profile_shift) && abs(profile_shift)<1);
vnf = worm(
circ_pitch=circ_pitch,
starts=starts,
d=d, l=l,
left_handed=left_handed,
pressure_angle=PA,
backlash=backlash,
clearance=clearance,
profile_shift=profile_shift,
mod=mod
);
attachable(anchor,spin,orient, d=d, l=l) {
zrot(gear_spin) vnf_polyhedron(vnf, convexity=ceil(l/circ_pitch)*2);
children();
}
}
// Function&Module: worm_gear()
// Synopsis: Creates a worm gear that will mate with a worm.
// SynTags: Geom, VNF
// Topics: Gears, Parts
// See Also: worm(), worm_gear(), rack(), rack2d(), spur_gear(), spur_gear2d(), bevel_pitch_angle(), bevel_gear()
// Usage: As a Module
// worm_gear(circ_pitch, teeth, worm_diam, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=], [shaft_diam=]) [ATTACHMENTS];
// worm_gear(mod=, teeth=, worm_diam=, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=], [shaft_diam=]) [ATTACHMENTS];
// Usage: As a Function
// vnf = worm_gear(circ_pitch, teeth, worm_diam, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=]);
// vnf = worm_gear(mod=, teeth=, worm_diam=, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=]);
// Description:
// Creates a worm gear to match with a worm.
// Arguments:
// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm. Default: 5
// teeth = Total number of teeth along the rack. Default: 30
// worm_diam = The pitch diameter of the worm gear to match to. Default: 30
// worm_starts = The number of lead starts on the worm gear to match to. Default: 1
// worm_arc = The arc of the worm to mate with, in degrees. Default: 60 degrees
// crowning = The amount to oversize the virtual hobbing cutter used to make the teeth, to add a slight crowning to the teeth to make them fit the work easier. Default: 1
// left_handed = If true, the gear returned will have a left-handed spiral. Default: false
// pressure_angle = Controls how straight or bulged the tooth sides are. In degrees. Default: 20
// backlash = Gap between two meshing teeth, in the direction along the circumference of the pitch circle. Default: 0
// clearance = Clearance gap at the bottom of the inter-tooth valleys.
// profile_shift = Profile shift factor x.
// slices = The number of vertical slices to refine the curve of the worm throat. Default: 10
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#subsection-anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#subsection-spin). Default: `0`
// orient = Vector to rotate top towards, after spin. See [orient](attachments.scad#subsection-orient). Default: `UP`
// Example: Right-Handed
// worm_gear(circ_pitch=5, teeth=36, worm_diam=30, worm_starts=1);
// Example: Left-Handed
// worm_gear(circ_pitch=5, teeth=36, worm_diam=30, worm_starts=1, left_handed=true);
// Example: Multiple Starts
// worm_gear(circ_pitch=5, teeth=36, worm_diam=30, worm_starts=4);
// Example: Metric Worm Gear
// worm_gear(mod=2, teeth=32, worm_diam=30, worm_starts=1);
// Example(Anim,Frames=4,FrameMS=125,VPD=220,VPT=[-15,0,0]): Meshing Worm and Gear
// $fn=36;
// circ_pitch = 5; starts = 4;
// worm_diam = 30; worm_length = 50;
// gear_teeth=36;
// right(worm_diam/2)
// yrot($t*360/starts)
// worm(
// d=worm_diam,
// l=worm_length,
// circ_pitch=circ_pitch,
// starts=starts,
// orient=BACK);
// left(pitch_radius(circ_pitch, gear_teeth))
// zrot(-$t*360/gear_teeth)
// worm_gear(
// circ_pitch=circ_pitch,
// teeth=gear_teeth,
// worm_diam=worm_diam,
// worm_starts=starts);
// Example: Meshing Worm and Gear Metricly
// $fn = 72;
// modulus = 2; starts = 3;
// worm_diam = 30; worm_length = 50;
// gear_teeth=36;
// right(worm_diam/2)
// worm(d=worm_diam, l=worm_length, mod=modulus, starts=starts, orient=BACK);
// left(pitch_radius(mod=modulus, teeth=gear_teeth))
// worm_gear(mod=modulus, teeth=gear_teeth, worm_diam=worm_diam, worm_starts=starts);
// Example: Called as Function
// vnf = worm_gear(circ_pitch=8, teeth=30, worm_diam=30, worm_starts=1);
// vnf_polyhedron(vnf);
function worm_gear(
circ_pitch,
teeth,
worm_diam,
worm_starts = 1,
worm_arc = 60,
crowning = 0.1,
left_handed = false,
pressure_angle,
backlash = 0,
clearance,
profile_shift,
slices = 10,
gear_spin=0,
pitch,
diam_pitch,
mod,
anchor = CENTER,
spin = 0,
orient = UP
) =
assert(worm_arc >= 10 && worm_arc <= 60)
let(
circ_pitch = _inherit_gear_pitch("worm_gear()", pitch, circ_pitch, diam_pitch, mod),
PA = _inherit_gear_pa(pressure_angle),
profile_shift = default(profile_shift, auto_profile_shift(teeth,PA))
)
assert(is_integer(teeth) && teeth>10)
assert(is_finite(worm_diam) && worm_diam>0)
assert(is_integer(worm_starts) && worm_starts>0)
assert(is_finite(worm_arc) && worm_arc>0 && worm_arc<90)
assert(is_finite(crowning) && crowning>=0)
assert(is_bool(left_handed))
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
//assert(is_finite(shaft_diam) && shaft_diam>=0)
assert(slices==undef || (is_integer(slices) && slices>0))
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(is_finite(gear_spin))
let(
helical = asin(worm_starts * circ_pitch / PI / worm_diam),
pr = pitch_radius(circ_pitch, teeth, helical),
hob_rad = worm_diam / 2 + crowning,
thickness = worm_gear_thickness(circ_pitch=circ_pitch, teeth=teeth, worm_diam=worm_diam, worm_arc=worm_arc, crowning=crowning, clearance=clearance),
tooth_profile = _gear_tooth_profile(
circ_pitch=circ_pitch,
teeth=teeth,
pressure_angle=PA,
clearance=clearance,
backlash=backlash,
helical=helical,
profile_shift=profile_shift,
center=true
),
tbot = min(column(tooth_profile,1)),
arcthick = hob_rad * sin(worm_arc/2) * 2,
twist = sin(helical)*arcthick / (2*PI*pr) * 360,
profiles = [
for (slice = [0:1:slices]) let(
u = slice/slices - 0.5
) [
for (i = [0:1:teeth-1]) each
apply(
zrot(-i*360/teeth + twist*u - 0.5) *
right(pr+hob_rad) *
yrot(u*worm_arc) *
left(hob_rad) *
zrot(-90) *
back(tbot) *
scale(cos(u*worm_arc)) *
fwd(tbot),
path3d(tooth_profile)
)
]
],
top_verts = last(profiles),
bot_verts = profiles[0],
face_pts = len(tooth_profile),
gear_pts = face_pts * teeth,
top_faces =[
for (i=[0:1:teeth-1], j=[0:1:(face_pts/2)-2]) each [
[i*face_pts+j, (i+1)*face_pts-j-1, (i+1)*face_pts-j-2],
[i*face_pts+j, (i+1)*face_pts-j-2, i*face_pts+j+1]
],
for (i=[0:1:teeth-1]) each [
[gear_pts, (i+1)*face_pts-1, i*face_pts],
[gear_pts, ((i+1)%teeth)*face_pts, (i+1)*face_pts-1]
]
],
sides_vnf = vnf_vertex_array(profiles, caps=false, col_wrap=true, style="min_edge"),
vnf1 = vnf_join([
[
[each top_verts, [0,0,top_verts[0].z]],
[for (x=top_faces) reverse(x)]
],
[
[each bot_verts, [0,0,bot_verts[0].z]],
top_faces
],
sides_vnf
]),
m = product([
zrot(gear_spin),
if (left_handed) xflip(),
]),
vnf = apply(m,vnf1)
) reorient(anchor,spin,orient, r=pr, l=thickness, p=vnf);
module worm_gear(
circ_pitch,
teeth,
worm_diam,
worm_starts = 1,
worm_arc = 60,
crowning = 0.1,
left_handed = false,
pressure_angle,
clearance,
backlash = 0,
shaft_diam = 0,
slices = 10,
profile_shift,
gear_spin=0,
pitch,
diam_pitch,
mod,
anchor = CENTER,
spin = 0,
orient = UP
) {
circ_pitch = _inherit_gear_pitch("worm_gear()", pitch, circ_pitch, diam_pitch, mod);
PA = _inherit_gear_pa(pressure_angle);
profile_shift = default(profile_shift, auto_profile_shift(teeth,PA));
checks =
assert(is_integer(teeth) && teeth>10)
assert(is_finite(worm_diam) && worm_diam>0)
assert(is_integer(worm_starts) && worm_starts>0)
assert(is_finite(worm_arc) && worm_arc>0 && worm_arc<90)
assert(is_finite(crowning) && crowning>=0)
assert(is_bool(left_handed))
assert(is_finite(PA) && PA>=0 && PA<90, "Bad pressure_angle value.")
assert(clearance==undef || (is_finite(clearance) && clearance>=0))
assert(is_finite(backlash) && backlash>=0)
assert(is_finite(shaft_diam) && shaft_diam>=0)
assert(slices==undef || (is_integer(slices) && slices>0))
assert(is_finite(profile_shift) && abs(profile_shift)<1)
assert(is_finite(gear_spin));
helical = asin(worm_starts * circ_pitch / PI / worm_diam);
pr = pitch_radius(circ_pitch, teeth, helical);
vnf = worm_gear(
circ_pitch = circ_pitch,
teeth = teeth,
worm_diam = worm_diam,
worm_starts = worm_starts,
worm_arc = worm_arc,
crowning = crowning,
left_handed = left_handed,
pressure_angle = PA,
backlash = backlash,
clearance = clearance,
profile_shift = profile_shift,
slices = slices
);
thickness = pointlist_bounds(vnf[0])[1].z;
attachable(anchor,spin,orient, r=pr, l=thickness) {
zrot(gear_spin)
difference() {
vnf_polyhedron(vnf, convexity=teeth/2);
if (shaft_diam > 0) {
cylinder(h=2*thickness+1, r=shaft_diam/2, center=true, $fn=max(12,segs(shaft_diam/2)));
}
}
children();
}
}
/// Function: _gear_tooth_profile()
/// Usage: As Function
/// path = _gear_tooth_profile(pitch, teeth, [pressure_angle], [clearance], [backlash], [internal]);
/// Topics: Gears
/// See Also: spur_gear2d()
/// Description:
/// When called as a function, returns the 2D profile path for an individual gear tooth.
/// When called as a module, creates the 2D profile shape for an individual gear tooth.
/// Arguments:
/// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
/// teeth = Total number of teeth on the spur gear that this is a tooth for.
/// pressure_angle = Pressure Angle. Controls how straight or bulged the tooth sides are. In degrees.
/// clearance = Gap between top of a tooth on one gear and bottom of valley on a meshing gear (in millimeters)
/// backlash = Gap between two meshing teeth, in the direction along the circumference of the pitch circle
/// internal = If true, create a mask for difference()ing from something else.
/// center = If true, centers the pitch circle of the tooth profile at the origin. Default: false.
/// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
/// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
/// Example(2D):
/// _gear_tooth_profile(circ_pitch=5, teeth=20, pressure_angle=20);
/// Example(2D): Metric Gear Tooth
/// _gear_tooth_profile(mod=2, teeth=20, pressure_angle=20);
/// Example(2D):
/// _gear_tooth_profile(
/// circ_pitch=5, teeth=20, pressure_angle=20
/// );
/// Example(2D): As a function
/// path = _gear_tooth_profile(
/// circ_pitch=5, teeth=20, pressure_angle=20
/// );
/// stroke(path, width=0.1);
function _gear_tooth_profile(
circ_pitch,
teeth,
pressure_angle = 20,
clearance,
backlash = 0.0,
helical = 0,
internal = false,
profile_shift = 0.0,
center = false
) = let(
// Calculate a point on the involute curve, by angle.
_involute = function(base_r,a)
let(b=a*PI/180) base_r * [cos(a)+b*sin(a), sin(a)-b*cos(a)],
steps = 16,
// Calculate the important circle radii
arad = outer_radius(circ_pitch, teeth, helical=helical, profile_shift=profile_shift, internal=internal),
prad = pitch_radius(circ_pitch, teeth, helical=helical),
brad = _base_radius(circ_pitch, teeth, pressure_angle, helical=helical),
rrad = _root_radius(circ_pitch, teeth, clearance, helical=helical, profile_shift=profile_shift, internal=internal),
srad = max(rrad,brad),
clear = default(clearance, circ_pitch/PI * 0.25),
tthick = circ_pitch/PI / cos(helical) * (PI/2 + 2*profile_shift * tan(pressure_angle)) - backlash,
tang = tthick / prad / 2 * 180 / PI,
// Generate a lookup table for the involute curve angles, by radius
involute_lup = [
if (rrad < brad)
each xy_to_polar(arc(n=4, r=min(brad-rrad,clear), corner=[
polar_to_xy(rrad,90+180/teeth),
polar_to_xy(rrad,90),
polar_to_xy(brad,90),
])),
for (i=[0:5:arad/PI/brad*360])
let(
xy = _involute(brad,i),
pol = xy_to_polar(xy)
)
if (pol.x <= arad * 1.1)
[pol.x, 90-pol.y]
],
// Generate reverse lookup table for involute radii, by angle
involute_rlup = mirror([-1,1],p=involute_lup), // swaps X and Y columns.
a_ang = lookup(arad, involute_lup),
p_ang = lookup(prad, involute_lup),
b_ang = lookup(brad, involute_lup),
r_ang = lookup(rrad, involute_lup),
s_ang = lookup(srad, involute_lup),
soff = tang + (b_ang - p_ang),
ma_rad = min(arad, lookup(90-soff+0.05*360/teeth/2, involute_rlup)),
ma_ang = lookup(ma_rad, involute_lup),
cap_steps = ceil((ma_ang + soff - 90) / 5),
cap_step = (ma_ang + soff - 90) / cap_steps,
ax = circ_pitch/4 - ang_adj_to_opp(pressure_angle, circ_pitch/PI),
// Calculate the undercut a meshing rack might carve out of this tooth.
undercut = [
for (a=[atan2(ax,rrad):-1:-90])
let(
bx = -a/360 * 2*PI*prad,
x = bx + ax,
y = prad - circ_pitch/PI + profile_shift*circ_pitch/PI,
pol = xy_to_polar(x,y)
)
if (pol.x < arad*1.05)
[pol.x, pol.y-a+180/teeth]
],
uc_min = min_index(column(undercut,0)),
// Generate a fast lookup table for the undercut.
undercut_lup = [for (i=idx(undercut)) if (i>=uc_min) undercut[i]],
// The u values to use when generating the tooth.
us = [
for (i=[0:1:20-1]) 0.2*sin(i/20*90),
for (i=[2:1:steps-1]) i/(steps-1),
],
// Generate the left half of the tooth.
tooth_half_raw = deduplicate([
for (u = us) let(
r = lerp(rrad, ma_rad, u),
a1 = lookup(r, involute_lup) + soff,
a2 = lookup(r, undercut_lup),
a = internal || r < undercut_lup[0].x? a1 : min(a1,a2)
) if(a<90+180/teeth) polar_to_xy(r, a),
for (i=[0:1:cap_steps-1]) let(
a = ma_ang + soff - i * (cap_step-1)
) polar_to_xy(ma_rad, a),
]),
// Find undercut bottom "jaggie" if it exists.
minima = [
for (i = idx(tooth_half_raw))
let(p = tooth_half_raw[i])
if (i > 0 && i < len(tooth_half_raw)-1 && norm(p) <= prad)
let(
pp = tooth_half_raw[i-1],
np = tooth_half_raw[i+1]
)
if (p.x > pp.x && p.x > np.x)
i
],
// Strip "jaggies" if found.
tooth_half = len(minima)<2? tooth_half_raw : [
for (i = idx(tooth_half_raw))
let(p = tooth_half_raw[i])
if (i <= minima[0] || i >= last(minima))
p
],
// Mirror the tooth to complete it.
tooth = deduplicate([
each tooth_half,
each reverse(xflip(tooth_half)),
]),
out = center? fwd(prad, p=tooth) : tooth
) out;
// Section: Computing Gear Dimensions
// These functions let the user find the derived dimensions of the gear.
// A gear fits within a circle of radius outer_radius, and two gears should have
// their centers separated by the sum of their pitch_radius.
// Function: circular_pitch()
// Synopsis: Returns tooth density expressed as "circular pitch".
// Topics: Gears, Parts
// See Also: spur_gear(), diametral_pitch(), circular_pitch(), pitch_value(), module_value()
// Usage:
// circ_pitch = circular_pitch(circ_pitch);
// circ_pitch = circular_pitch(mod=);
// circ_pitch = circular_pitch(diam_pitch=);
// Description:
// Get tooth density expressed as "circular pitch", or the distance in mm between teeth around the pitch circle.
// For example, if you have a gear with 11 teeth, and the pitch diameter is 35mm, then the circumfrence
// of the pitch diameter is really close to 110mm, making the circular pitch of that gear about 10mm/tooth.
// Arguments:
// circ_pitch = The circular pitch, or distance in mm between teeth around the pitch circle.
// ---
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// Example(VPT=[0,31,0];VPR=[0,0,0];VPD=40):
// $fn=144;
// teeth=20;
// circ_pitch = circular_pitch(diam_pitch=8);
// pr = pitch_radius(circ_pitch, teeth);
// stroke(spur_gear2d(circ_pitch, teeth), width=0.1);
// color("cyan")
// dashed_stroke(circle(r=pr), width=0.1);
// color("black") {
// stroke(
// arc(r=pr, start=90+90/teeth, angle=-360/teeth),
// width=0.2, endcaps="arrow");
// back(pr+1) right(3)
// zrot(30) text("Circular Pitch", size=1);
// }
// Example:
// circ_pitch = circular_pitch(circ_pitch=5);
// circ_pitch = circular_pitch(diam_pitch=12);
// circ_pitch = circular_pitch(mod=2);
function circular_pitch(circ_pitch, mod, pitch, diam_pitch) =
assert(one_defined([pitch, mod, circ_pitch, diam_pitch], "pitch,mod,circ_pitch,diam_pitch"))
pitch != undef? assert(is_finite(pitch) && pitch>0) pitch :
circ_pitch != undef? assert(is_finite(circ_pitch) && circ_pitch>0) circ_pitch :
diam_pitch != undef? assert(is_finite(diam_pitch) && diam_pitch>0) PI / diam_pitch * INCH :
assert(is_finite(mod) && mod>0) mod * PI;
// Function: diametral_pitch()
// Synopsis: Returns tooth density expressed as "diametral pitch".
// Topics: Gears, Parts
// See Also: spur_gear(), diametral_pitch(), circular_pitch(), pitch_value(), module_value()
// Usage:
// dp = diametral_pitch(circ_pitch);
// dp = diametral_pitch(mod=);
// dp = diametral_pitch(diam_pitch=);
// Description:
// Returns tooth density expressed as "diametral pitch", the number of teeth per inch of pitch diameter.
// For example, if you have a gear with 30 teeth, with a 1.5 inch pitch diameter, then you have a
// diametral pitch of 20 teeth/inch.
// Arguments:
// circ_pitch = The circular pitch, or distance in mm between teeth around the pitch circle.
// ---
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// Example:
// diam_pitch = diametral_pitch(mod=2);
// diam_pitch = diametral_pitch(circ_pitch=8);
// diam_pitch = diametral_pitch(diam_pitch=16);
function diametral_pitch(circ_pitch, mod, pitch, diam_pitch) =
let( circ_pitch = circular_pitch(pitch, mod, circ_pitch, diam_pitch) )
PI / circ_pitch / INCH;
// Function: pitch_value()
// Synopsis: Returns tooth density expressed as "circular pitch".
// Topics: Gears, Parts
// See Also: spur_gear(), diametral_pitch(), circular_pitch(), pitch_value(), module_value()
// Usage:
// circ_pitch = pitch_value(mod);
// circ_pitch = pitch_value(circ_pitch=);
// circ_pitch = pitch_value(diam_pitch=);
// Description:
// Returns the circular pitch in mm from module/modulus or diametral pitch.
// The circular pitch of a gear is the number of millimeters per tooth around the pitch radius circle.
// For example, if you have a gear with 11 teeth, and the pitch diameter is 35mm, then the circumfrence
// of the pitch diameter is really close to 110mm, making the circular pitch of that gear about 10mm/tooth.
// Arguments:
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// ---
// circ_pitch = The circular pitch, or distance in mm between teeth around the pitch circle.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// Example:
// circ_pitch = pitch_value(mod=2);
// circ_pitch = pitch_value(circ_pitch=8);
// circ_pitch = pitch_value(diam_pitch=16);
function pitch_value(mod, circ_pitch, diam_pitch) =
circular_pitch(mod=mod, circ_pitch=circ_pitch, diam_pitch=diam_pitch);
// Function: module_value()
// Synopsis: Returns tooth density expressed as "module" or "modulus" in millimeters.
// Topics: Gears, Parts
// See Also: spur_gear(), diametral_pitch(), circular_pitch(), pitch_value(), module_value()
// Usage:
// mod = module_value(circ_pitch);
// mod = module_value(mod=);
// mod = module_value(diam_pitch=);
// Description:
// Get tooth density expressed as "module" or "modulus" in millimeters. The module is the pitch
// diameter of the gear divided by the number of teeth on it. For example, a gear with a pitch
// diameter of 40mm, with 20 teeth on it will have a modulus of 2.
// Arguments:
// circ_pitch = The circular pitch, or distance in mm between teeth around the pitch circle.
// ---
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// Example:
// mod = module_value(circ_pitch=8);
// mod = module_value(mod=2);
// mod = module_value(diam_pitch=16);
function module_value(circ_pitch, mod, pitch, diam_pitch) =
let( circ_pitch = circular_pitch(pitch, mod, circ_pitch, diam_pitch) )
circ_pitch / PI;
/// Function: _adendum()
/// Usage:
/// ad = _adendum(circ_pitch, [profile_shift]);
/// ad = _adendum(diam_pitch=, [profile_shift=]);
/// ad = _adendum(mod=, [profile_shift=]);
/// Topics: Gears
/// Description:
/// The height of the top of a gear tooth above the pitch radius circle.
/// Arguments:
/// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
/// profile_shift = Profile shift factor x.
/// ---
/// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
/// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
/// Example:
/// ad = _adendum(circ_pitch=5);
/// ad = _adendum(mod=2);
/// Example(2D):
/// circ_pitch = 5; teeth = 17;
/// pr = pitch_radius(circ_pitch, teeth);
/// adn = _adendum(circ_pitch=5);
/// #spur_gear2d(circ_pitch=circ_pitch, teeth=teeth);
/// color("black") {
/// stroke(circle(r=pr),width=0.1,closed=true);
/// stroke(circle(r=pr+adn),width=0.1,closed=true);
/// }
function _adendum(
circ_pitch,
profile_shift=0,
diam_pitch,
mod,
pitch
) =
let( mod = module_value(circ_pitch, mod, pitch, diam_pitch) )
mod * (1 + profile_shift);
/// Function: _dedendum()
/// Usage:
/// ddn = _dedendum(circ_pitch=, [clearance], [profile_shift]);
/// ddn = _dedendum(diam_pitch=, [clearance=], [profile_shift=]);
/// ddn = _dedendum(mod=, [clearance=], [profile_shift=]);
/// Topics: Gears
/// Description:
/// The depth of the gear tooth valley, below the pitch radius.
/// Arguments:
/// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
/// clearance = If given, sets the clearance between meshing teeth.
/// profile_shift = Profile shift factor x.
/// ---
/// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
/// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
/// Example:
/// ddn = _dedendum(circ_pitch=5);
/// ddn = _dedendum(mod=2);
/// Example(2D):
/// circ_pitch = 5; teeth = 17;
/// pr = pitch_radius(circ_pitch, teeth);
/// ddn = _dedendum(circ_pitch=5);
/// #spur_gear2d(circ_pitch=circ_pitch, teeth=teeth);
/// color("black") {
/// stroke(circle(r=pr),width=0.1,closed=true);
/// stroke(circle(r=pr-ddn),width=0.1,closed=true);
/// }
function _dedendum(
circ_pitch,
clearance,
profile_shift=0,
diam_pitch,
mod,
pitch
) = let(
mod = module_value(circ_pitch, mod, pitch, diam_pitch),
clearance = default(clearance, 0.25 * mod)
)
mod * (1 - profile_shift) + clearance;
// Function: pitch_radius()
// Synopsis: Returns the pitch radius for a gear.
// Topics: Gears, Parts
// See Also: spur_gear(), diametral_pitch(), circular_pitch(), pitch_value(), module_value(), outer_radius()
// Usage:
// pr = pitch_radius(pitch, teeth, [helical]);
// pr = pitch_radius(mod=, teeth=, [helical=]);
// Description:
// Calculates the pitch radius for the gear. Two mated gears will have their centers spaced apart
// by the sum of the two gear's pitch radii.
// Arguments:
// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// teeth = The number of teeth on the gear.
// helical = The helical angle (from vertical) of the teeth on the gear. Default: 0
// ---
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// Example:
// pr = pitch_radius(circ_pitch=5, teeth=11);
// pr = pitch_radius(circ_pitch=5, teeth=11, helical=30);
// pr = pitch_radius(diam_pitch=10, teeth=11);
// pr = pitch_radius(mod=2, teeth=20);
// pr = pitch_radius(mod=2, teeth=20, helical=30);
// Example(2D):
// $fn=144;
// teeth=17; circ_pitch = 5;
// pr = pitch_radius(circ_pitch, teeth);
// stroke(spur_gear2d(circ_pitch, teeth), width=0.1);
// color("blue") dashed_stroke(circle(r=pr), width=0.1);
// color("black") {
// stroke([[0,0],polar_to_xy(pr,45)],
// endcaps="arrow", width=0.3);
// fwd(1)
// text("Pitch Radius", size=1.5,
// halign="center", valign="top");
// }
function pitch_radius(
circ_pitch,
teeth,
helical=0,
mod,
diam_pitch,
pitch
) =
let( circ_pitch = circular_pitch(pitch, mod, circ_pitch, diam_pitch) )
circ_pitch * teeth / PI / 2 / cos(helical);
// Function: outer_radius()
// Synopsis: Returns the outer radius for a gear.
// Topics: Gears, Parts
// See Also: spur_gear(), diametral_pitch(), circular_pitch(), pitch_value(), module_value(), pitch_radius(), outer_radius()
// Usage:
// or = outer_radius(circ_pitch, teeth, [helical=], [clearance=], [internal=], [profile_shift=]);
// or = outer_radius(mod=, teeth=, [helical=], [clearance=], [internal=], [profile_shift=]);
// or = outer_radius(diam_pitch=, teeth=, [helical=], [clearance=], [internal=], [profile_shift=]);
// Description:
// Calculates the outer radius for the gear. The gear fits entirely within a cylinder of this radius.
// Arguments:
// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// teeth = The number of teeth on the gear.
// ---
// clearance = If given, sets the clearance between meshing teeth.
// profile_shift = Profile shift factor x.
// internal = If true, calculate for an internal gear.
// helical = The helical angle (from vertical) of the teeth on the gear. Default: 0
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// Example:
// or = outer_radius(circ_pitch=5, teeth=20);
// or = outer_radius(circ_pitch=5, teeth=20, helical=30);
// or = outer_radius(diam_pitch=10, teeth=17);
// or = outer_radius(mod=2, teeth=16);
// Example(2D):
// $fn=144;
// teeth=17; circ_pitch = 5;
// or = outer_radius(circ_pitch, teeth);
// stroke(spur_gear2d(circ_pitch, teeth), width=0.1);
// color("blue") dashed_stroke(circle(r=or), width=0.1);
// color("black") {
// stroke([[0,0],polar_to_xy(or,45)],
// endcaps="arrow", width=0.3);
// fwd(1)
// text("Outer Radius", size=1.5,
// halign="center", valign="top");
// }
function outer_radius(circ_pitch, teeth, clearance, internal=false, helical=0, profile_shift=0, mod, pitch, diam_pitch) =
let( circ_pitch = circular_pitch(pitch, mod, circ_pitch, diam_pitch) )
pitch_radius(circ_pitch, teeth, helical) + (
internal
? _dedendum(circ_pitch, clearance, profile_shift=profile_shift)
: _adendum(circ_pitch, profile_shift=profile_shift)
);
/// Function: _root_radius()
/// Usage:
/// rr = _root_radius(circ_pitch, teeth, [helical], [clearance=], [internal=], [profile_shift=]);
/// rr = _root_radius(diam_pitch=, teeth=, [helical=], [clearance=], [internal=], [profile_shift=]);
/// rr = _root_radius(mod=, teeth=, [helical=], [clearance=], [internal=], [profile_shift=]);
/// Topics: Gears
/// Description:
/// Calculates the root radius for the gear, at the base of the dedendum.
/// Arguments:
/// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
/// teeth = The number of teeth on the gear.
/// ---
/// clearance = If given, sets the clearance between meshing teeth.
/// internal = If true, calculate for an internal gear.
/// helical = The helical angle (from vertical) of the teeth on the gear. Default: 0
/// profile_shift = Profile shift factor x.
/// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
/// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
/// Example:
/// rr = _root_radius(circ_pitch=5, teeth=11);
/// rr = _root_radius(circ_pitch=5, teeth=16, helical=30);
/// rr = _root_radius(diam_pitch=10, teeth=11);
/// rr = _root_radius(mod=2, teeth=16);
/// Example(2D):
/// pr = _root_radius(circ_pitch=5, teeth=11);
/// #spur_gear2d(pitch=5, teeth=11);
/// color("black")
/// stroke(circle(r=pr),width=0.1,closed=true);
function _root_radius(circ_pitch, teeth, clearance, internal=false, helical=0, profile_shift=0, diam_pitch, mod, pitch) =
let( circ_pitch = circular_pitch(pitch, mod, circ_pitch, diam_pitch) )
pitch_radius(circ_pitch, teeth, helical) - (
internal
? _adendum(circ_pitch, profile_shift=profile_shift)
: _dedendum(circ_pitch, clearance, profile_shift=profile_shift)
);
/// Function: _base_radius()
/// Usage:
/// br = _base_radius(circ_pitch, teeth, [pressure_angle], [helical]);
/// br = _base_radius(diam_pitch=, teeth=, [pressure_angle=], [helical=]);
/// br = _base_radius(mod=, teeth=, [pressure_angle=], [helical=]);
/// Topics: Gears
/// Description:
/// Get the base circle for involute teeth, at the base of the teeth.
/// Arguments:
/// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
/// teeth = The number of teeth on the gear.
/// pressure_angle = Pressure angle in degrees. Controls how straight or bulged the tooth sides are.
/// helical = The helical angle (from vertical) of the teeth on the gear. Default: 0
/// ---
/// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
/// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
/// Example:
/// br = _base_radius(circ_pitch=5, teeth=20, pressure_angle=20);
/// br = _base_radius(circ_pitch=5, teeth=20, pressure_angle=20, helical=30);
/// br = _base_radius(diam_pitch=10, teeth=20, pressure_angle=20);
/// br = _base_radius(mod=2, teeth=18, pressure_angle=20);
/// Example(2D):
/// pr = _base_radius(circ_pitch=5, teeth=11);
/// #spur_gear2d(circ_pitch=5, teeth=11);
/// color("black")
/// stroke(circle(r=pr),width=0.1,closed=true);
function _base_radius(circ_pitch, teeth, pressure_angle=20, helical=0, diam_pitch, mod, pitch) =
let(
circ_pitch = circular_pitch(pitch, mod, circ_pitch, diam_pitch),
trans_pa = atan(tan(pressure_angle)/cos(helical))
)
pitch_radius(circ_pitch, teeth, helical) * cos(trans_pa);
// Function: bevel_pitch_angle()
// Synopsis: Returns the pitch cone angle for a bevel gear.
// Topics: Gears, Parts
// See Also: bevel_gear(), pitch_radius(), outer_radius()
// Usage:
// ang = bevel_pitch_angle(teeth, mate_teeth, [drive_angle=]);
// Description:
// Returns the correct pitch cone angle for a bevel gear with a given number of teeth, that is
// matched to another bevel gear with a (possibly different) number of teeth.
// Arguments:
// teeth = Number of teeth that this gear has.
// mate_teeth = Number of teeth that the matching gear has.
// drive_angle = Angle between the drive shafts of each gear. Default: 90ยบ.
// Example:
// ang = bevel_pitch_angle(teeth=18, mate_teeth=30);
// Example(2D):
// t1 = 13; t2 = 19; pitch=5;
// pang = bevel_pitch_angle(teeth=t1, mate_teeth=t2, drive_angle=90);
// color("black") {
// zrot_copies([0,pang])
// stroke([[0,0,0], [0,-20,0]],width=0.2);
// stroke(arc(r=3, angle=[270,270+pang]),width=0.2);
// }
// #bevel_gear(
// pitch=5, teeth=t1, mate_teeth=t2,
// spiral_angle=0, cutter_radius=1000,
// slices=12, anchor="apex", orient=BACK
// );
function bevel_pitch_angle(teeth, mate_teeth, drive_angle=90) =
atan(sin(drive_angle)/((mate_teeth/teeth)+cos(drive_angle)));
// Function: worm_gear_thickness()
// Synopsis: Returns the thickness for a worm gear.
// Topics: Gears, Parts
// See Also: worm(), worm_gear(), pitch_radius(), outer_radius()
// Usage:
// thick = worm_gear_thickness(pitch, teeth, worm_diam, [worm_arc=], [crowning=], [clearance=]);
// thick = worm_gear_thickness(mod=, teeth=, worm_diam=, [worm_arc=], [crowning=], [clearance=]);
// Description:
// Calculate the thickness of the worm gear.
// Arguments:
// circ_pitch = The circular pitch, or distance between teeth around the pitch circle, in mm. Default: 5
// teeth = Total number of teeth along the rack. Default: 30
// worm_diam = The pitch diameter of the worm gear to match to. Default: 30
// ---
// worm_arc = The arc of the worm to mate with, in degrees. Default: 60 degrees
// crowning = The amount to oversize the virtual hobbing cutter used to make the teeth, to add a slight crowning to the teeth to make them fit the work easier. Default: 1
// clearance = Clearance gap at the bottom of the inter-tooth valleys.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// Example:
// thick = worm_gear_thickness(circ_pitch=5, teeth=36, worm_diam=30);
// thick = worm_gear_thickness(mod=2, teeth=28, worm_diam=25);
// Example(2D):
// circ_pitch = 5; teeth=17;
// worm_diam = 30; starts=2;
// y = worm_gear_thickness(circ_pitch=circ_pitch, teeth=teeth, worm_diam=worm_diam);
// #worm_gear(
// circ_pitch=circ_pitch, teeth=teeth,
// worm_diam=worm_diam,
// worm_starts=starts,
// orient=BACK
// );
// color("black") {
// ycopies(y) stroke([[-25,0],[25,0]], width=0.5);
// stroke([[-20,-y/2],[-20,y/2]],width=0.5,endcaps="arrow");
// }
function worm_gear_thickness(circ_pitch, teeth, worm_diam, worm_arc=60, crowning=1, clearance, diam_pitch, mod, pitch) =
let(
circ_pitch = circular_pitch(pitch, mod, circ_pitch, diam_pitch),
r = worm_diam/2 + crowning,
pitch_thick = r * sin(worm_arc/2) * 2,
pr = pitch_radius(circ_pitch, teeth),
rr = _root_radius(circ_pitch, teeth, clearance, false),
pitchoff = (pr-rr) * sin(worm_arc/2),
thickness = pitch_thick + 2*pitchoff
) thickness;
// Function: mesh_radius()
// Synopsis: Returns the distance between two gear centers.
// Topics: Gears, Parts
// See Also: worm(), worm_gear(), pitch_radius(), outer_radius()
// Usage:
// dist = mesh_radius(pitch, teeth, [helical=], [profile_shift=], [pressure_angle=]);
// dist = mesh_radius(mod=, teeth=, [helical=], [profile_shift=], [pressure_angle=]);
// Description:
// Calculate the distance between the centers of two gears.
// Arguments:
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm. Default: 5
// teeth = Total number of teeth in the first gear. If given 0, we assume this is a rack or worm.
// ---
// helical = The helical angle (from vertical) of the teeth on the first gear. Default: 0
// profile_shift = Profile shift factor x for the first gear. Default: 0
// pressure_angle = The pressure angle of the gear.
// diam_pitch = The diametral pitch, or number of teeth per inch of pitch diameter. Note that the diametral pitch is a completely different thing than the pitch diameter.
// mod = The metric module/modulus of the gear, or mm of pitch diameter per tooth.
// Example(2D):
// pitch=5; teeth1=7; teeth2=24;
// mr1 = mesh_radius(pitch, teeth1);
// mr2 = mesh_radius(pitch, teeth2);
// left(mr1) spur_gear2d(pitch, teeth1, gear_spin=-90);
// right(mr2) spur_gear2d(pitch, teeth2, gear_spin=90-180/teeth2);
// Example: Non-parallel Helical Gears
// pitch=5; teeth1=15; teeth2=24; ha1=45; ha2=30; thick=10;
// mr1 = mesh_radius(pitch, teeth1, helical=ha1);
// mr2 = mesh_radius(pitch, teeth2, helical=ha2);
// left(mr1) spur_gear(pitch, teeth1, helical=ha1, thickness=thick, gear_spin=-90);
// right(mr2) xrot(ha1+ha2) spur_gear(pitch, teeth2, helical=ha2, thickness=thick, gear_spin=90-180/teeth2);
// Example(2D): Disable Auto Profile Shifting on the Small Gear
// pitch=5; teeth1=7; teeth2=24;
// mr1 = mesh_radius(pitch, teeth1, profile_shift=0);
// mr2 = mesh_radius(pitch, teeth2);
// left(mr1) spur_gear2d(pitch, teeth1, profile_shift=0, gear_spin=-90);
// right(mr2) spur_gear2d(pitch, teeth2, gear_spin=90-180/teeth2);
// Example(2D): Manual Profile Shifting
// pitch=5; teeth1=7; teeth2=24; ps1 = 0.5; ps2 = -0.2;
// mr1 = mesh_radius(pitch, teeth1, profile_shift=ps1);
// mr2 = mesh_radius(pitch, teeth2, profile_shift=ps2);
// left(mr1) spur_gear2d(pitch, teeth1, profile_shift=ps1, gear_spin=-90);
// right(mr2) spur_gear2d(pitch, teeth2, profile_shift=ps2, gear_spin=90-180/teeth2);
function mesh_radius(
circ_pitch,
teeth,
helical=0,
profile_shift,
pressure_angle=20,
diam_pitch,
mod,
pitch
) =
let(
circ_pitch = circular_pitch(pitch, mod, circ_pitch, diam_pitch),
profile_shift = default(profile_shift, teeth>0? auto_profile_shift(teeth,pressure_angle) : 0),
mod = circ_pitch / PI,
pr = teeth>0? pitch_radius(circ_pitch, teeth, helical) : 0,
r = pr + profile_shift * mod
) r;
// Function: auto_profile_shift()
// Synopsis: Returns the recommended profile shift for a gear.
// Topics: Gears, Parts
// See Also: worm(), worm_gear(), pitch_radius(), outer_radius()
// Usage:
// x = auto_profile_shift(teeth, pressure_angle);
// x = auto_profile_shift(teeth, min_teeth=);
// Description:
// Calculates the recommended profile shift to avoid gear tooth undercutting.
// Arguments:
// teeth = Total number of teeth in the gear.
// pressure_angle = The pressure angle of the gear.
// ---
// min_teeth = If given, the minimum number of teeth on a gear that has acceptable undercut.
function auto_profile_shift(teeth, pressure_angle=20, min_teeth) =
let(
min_teeth = is_undef(min_teeth)
? 2 / pow(sin(pressure_angle),2)
: min_teeth
)
teeth > floor(min_teeth)? 0 :
1 - (teeth / min_teeth);
// vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap