////////////////////////////////////////////////////////////////////////////////////////////// // LibFile: gears.scad // Spur Gears, Bevel Gears, Racks, Worms and Worm Gears. // Inspired by code by Leemon Baird, 2011, Leemon@Leemon.com // Includes: // include // include // FileGroup: Parts // FileSummary: Gears, racks, worms, and worm gears. ////////////////////////////////////////////////////////////////////////////////////////////// // 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() // Usage: As a Module // spur_gear(pitch, teeth, thickness, [shaft_diam], [hide=], [pressure_angle=], [clearance=], [backlash=], [helical=], [slices=], [interior=]) [ATTACHMENTS]; // spur_gear(mod=, teeth=, thickness=, [shaft_diam=], ...) [ATTACHMENTS]; // Usage: As a Function // vnf = spur_gear(pitch, teeth, thickness, [shaft_diam], ...); // vnf = spur_gear(mod=, teeth=, thickness=, [shaft_diam], ...); // Topics: Gears // See Also: rack() // Description: // Creates a (potentially helical) involute spur 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. 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 is `pitch_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 `pitch_radius()` for one, plus `pitch_radius()` for the // other, which gives the radii of their pitch circles. 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. Though I've seen 28 recommended for plastic // gears. Larger numbers bulge out more, giving stronger teeth, so 28 degrees is the default here. // 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: // pitch = The circular pitch, or distance between teeth around the pitch circle, in mm. // 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`. // scale = Scale of top of gear compared to bottom. Useful for making crown gears. // interior = If true, create a mask for difference()ing from something else. // mod = The metric module/modulus of the 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` // Example: Spur Gear // spur_gear(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( // pitch=5, teeth=20, thickness=10, // shaft_diam=5, helical=-30, slices=12, // $fa=1, $fs=1 // ); // 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 = 5; //blue gear // n4 = 16; //orange gear // n5 = 9; //gray rack // pitch = 9; //all meshing gears need the same `pitch` (and the same `pressure_angle`) // thickness = 6; // hole = 3; // rack_base = 12; // r1 = pitch_radius(pitch,n1); // r2 = pitch_radius(pitch,n2); // r3 = pitch_radius(pitch,n3); // r4 = pitch_radius(pitch,n4); // r5 = pitch_radius(pitch,n5); // a1 = $t * 360 / n1; // a2 = -$t * 360 / n2 + 180/n2; // a3 = -$t * 360 / n3; // a4 = -$t * 360 / n4 - 7.5*180/n4; // color("#f77") zrot(a1) spur_gear(pitch,n1,thickness,hole); // color("#7f7") back(r1+r2) zrot(a2) spur_gear(pitch,n2,thickness,hole); // color("#77f") right(r1+r3) zrot(a3) spur_gear(pitch,n3,thickness,hole); // color("#fc7") left(r1+r4) zrot(a4) spur_gear(pitch,n4,thickness,hole,hide=n4-3); // color("#ccc") fwd(r1) right(pitch*$t) // rack(pitch=pitch,teeth=n5,thickness=thickness,height=rack_base,anchor=CENTER,orient=BACK); function spur_gear( pitch = 3, teeth = 11, thickness = 6, shaft_diam = 0, hide = 0, pressure_angle = 28, clearance = undef, backlash = 0.0, helical = 0, slices = 2, interior = false, mod, anchor = CENTER, spin = 0, orient = UP ) = let( pitch = is_undef(mod) ? pitch : pitch_value(mod), p = pitch_radius(pitch, teeth), c = outer_radius(pitch, teeth, clearance, interior), r = _root_radius(pitch, teeth, clearance, interior), twist = atan2(thickness*tan(helical),p), rgn = [ spur_gear2d( pitch = pitch, teeth = teeth, pressure_angle = pressure_angle, hide = hide, clearance = clearance, backlash = backlash, interior = interior ), if (shaft_diam > 0) circle(d=shaft_diam, $fn=max(12,segs(shaft_diam/2))) ], vnf = linear_sweep(rgn, height=thickness, center=true) ) reorient(anchor,spin,orient, h=thickness, r=p, p=vnf); module spur_gear( pitch = 3, teeth = 11, thickness = 6, shaft_diam = 0, hide = 0, pressure_angle = 28, clearance = undef, backlash = 0.0, helical = 0, slices = 2, interior = false, mod, anchor = CENTER, spin = 0, orient = UP ) { pitch = is_undef(mod) ? pitch : pitch_value(mod); p = pitch_radius(pitch, teeth); c = outer_radius(pitch, teeth, clearance, interior); r = _root_radius(pitch, teeth, clearance, interior); twist = atan2(thickness*tan(helical),p); attachable(anchor,spin,orient, r=p, l=thickness) { difference() { linear_extrude(height=thickness, center=true, convexity=teeth/2, twist=twist) { spur_gear2d( pitch = pitch, teeth = teeth, pressure_angle = pressure_angle, hide = hide, clearance = clearance, backlash = backlash, interior = interior ); } 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: spur_gear2d() // Usage: As Module // spur_gear2d(pitch, teeth, [hide=], [pressure_angle=], [clearance=], [backlash=], [interior=]) [ATTACHMENTS]; // spur_gear2d(mod=, teeth=, [hide=], [pressure_angle=], [clearance=], [backlash=], [interior=]) [ATTACHMENTS]; // Usage: As Function // poly = spur_gear2d(pitch, teeth, [hide=], [pressure_angle=], [clearance=], [backlash=], [interior=]); // poly = spur_gear2d(mod=, teeth=, [hide=], [pressure_angle=], [clearance=], [backlash=], [interior=]); // Topics: Gears // See Also: spur_gear() // Description: // When called as a module, creates a 2D involute spur gear. When called as a function, returns a // 2D path for the perimeter of a 2D involute spur gear. Normally, you should just specify the // first 2 parameters `pitch` and `teeth`, and let the rest be default values. // Meshing gears must match in `pitch`, `pressure_angle`, and `helical`, and be separated by // the sum of their pitch radii, which can be found with `pitch_radius()`. // Arguments: // 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. // 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 // interior = If true, create a mask for difference()ing from something else. // mod = The metric module/modulus of the 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` // Example(2D): Typical Gear Shape // spur_gear2d(pitch=5, teeth=20); // Example(2D): Metric Gear // spur_gear2d(mod=2, teeth=20); // Example(2D): Lower Pressure Angle // spur_gear2d(pitch=5, teeth=20, pressure_angle=20); // Example(2D): Partial Gear // spur_gear2d(pitch=5, teeth=20, hide=15, pressure_angle=20); // Example(2D): Called as a Function // path = spur_gear2d(pitch=8, teeth=16); // polygon(path); function spur_gear2d( pitch = 3, teeth = 11, hide = 0, pressure_angle = 28, clearance = undef, backlash = 0.0, interior = false, mod, anchor = CENTER, spin = 0 ) = let( pitch = is_undef(mod) ? pitch : pitch_value(mod), pr = pitch_radius(pitch=pitch, teeth=teeth), tooth_profile = _gear_tooth_profile( pitch = pitch, teeth = teeth, pressure_angle = pressure_angle, clearance = clearance, backlash = backlash, interior = interior, valleys = false ), pts = concat( [for (tooth = [0:1:teeth-hide-1]) each rot(tooth*360/teeth, p=tooth_profile) ], hide>0? [[0,0]] : [] ) ) reorient(anchor,spin, two_d=true, r=pr, p=pts); module spur_gear2d( pitch = 3, teeth = 11, hide = 0, pressure_angle = 28, clearance = undef, backlash = 0.0, interior = false, mod, anchor = CENTER, spin = 0 ) { pitch = is_undef(mod) ? pitch : pitch_value(mod); path = spur_gear2d( pitch = pitch, teeth = teeth, hide = hide, pressure_angle = pressure_angle, clearance = clearance, backlash = backlash, interior = interior ); pr = pitch_radius(pitch=pitch, teeth=teeth); attachable(anchor,spin, two_d=true, r=pr) { polygon(path); children(); } } // Function&Module: rack() // Usage: As a Module // rack(pitch, teeth, thickness, height, [pressure_angle=], [backlash=]) [ATTACHMENTS]; // rack(mod=, teeth=, thickness=, height=, [pressure_angle=], [backlash]=) [ATTACHMENTS]; // Usage: As a Function // vnf = rack(pitch, teeth, thickness, height, [pressure_angle=], [backlash=]); // vnf = rack(mod=, teeth=, thickness=, height=, [pressure_angle=], [backlash=]); // Topics: Gears // See Also: spur_gear() // 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 circular pitch, or distance between teeth around the pitch circle, in mm. 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: 28 // 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 // mod = The metric module/modulus of the 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` // 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=pitch, teeth=teeth2); // right(pr*2*PI/teeth2*$t) rack(pitch=pitch, teeth=teeth1, thickness=thick, height=5, helical=helical); // up(pr) yrot(186.5-$t*360/teeth2) // spur_gear(pitch=pitch, teeth=teeth2, thickness=thick, helical=helical, shaft_diam=5, orient=BACK); module rack( pitch = 5, teeth = 20, thickness = 5, height = 10, pressure_angle = 28, backlash = 0.0, clearance, helical=0, mod, anchor = CENTER, spin = 0, orient = UP ) { pitch = is_undef(mod) ? pitch : pitch_value(mod); a = _adendum(pitch); d = _dedendum(pitch, clearance); l = teeth * 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), ]; attachable(anchor,spin,orient, size=[l, thickness, 2*abs(a-height)], anchors=anchors) { skew(sxy=tan(helical)) xrot(90) { linear_extrude(height=thickness, center=true, convexity=teeth*2) { rack2d( pitch = pitch, teeth = teeth, height = height, pressure_angle = pressure_angle, backlash = backlash, clearance = clearance ); } } children(); } } function rack( pitch = 5, teeth = 20, thickness = 5, height = 10, pressure_angle = 28, backlash = 0.0, clearance, helical=0, mod, anchor = CENTER, spin = 0, orient = UP ) = let( pitch = is_undef(mod) ? pitch : pitch_value(mod), a = _adendum(pitch), d = _dedendum(pitch, clearance), l = teeth * 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), ], path = rack2d( pitch = pitch, teeth = teeth, height = height, pressure_angle = pressure_angle, backlash = backlash, clearance = clearance ), vnf = linear_sweep(path, height=thickness, anchor="origin", orient=FWD), out = helical==0? vnf : skew(sxy=tan(helical), p=vnf) ) reorient(anchor,spin,orient, size=[l, thickness, 2*abs(a-height)], anchors=anchors, p=out); // Function&Module: rack2d() // Usage: As a Module // path = rack2d(pitch, teeth, height, [pressure_angle=], [backlash=]) [ATTACHMENTS]; // path = rack2d(mod=, teeth=, height=, [pressure_angle=], [backlash=]) [ATTACHMENTS]; // Usage: As a Function // path = rack2d(pitch, teeth, height, [pressure_angle=], [backlash=]); // path = rack2d(mod=, teeth=, height=, [pressure_angle=], [backlash=]); // Topics: Gears // See Also: spur_gear2d() // 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 circular pitch, or distance between teeth around the pitch circle, in mm. // teeth = Total number of teeth along the rack // height = Height of rack in mm, from tooth top 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 // mod = The metric module/modulus of the 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` // 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=28); // polygon(path); function rack2d( pitch = 5, teeth = 20, height = 10, pressure_angle = 28, backlash = 0.0, clearance = undef, mod, anchor = CENTER, spin = 0 ) = let( pitch = is_undef(mod) ? pitch : pitch_value(mod), a = _adendum(pitch), d = _dedendum(pitch, clearance) ) assert(a+d < height) let( xa = a * sin(pressure_angle), xd = d * sin(pressure_angle), l = teeth * pitch, 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), ], path = [ [-(teeth-1)/2 * pitch + -1/2 * pitch, a-height], [-(teeth-1)/2 * pitch + -1/2 * pitch, -d], for (i = [0:1:teeth-1]) let( off = (i-(teeth-1)/2) * pitch ) each [ [off + -1/4 * pitch + backlash - xd, -d], [off + -1/4 * pitch + backlash + xa, a], [off + 1/4 * pitch - backlash - xa, a], [off + 1/4 * pitch - backlash + xd, -d], ], [ (teeth-1)/2 * pitch + 1/2 * pitch, -d], [ (teeth-1)/2 * pitch + 1/2 * pitch, a-height], ] ) reorient(anchor,spin, two_d=true, size=[l,2*abs(a-height)], anchors=anchors, p=path); module rack2d( pitch = 5, teeth = 20, height = 10, pressure_angle = 28, backlash = 0.0, clearance = undef, mod, anchor = CENTER, spin = 0 ) { pitch = is_undef(mod) ? pitch : pitch_value(mod); a = _adendum(pitch); d = _dedendum(pitch, clearance); l = teeth * pitch; 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), ]; path = rack2d( pitch = pitch, teeth = teeth, height = height, pressure_angle = pressure_angle, backlash = backlash, clearance = clearance ); attachable(anchor,spin, two_d=true, size=[l, 2*abs(a-height)], anchors=anchors) { polygon(path); children(); } } // Function&Module: bevel_gear() // Usage: As a Module // bevel_gear(pitch|mod, teeth, face_width, pitch_angle, [shaft_diam], [hide], [pressure_angle], [clearance], [backlash], [cutter_radius], [spiral_angle], [slices], [interior]); // Usage: As a Function // vnf = bevel_gear(pitch|mod, teeth, face_width, pitch_angle, [hide], [pressure_angle], [clearance], [backlash], [cutter_radius], [spiral_angle], [slices], [interior]); // Topics: Gears // See Also: bevel_pitch_angle() // 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. 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 is `pitch_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 `pitch_radius()` for one, plus `pitch_radius()` for the // other, which gives the radii of their pitch circles. 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. Though I've seen 28 recommended for plastic gears. Larger numbers bulge out // more, giving stronger teeth, so 28 degrees is the default here. 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: // 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: 28 // 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 // interior = If true, create a mask for difference()ing from something else. // mod = The metric module/modulus of the 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` // 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. // Example: Beveled Gear // bevel_gear( // 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( // pitch=5, teeth=t1, mate_teeth=t2, // slices=12, anchor="apex", orient=FWD // ); // bevel_gear( // 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; pitch=5; // back(pitch_radius(pitch=pitch, teeth=t2)) { // yrot($t*360/t1) // bevel_gear( // pitch=pitch, teeth=t1, mate_teeth=t2, shaft_diam=5, // slices=12, orient=FWD // ); // } // down(pitch_radius(pitch=pitch, teeth=t1)) { // zrot($t*360/t2) // bevel_gear( // pitch=pitch, teeth=t2, mate_teeth=t1, left_handed=true, // shaft_diam=5, slices=12, spin=180/t2 // ); // } function bevel_gear( pitch = 5, teeth = 20, face_width = 10, pitch_angle = 45, mate_teeth, hide = 0, pressure_angle = 20, clearance = undef, backlash = 0.0, cutter_radius = 30, spiral_angle = 35, left_handed = false, slices = 5, interior = false, mod, anchor = "pitchbase", spin = 0, orient = UP ) = let( pitch = is_undef(mod) ? pitch : pitch_value(mod), slices = cutter_radius==0? 1 : slices, pitch_angle = is_undef(mate_teeth)? pitch_angle : atan(teeth/mate_teeth), pr = pitch_radius(pitch, teeth), rr = _root_radius(pitch, teeth, clearance, interior), 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 = _gear_tooth_profile( pitch = pitch, teeth = teeth, pressure_angle = pressure_angle, clearance = clearance, backlash = backlash, interior = interior, valleys = false, 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( pitch = 5, teeth = 20, face_width = 10, pitch_angle = 45, mate_teeth, shaft_diam = 0, hide = 0, pressure_angle = 20, clearance = undef, backlash = 0.0, cutter_radius = 30, spiral_angle = 35, left_handed = false, slices = 5, interior = false, mod, anchor = "pitchbase", spin = 0, orient = UP ) { pitch = is_undef(mod) ? pitch : pitch_value(mod); slices = cutter_radius==0? 1 : slices; pitch_angle = is_undef(mate_teeth)? pitch_angle : atan(teeth/mate_teeth); pr = pitch_radius(pitch, teeth); ipr = pr - face_width*sin(pitch_angle); rr = _root_radius(pitch, teeth, clearance, interior); pitchoff = (pr-rr) * sin(pitch_angle); vnf = bevel_gear( pitch = pitch, teeth = teeth, face_width = face_width, pitch_angle = pitch_angle, hide = hide, pressure_angle = pressure_angle, clearance = clearance, backlash = backlash, cutter_radius = cutter_radius, spiral_angle = spiral_angle, left_handed = left_handed, slices = slices, interior = interior, 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]) ]; 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() // Usage: As a Module // worm(pitch|mod, d, l, [starts], [left_handed], [pressure_angle], [backlash], [clearance]); // Usage: As a Function // vnf = worm(pitch|mod, d, l, [starts], [left_handed], [pressure_angle], [backlash], [clearance]); // Topics: Gears // See Also: worm_gear() // Description: // Creates a worm shape that can be matched to a worm gear. // Arguments: // 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. // mod = The metric module/modulus of the 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` // Example: // worm(pitch=8, d=30, l=50, $fn=72); // Example: Multiple Starts. // worm(pitch=8, d=30, l=50, starts=3, $fn=72); // Example: Left Handed // worm(pitch=8, d=30, l=50, starts=3, left_handed=true, $fn=72); // Example: Called as Function // vnf = worm(pitch=8, d=35, l=50, starts=2, left_handed=true, pressure_angle=20, $fn=72); // vnf_polyhedron(vnf); function worm( pitch=5, d=30, l=100, starts=1, left_handed=false, pressure_angle=20, backlash=0, clearance, mod, anchor=CENTER, spin=0, orient=UP ) = let( pitch = is_undef(mod) ? pitch : pitch_value(mod), rack_profile = select(rack2d( pitch = pitch, teeth = starts, height = d, pressure_angle = pressure_angle, backlash = backlash, clearance = clearance ), 1, -2), polars = [ for (i=idx(rack_profile)) let( p = rack_profile[i], a = 360 * p.x / pitch / starts ) [a, p.y + d/2] ], maxang = 360 / segs(d/2), refined_polars = [ for (i=idx(polars,e=-2)) let( delta = polars[i+1].x - polars[i].x, steps = ceil(delta/maxang), step = delta/steps ) for (j = [0:1:steps-1]) [polars[i].x + j*step, lerp(polars[i].y,polars[i+1].y, j/steps)] ], cross_sect = [ for (p = refined_polars) polar_to_xy(p.y, p.x) ], revs = l/pitch/starts, zsteps = ceil(revs*360/maxang), zstep = l/zsteps, astep = revs*360/zsteps, profiles = [ for (i=[0:1:zsteps]) let( z = i*zstep - l/2, a = i*astep - 360*revs/2 ) apply(zrot(a)*up(z), path3d(cross_sect)) ], rprofiles = [ for (prof=profiles) reverse(prof) ], vnf1 = vnf_vertex_array(rprofiles, caps=true, col_wrap=true, style="min_edge"), vnf = left_handed? xflip(p=vnf1) : vnf1 ) reorient(anchor,spin,orient, d=d, l=l, p=vnf); module worm( pitch=5, d=15, l=100, starts=1, left_handed=false, pressure_angle=20, backlash=0, clearance, mod, anchor=CENTER, spin=0, orient=UP ) { vnf = worm( pitch=pitch, starts=starts, d=d, l=l, left_handed=left_handed, pressure_angle=pressure_angle, backlash=backlash, clearance=clearance, mod=mod ); attachable(anchor,spin,orient, d=d, l=l) { vnf_polyhedron(vnf, convexity=ceil(l/pitch)*2); children(); } } // Function&Module: worm_gear() // Usage: As a Module // worm_gear(pitch|mod, teeth, worm_diam, [worm_starts], [crowning], [left_handed], [pressure_angle], [backlash], [slices], [clearance], [shaft_diam]); // Usage: As a Function // vnf = worm_gear(pitch|mod, teeth, worm_diam, [worm_starts], [crowning], [left_handed], [pressure_angle], [backlash], [slices], [clearance]); // Topics: Gears // See Also: worm() // Description: // Creates a worm gear to match with a worm. // Arguments: // 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 fir 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. // slices = The number of vertical slices to refine the curve of the worm throat. Default: 10 // mod = The metric module/modulus of the 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` // Example: Right-Handed // worm_gear(pitch=5, teeth=36, worm_diam=30, worm_starts=1); // Example: Left-Handed // worm_gear(pitch=5, teeth=36, worm_diam=30, worm_starts=1, left_handed=true); // Example: Multiple Starts // worm_gear(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; // 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, pitch=pitch, starts=starts, orient=BACK); // left(pitch_radius(pitch=pitch, teeth=gear_teeth)) // zrot(-$t*360/gear_teeth) // worm_gear(pitch=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(pitch=8, teeth=30, worm_diam=30, worm_starts=1); // vnf_polyhedron(vnf); function worm_gear( pitch = 5, teeth = 36, worm_diam = 30, worm_starts = 1, worm_arc = 60, crowning = 1, left_handed = false, pressure_angle = 20, backlash = 0, clearance, mod, slices = 10, anchor = CENTER, spin = 0, orient = UP ) = assert(worm_arc >= 10 && worm_arc <= 60) let( pitch = is_undef(mod) ? pitch : pitch_value(mod), p = pitch_radius(pitch, teeth), circ = 2 * PI * p, r1 = p + worm_diam/2 + crowning, r2 = worm_diam/2 + crowning, thickness = worm_gear_thickness(pitch=pitch, teeth=teeth, worm_diam=worm_diam, worm_arc=worm_arc, crowning=crowning, clearance=clearance), helical = pitch * worm_starts * worm_arc / 360 * 360 / circ, tooth_profile = reverse(_gear_tooth_profile( pitch = pitch, teeth = teeth, pressure_angle = pressure_angle, clearance = clearance, backlash = backlash, valleys = false, center = true )), profiles = [ for (slice = [0:1:slices]) let( u = slice/slices - 0.5, zang = u * worm_arc, tp = [0,r1,0] - spherical_to_xyz(r2, 90, 90+zang), zang2 = u * helical ) [ for (i = [0:1:teeth-1]) each apply( zrot(-i*360/teeth+zang2) * move(tp) * xrot(-zang) * scale(cos(zang)), 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 ]), vnf = left_handed? xflip(p=vnf1) : vnf1 ) reorient(anchor,spin,orient, r=p, l=thickness, p=vnf); module worm_gear( pitch = 5, teeth = 36, worm_diam = 30, worm_starts = 1, worm_arc = 60, crowning = 1, left_handed = false, pressure_angle = 20, backlash = 0, slices = 10, clearance, mod, shaft_diam = 0, anchor = CENTER, spin = 0, orient = UP ) { pitch = is_undef(mod) ? pitch : pitch_value(mod); p = pitch_radius(pitch, teeth); vnf = worm_gear( pitch = pitch, teeth = teeth, worm_diam = worm_diam, worm_starts = worm_starts, worm_arc = worm_arc, crowning = crowning, left_handed = left_handed, pressure_angle = pressure_angle, backlash = backlash, slices = slices, clearance = clearance ); thickness = pointlist_bounds(vnf[0])[1].z; attachable(anchor,spin,orient, r=p, l=thickness) { difference() { vnf_polyhedron(vnf, convexity=teeth/2); if (shaft_diam > 0) { cylinder(d=shaft_diam, l=worm_diam, center=true); } } children(); } } /// Function&Module: _gear_tooth_profile() /// Usage: As Module /// _gear_tooth_profile(pitch|mod, teeth, [pressure_angle], [clearance], [backlash], [interior], [valleys]); /// Usage: As Function /// path = _gear_tooth_profile(pitch|mod, teeth, [pressure_angle], [clearance], [backlash], [interior], [valleys]); /// 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: /// 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 /// interior = If true, create a mask for difference()ing from something else. /// valleys = If true, add the valley bottoms on either side of the tooth. Default: true /// center = If true, centers the pitch circle of the tooth profile at the origin. Default: false. /// mod = The metric module/modulus of the gear. /// Example(2D): /// _gear_tooth_profile(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( /// pitch=5, teeth=20, pressure_angle=20, valleys=false /// ); /// Example(2D): As a function /// path = _gear_tooth_profile( /// pitch=5, teeth=20, pressure_angle=20, valleys=false /// ); /// stroke(path, width=0.1); function _gear_tooth_profile( pitch = 3, teeth = 11, pressure_angle = 28, clearance = undef, backlash = 0.0, interior = false, valleys = true, center = false, mod ) = let( pitch = is_undef(mod) ? pitch : pitch_value(mod), p = pitch_radius(pitch, teeth), c = outer_radius(pitch, teeth, clearance, interior), r = _root_radius(pitch, teeth, clearance, interior), b = _base_radius(pitch, teeth, pressure_angle), t = pitch/2-backlash/2, //tooth thickness at pitch circle k = -_gear_iang(b, p) - t/2/p/PI*180, //angle to where involute meets base circle on each side of tooth kk = r