grey/BOSL2
1
0
Fork 0
mirror of https://github.com/BelfrySCAD/BOSL2.git synced 2025-01-01 09:49:45 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Added bevel_gear()

Browse source
This commit is contained in:
Revar Desmera 2019-06-11 19:29:39 -07:00
parent 48478434ff
commit f7d650f251
1 changed files with 433 additions and 205 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

638
involute_gears.scad
View file

@ -47,194 +47,255 @@
// Function: circular_pitch()
// Description: Get tooth density expressed as "circular pitch".
// Arguments:
// mm_per_tooth = Distance between teeth around the pitch circle, in mm.
function circular_pitch(mm_per_tooth=5) = mm_per_tooth;
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
function circular_pitch(pitch=5) = pitch;
// Function: diametral_pitch()
// Description: Get tooth density expressed as "diametral pitch".
// Arguments:
// mm_per_tooth = Distance between teeth around the pitch circle, in mm.
function diametral_pitch(mm_per_tooth=5) = PI / mm_per_tooth;
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
function diametral_pitch(pitch=5) = PI / pitch;
// Function: module_value()
// Description: Get tooth density expressed as "module" or "modulus" in millimeters
// Arguments:
// mm_per_tooth = Distance between teeth around the pitch circle, in mm.
function module_value(mm_per_tooth=5) = mm_per_tooth / PI;
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
function module_value(pitch=5) = pitch / PI;
// Function: adendum()
// Description: The height of the gear tooth above the pitch radius.
// Arguments:
// mm_per_tooth = Distance between teeth around the pitch circle, in mm.
function adendum(mm_per_tooth=5) = module_value(mm_per_tooth);
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
function adendum(pitch=5) = module_value(pitch);
// Function: dedendum()
// Description: The depth of the gear tooth valley, below the pitch radius.
// Arguments:
// mm_per_tooth = Distance between teeth around the pitch circle, in mm.
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// clearance = If given, sets the clearance between meshing teeth.
function dedendum(mm_per_tooth=5, clearance=undef) =
(clearance==undef)? (1.25 * module_value(mm_per_tooth)) : (module_value(mm_per_tooth) + clearance);
function dedendum(pitch=5, clearance=undef) =
(clearance==undef)? (1.25 * module_value(pitch)) : (module_value(pitch) + clearance);
// Function: pitch_radius()
// Description: Calculates the pitch radius for the gear.
// Arguments:
// mm_per_tooth = Distance between teeth around the pitch circle, in mm.
// number of teeth = The number of teeth on the gear.
function pitch_radius(mm_per_tooth=5, number_of_teeth=11) =
mm_per_tooth * number_of_teeth / PI / 2;
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// teeth = The number of teeth on the gear.
function pitch_radius(pitch=5, teeth=11) =
pitch * teeth / PI / 2;
// Function: outer_radius()
// Description:
// Calculates the outer radius for the gear. The gear fits entirely within a cylinder of this radius.
// Arguments:
// mm_per_tooth = Distance between teeth around the pitch circle, in mm.
// number of teeth = The number of teeth on the gear.
// 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.
// interior = If true, calculate for an interior gear.
function outer_radius(mm_per_tooth=5, number_of_teeth=11, clearance=undef, interior=false) =
pitch_radius(mm_per_tooth, number_of_teeth) +
(interior? dedendum(mm_per_tooth, clearance) : adendum(mm_per_tooth));
function outer_radius(pitch=5, teeth=11, clearance=undef, interior=false) =
pitch_radius(pitch, teeth) +
(interior? dedendum(pitch, clearance) : adendum(pitch));
// Function: root_radius()
// Description:
// Calculates the root radius for the gear, at the base of the dedendum.
// Arguments:
// mm_per_tooth = Distance between teeth around the pitch circle, in mm.
// number of teeth = The number of teeth on the gear.
// 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.
// interior = If true, calculate for an interior gear.
function root_radius(mm_per_tooth=5, number_of_teeth=11, clearance=undef, interior=false)
= pitch_radius(mm_per_tooth, number_of_teeth) -
(interior? adendum(mm_per_tooth) : dedendum(mm_per_tooth, clearance));
function root_radius(pitch=5, teeth=11, clearance=undef, interior=false) =
pitch_radius(pitch, teeth) -
(interior? adendum(pitch) : dedendum(pitch, clearance));
// Function: base_radius()
// Description: Get the base circle for involute teeth.
// Arguments:
// mm_per_tooth = Distance between teeth around the pitch circle, in mm.
// number_of_teeth = The number of teeth on the gear.
// pressure_angle = Pressure angle in degrees. Controls how straight or bulged the tooth sides are.
function base_radius(mm_per_tooth=5, number_of_teeth=11, pressure_angle=28)
= pitch_radius(mm_per_tooth, number_of_teeth) * cos(pressure_angle);
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// teeth = The number of teeth on the gear.
// PA = Pressure angle in degrees. Controls how straight or bulged the tooth sides are.
function base_radius(pitch=5, teeth=11, PA=28) =
pitch_radius(pitch, teeth) * cos(PA);
// Function bevel_pitch_angle()
// Usage:
// bevel_pitch_angle(teeth, mate_teeth, [drive_angle]);
// Description:
// Returns the correct pitch angle (bevelang) for a bevel gear with a given number of tooth, 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. Usually 90º.
function bevel_pitch_angle(teeth, mate_teeth, drive_angle=90) =
atan(sin(drive_angle)/((mate_teeth/teeth)+cos(drive_angle)));
function _gear_polar(r,t) = r*[sin(t),cos(t)];
function _gear_iang(r1,r2) = sqrt((r2/r1)*(r2/r1) - 1)/PI*180 - acos(r1/r2); //unwind a string this many degrees to go from radius r1 to radius r2
function _gear_q6(b,s,t,d) = _gear_polar(d,s*(_gear_iang(b,d)+t)); //point at radius d on the involute curve
function _gear_q7(f,r,b,r2,t,s) = _gear_q6(b,s,t,(1-f)*max(b,r)+f*r2); //radius a fraction f up the curved side of the tooth
// Section: Modules
// Module: gear_tooth_profile()
// Function&Module: gear_tooth_profile()
// Description:
// Creates the 2D profile for an individual gear tooth.
// 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:
// mm_per_tooth = This is the "circular pitch", the circumference of the pitch circle divided by the number of teeth
// number_of_teeth = Total number of teeth along the rack
// pressure_angle = Controls how straight or bulged the tooth sides are. In degrees.
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// teeth = Total number of teeth along the rack
// PA = 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
// bevelang = Angle of beveled gear face.
// clearance = Gap between top of a tooth on one gear and bottom of valley on a meshing gear (in millimeters)
// 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.
// Example(2D):
// gear_tooth_profile(mm_per_tooth=5, number_of_teeth=20, pressure_angle=20);
module gear_tooth_profile(
mm_per_tooth = 3,
number_of_teeth = 11,
pressure_angle = 28,
backlash = 0.0,
bevelang = 0.0,
clearance = undef,
interior = false
) {
function polar(r,theta) = r*[sin(theta), cos(theta)]; //convert polar to cartesian coordinates
function iang(r1,r2) = sqrt((r2/r1)*(r2/r1) - 1)/PI*180 - acos(r1/r2); //unwind a string this many degrees to go from radius r1 to radius r2
function q7(f,r,b,r2,t,s) = q6(b,s,t,(1-f)*max(b,r)+f*r2); //radius a fraction f up the curved side of the tooth
function q6(b,s,t,d) = polar(d,s*(iang(b,d)+t)); //point at radius d on the involute curve
// gear_tooth_profile(pitch=5, teeth=20, PA=20);
// Example(2D):
// gear_tooth_profile(pitch=5, teeth=20, PA=20, valleys=true);
function gear_tooth_profile(
pitch = 3,
teeth = 11,
PA = 28,
backlash = 0.0,
clearance = undef,
interior = false,
valleys = true
) = let(
p = pitch_radius(pitch, teeth),
c = outer_radius(pitch, teeth, clearance, interior),
r = root_radius(pitch, teeth, clearance, interior),
b = base_radius(pitch, teeth, PA),
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<b? k : -180/teeth,
isteps = 5,
pts = concat(
valleys? [
_gear_polar(r-1, -180.1/teeth),
_gear_polar(r, -180.1/teeth),
] : [
],
[_gear_polar(r, kk)],
[for (i=[0: 1:isteps]) _gear_q7(i/isteps,r,b,c,k, 1)],
[for (i=[isteps:-1:0]) _gear_q7(i/isteps,r,b,c,k,-1)],
[_gear_polar(r, -kk)],
valleys? [
_gear_polar(r, 180.1/teeth),
_gear_polar(r-1, 180.1/teeth),
] : [
]
)
) reverse(pts);
p = pitch_radius(mm_per_tooth, number_of_teeth);
c = outer_radius(mm_per_tooth, number_of_teeth, clearance, interior);
r = root_radius(mm_per_tooth, number_of_teeth, clearance, interior);
b = base_radius(mm_per_tooth, number_of_teeth, pressure_angle);
t = mm_per_tooth/2-backlash/2; //tooth thickness at pitch circle
k = -iang(b, p) - t/2/p/PI*180; //angle to where involute meets base circle on each side of tooth
scale([1, 1/cos(bevelang), 1])
module gear_tooth_profile(
pitch = 3,
teeth = 11,
PA = 28,
backlash = 0.0,
clearance = undef,
interior = false,
valleys = true
) {
r = root_radius(pitch, teeth, clearance, interior);
translate([0,-r,0])
polygon(
points=[
polar(r-1, -181/number_of_teeth),
polar(r, -181/number_of_teeth),
polar(r, r<b ? k : -180/number_of_teeth),
q7(0/5,r,b,c,k, 1),q7(1/5,r,b,c,k, 1),q7(2/5,r,b,c,k, 1),q7(3/5,r,b,c,k, 1),q7(4/5,r,b,c,k, 1),q7(5/5,r,b,c,k, 1),
q7(5/5,r,b,c,k,-1),q7(4/5,r,b,c,k,-1),q7(3/5,r,b,c,k,-1),q7(2/5,r,b,c,k,-1),q7(1/5,r,b,c,k,-1),q7(0/5,r,b,c,k,-1),
polar(r, r<b ? -k : 180/number_of_teeth),
polar(r, 181/number_of_teeth),
polar(r-1, 181/number_of_teeth),
]
points=gear_tooth_profile(
pitch = pitch,
teeth = teeth,
PA = PA,
backlash = backlash,
clearance = clearance,
interior = interior,
valleys = valleys
)
);
}
// Module: gear2d()
// Function&Module: gear2d()
// Description:
// Creates a 2D involute spur gear, with reasonable defaults for all the parameters.
// Normally, you should just specify the first 2 parameters, and let the rest be default values.
// Meshing gears must match in mm_per_tooth, pressure_angle, and twist,
// and be separated by the sum of their pitch radii, which can be found with pitch_radius().
// 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`, `PA`, and `helical`, and be separated by
// the sum of their pitch radii, which can be found with `pitch_radius()`.
// Arguments:
// mm_per_tooth = This is the "circular pitch", the circumference of the pitch circle divided by the number of teeth
// number_of_teeth = Total number of teeth along the rack
// teeth_to_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.
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// teeth = Total number of teeth along the rack
// hide = Number of teeth to delete to make this only a fraction of a circle
// PA = 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
// bevelang = Angle of beveled gear face.
// interior = If true, create a mask for difference()ing from something else.
// Example(2D): Typical Gear Shape
// gear2d(mm_per_tooth=5, number_of_teeth=20);
// gear2d(pitch=5, teeth=20);
// Example(2D): Lower Pressure Angle
// gear2d(mm_per_tooth=5, number_of_teeth=20, pressure_angle=20);
// gear2d(pitch=5, teeth=20, PA=20);
// Example(2D): Partial Gear
// gear2d(mm_per_tooth=5, number_of_teeth=20, teeth_to_hide=15, pressure_angle=20);
// gear2d(pitch=5, teeth=20, hide=15, PA=20);
function gear2d(
pitch = 3,
teeth = 11,
hide = 0,
PA = 28,
clearance = undef,
backlash = 0.0,
interior = false
) = let(
pts = concat(
[for (tooth = [0:1:teeth-hide-1])
each rot(tooth*360/teeth,
planar=true,
p=gear_tooth_profile(
pitch = pitch,
teeth = teeth,
PA = PA,
clearance = clearance,
backlash = backlash,
interior = interior,
valleys = false
)
)
],
hide>0? [[0,0]] : []
)
) pts;
module gear2d(
mm_per_tooth = 3,
number_of_teeth = 11,
teeth_to_hide = 0,
pressure_angle = 28,
clearance = undef,
backlash = 0.0,
bevelang = 0.0,
interior = false
pitch = 3,
teeth = 11,
hide = 0,
PA = 28,
clearance = undef,
backlash = 0.0,
interior = false
) {
r = root_radius(mm_per_tooth, number_of_teeth, clearance, interior);
ang = 360/number_of_teeth/2;
union() {
for (i = [0:1:number_of_teeth-teeth_to_hide-1] ) {
rotate(i*360/number_of_teeth) {
translate([0,r,0]) {
gear_tooth_profile(
mm_per_tooth = mm_per_tooth,
number_of_teeth = number_of_teeth,
pressure_angle = pressure_angle,
clearance = clearance,
backlash = backlash,
bevelang = bevelang,
interior = interior
);
}
polygon([
[-r*sin(ang), r*cos(ang)],
[0,0],
[r*sin(ang), r*cos(ang)]
]);
}
}
}
polygon(
gear2d(
pitch = pitch,
teeth = teeth,
hide = hide,
PA = PA,
clearance = clearance,
backlash = backlash,
interior = interior
)
);
}
@ -256,85 +317,252 @@ module gear2d(
// 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 `mm_per_tooth`
// and `pressure_angle` parameters. `mm_per_tooth` gives the number
// In order for two gears to mesh, they must have the same `pitch`
// and `PA` 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
// and one space between teeth. The `PA` 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 `number_of_teeth` for two meshing gears gives how many
// 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:
// mm_per_tooth = This is the "circular pitch", the circumference of the pitch circle divided by the number of teeth
// number_of_teeth = Total number of teeth around the entire perimeter
// 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
// hole_diameter = Diameter of the hole in the center, in mm
// teeth_to_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.
// shaft_diam = Diameter of the hole in the center, in mm
// hide = Number of teeth to delete to make this only a fraction of a circle
// PA = 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
// bevelang = Angle of beveled gear face.
// twist = Teeth rotate this many degrees from bottom of gear to top. 360 makes the gear a screw with each thread going around once.
// slices = Number of vertical layers to divide gear into. Useful for refining gears with `twist`.
// helical = Teeth rotate this many degrees from bottom of gear to top. 360 makes the gear a screw with each thread going around once.
// 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.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0`
// orient = Vector to rotate top towards, after spin. See [orient](attachments.scad#orient). Default: `UP`
// Example: Spur Gear
// gear(mm_per_tooth=5, number_of_teeth=20, thickness=8, hole_diameter=5);
// gear(pitch=5, teeth=20, thickness=8, shaft_diam=5);
// Example: Beveled Gear
// gear(mm_per_tooth=5, number_of_teeth=20, thickness=10*cos(45), hole_diameter=5, twist=-30, bevelang=45, slices=12, $fa=1, $fs=1);
// gear(pitch=5, teeth=20, thickness=10*cos(45), shaft_diam=5, helical=-30, slices=12, $fa=1, $fs=1);
module gear(
mm_per_tooth = 3,
number_of_teeth = 11,
thickness = 6,
hole_diameter = 3,
teeth_to_hide = 0,
pressure_angle = 28,
clearance = undef,
backlash = 0.0,
bevelang = 0.0,
twist = undef,
slices = undef,
interior = false,
anchor = CENTER,
spin = 0,
orient = UP
pitch = 3,
teeth = 11,
PA = 28,
thickness = 6,
hide = 0,
shaft_diam = 3,
clearance = undef,
backlash = 0.0,
helical = 0,
slices = 2,
interior = false,
anchor = CENTER,
spin = 0,
orient = UP
) {
p = pitch_radius(mm_per_tooth, number_of_teeth);
c = outer_radius(mm_per_tooth, number_of_teeth, clearance, interior);
r = root_radius(mm_per_tooth, number_of_teeth, clearance, interior);
p2 = p - (thickness*tan(bevelang));
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);
orient_and_anchor([p, p, thickness], orient, anchor, spin=spin, geometry="cylinder", chain=true) {
difference() {
linear_extrude(height=thickness, center=true, convexity=10, twist=twist, scale=p2/p, slices=slices) {
linear_extrude(height=thickness, center=true, convexity=10, twist=twist) {
gear2d(
mm_per_tooth = mm_per_tooth,
number_of_teeth = number_of_teeth,
teeth_to_hide = teeth_to_hide,
pressure_angle = pressure_angle,
clearance = clearance,
backlash = backlash,
bevelang = bevelang,
interior = interior
pitch = pitch,
teeth = teeth,
PA = PA,
hide = hide,
clearance = clearance,
backlash = backlash,
interior = interior
);
}
if (hole_diameter > 0) {
cylinder(h=2*thickness+1, r=hole_diameter/2, center=true);
if (shaft_diam > 0) {
cylinder(h=2*thickness+1, r=shaft_diam/2, center=true);
}
if (bevelang != 0) {
h = (c-r)*sin(bevelang);
translate([0,0,-thickness/2]) {
difference() {
cube([2*c/cos(bevelang),2*c/cos(bevelang),2*h], center=true);
cylinder(h=h, r1=r, r2=c, center=false);
}
children();
}
}
// Module: bevel_gear()
// Description:
// Creates a (potentially spiral) bevel gear.
// The module `bevel_gear()` gives an 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 `PA` parameters. `pitch` gives the number
// of millimeters of arc around the pitch circle covered by one tooth
// and one space between teeth. The `PA` 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
// face_width = Width of the toothed surface in mm, from inside to outside.
// shaft_diam = Diameter of the hole in the center, in mm
// hide = Number of teeth to delete to make this only a fraction of a circle
// PA = 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
// bevelang = Angle of beveled gear face.
// spiral = Radius of spiral arc for teeth, if given. If 0, then gear will not be spiral.
// slices = Number of vertical layers to divide gear into. Useful for refining gears with `spiral`.
// 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.
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0`
// orient = Vector to rotate top towards, after spin. See [orient](attachments.scad#orient). Default: `UP`
// Example: Beveled Gear
// bevel_gear(pitch=5, teeth=20, face_width=10, shaft_diam=5, spiral=-30, bevelang=45, slices=12, $fa=1, $fs=1);
module bevel_gear(
pitch = 3,
teeth = 11,
PA = 20,
face_width = 6,
bevelang = 45,
hide = 0,
shaft_diam = 3,
clearance = undef,
backlash = 0.0,
spiral_rad = 0,
spiral_ang = 0,
slices = 2,
interior = false,
anchor = CENTER,
spin = 0,
orient = UP
) {
thickness = face_width * cos(bevelang);
slices = spiral_rad==0? 1 : slices;
spiral_rad = spiral_rad==0? 10000 : spiral_rad;
p1 = pitch_radius(pitch, teeth);
r1 = root_radius(pitch, teeth, clearance, interior);
c1 = outer_radius(pitch, teeth, clearance, interior);
dx = thickness * tan(bevelang);
dy = (p1-r1) * sin(bevelang);
scl = (p1-dx)/p1;
p2 = pitch_radius(pitch*scl, teeth);
r2 = root_radius(pitch*scl, teeth, clearance, interior);
c2 = outer_radius(pitch*scl, teeth, clearance, interior);
slice_u = 1/slices;
Rm = (p1+p2)/2;
H = spiral_rad * cos(spiral_ang);
V = Rm - abs(spiral_rad) * sin(spiral_ang);
spiral_cp = [H,V,0];
S = norm(spiral_cp);
theta_r = acos((S*S+spiral_rad*spiral_rad-p1*p1)/(2*S*spiral_rad)) - acos((S*S+spiral_rad*spiral_rad-p2*p2)/(2*S*spiral_rad));
theta_ro = acos((S*S+spiral_rad*spiral_rad-p1*p1)/(2*S*spiral_rad)) - acos((S*S+spiral_rad*spiral_rad-Rm*Rm)/(2*S*spiral_rad));
theta_ri = theta_r - theta_ro;
extent_u = 2*(p2-r2)*tan(bevelang) / thickness;
slice_us = concat(
[for (u = [0:slice_u:1+extent_u]) u]
);
lsus = len(slice_us);
vertices = concat(
[
for (u=slice_us, tooth=[0:1:teeth-1]) let(
p = lerp(p1,p2,u),
r = lerp(r1,r2,u),
theta = lerp(-theta_ro, theta_ri, u),
profile = gear_tooth_profile(
pitch = pitch*(p/p1),
teeth = teeth,
PA = PA,
clearance = clearance,
backlash = backlash,
interior = interior,
valleys = false
),
pp = rot(theta, cp=spiral_cp, p=[0,Rm,0]),
ang = atan2(pp.y,pp.x)-90,
pts = affine3d_apply(pts=profile, affines=[
move([0,-p,0]),
rot([0,ang,0]),
rot([bevelang,0,0]),
move(pp),
rot(tooth*360/teeth),
move([0,0,thickness*u])
])
) each pts
], [
[0,0,-dy], [0,0,thickness]
]
);
lcnt = (len(vertices)-2)/lsus/teeth;
function _gv(layer,tooth,i) = ((layer*teeth)+(tooth%teeth))*lcnt+(i%lcnt);
function _lv(layer,i) = layer*teeth*lcnt+(i%(teeth*lcnt));
faces = concat(
[
for (sl=[0:1:lsus-2], i=[0:1:lcnt*teeth-1]) each [
[_lv(sl,i), _lv(sl+1,i), _lv(sl,i+1)],
[_lv(sl+1,i), _lv(sl+1,i+1), _lv(sl,i+1)]
]
], [
for (tooth=[0:1:teeth-1], i=[0:1:lcnt/2-1]) each [
[_gv(0,tooth,i), _gv(0,tooth,i+1), _gv(0,tooth,lcnt-1-(i+1))],
[_gv(0,tooth,i), _gv(0,tooth,lcnt-1-(i+1)), _gv(0,tooth,lcnt-1-i)],
[_gv(lsus-1,tooth,i), _gv(lsus-1,tooth,lcnt-1-(i+1)), _gv(lsus-1,tooth,i+1)],
[_gv(lsus-1,tooth,i), _gv(lsus-1,tooth,lcnt-1-i), _gv(lsus-1,tooth,lcnt-1-(i+1))],
]
], [
for (tooth=[0:1:teeth-1]) each [
[len(vertices)-2, _gv(0,tooth,0), _gv(0,tooth,lcnt-1)],
[len(vertices)-2, _gv(0,tooth,lcnt-1), _gv(0,tooth+1,0)],
[len(vertices)-1, _gv(lsus-1,tooth,lcnt-1), _gv(lsus-1,tooth,0)],
[len(vertices)-1, _gv(lsus-1,tooth+1,0), _gv(lsus-1,tooth,lcnt-1)],
]
]
);
orient_and_anchor([p1, p1, thickness], orient, anchor, spin=spin, size2=[p2,p2], geometry="cylinder", chain=true) {
union() {
difference() {
down(thickness/2) {
polyhedron(points=vertices, faces=faces, convexity=floor(teeth/2));
}
if (shaft_diam > 0) {
cylinder(h=2*thickness+1, r=shaft_diam/2, center=true);
}
if (bevelang != 0) {
h = (c1-r1)/tan(45);
down(thickness/2+dy) {
difference() {
cube([2*c1/cos(45),2*c1/cos(45),2*h], center=true);
cylinder(h=h, r1=r1-0.5, r2=c1-0.5, center=false, $fn=teeth*4);
}
}
up(thickness/2-0.01) {
cylinder(h=(c2-r2)/tan(45)*5, r1=r2-0.5, r2=lerp(r2-0.5,c2-0.5,5), center=false, $fn=teeth*4);
}
}
}
@ -347,14 +575,14 @@ module gear(
// Module: rack()
// Description:
// The module `rack()` gives a rack, which is a bar with teeth. A
// rack can mesh with any gear that has the same `mm_per_tooth` and
// `pressure_angle`.
// rack can mesh with any gear that has the same `pitch` and
// `PA`.
// Arguments:
// mm_per_tooth = This is the "circular pitch", the circumference of the pitch circle divided by the number of teeth
// number_of_teeth = Total number of teeth along the rack
// pitch = The circular pitch, or distance between teeth around the pitch circle, in mm.
// teeth = Total number of teeth along the rack
// thickness = Thickness of rack in mm (affects each tooth)
// 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.
// PA = 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
// anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER`
// spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0`
@ -371,24 +599,24 @@ module gear(
// "dedendum-top" = At the base of the teeth, at the top of the rack.
// "dedendum-bottom" = At the base of the teeth, at the bottom of the rack.
// Example:
// rack(mm_per_tooth=5, number_of_teeth=10, thickness=5, height=5, pressure_angle=20);
// rack(pitch=5, teeth=10, thickness=5, height=5, PA=20);
module rack(
mm_per_tooth = 5,
number_of_teeth = 20,
thickness = 5,
height = 10,
pressure_angle = 28,
backlash = 0.0,
clearance = undef,
anchor = CENTER,
spin = 0,
orient = UP
pitch = 5,
teeth = 20,
thickness = 5,
height = 10,
PA = 28,
backlash = 0.0,
clearance = undef,
anchor = CENTER,
spin = 0,
orient = UP
) {
a = adendum(mm_per_tooth);
d = dedendum(mm_per_tooth, clearance);
xa = a * sin(pressure_angle);
xd = d * sin(pressure_angle);
l = number_of_teeth * mm_per_tooth;
a = adendum(pitch);
d = dedendum(pitch, clearance);
xa = a * sin(PA);
xd = d * sin(PA);
l = teeth * pitch;
anchors = [
anchorpt("adendum", [0,a,0], BACK),
anchorpt("adendum-left", [-l/2,a,0], LEFT),
@ -402,20 +630,20 @@ module rack(
anchorpt("dedendum-bottom", [0,-d,-thickness/2], DOWN),
];
orient_and_anchor([l, 2*abs(a-height), thickness], orient, anchor, spin=spin, anchors=anchors, chain=true) {
left((number_of_teeth-1)*mm_per_tooth/2) {
left((teeth-1)*pitch/2) {
linear_extrude(height = thickness, center = true, convexity = 10) {
for (i = [0:1:number_of_teeth-1] ) {
translate([i*mm_per_tooth,0,0]) {
for (i = [0:1:teeth-1] ) {
translate([i*pitch,0,0]) {
polygon(
points=[
[-1/2 * mm_per_tooth - 0.01, a-height],
[-1/2 * mm_per_tooth, -d],
[-1/4 * mm_per_tooth + backlash - xd, -d],
[-1/4 * mm_per_tooth + backlash + xa, a],
[ 1/4 * mm_per_tooth - backlash - xa, a],
[ 1/4 * mm_per_tooth - backlash + xd, -d],
[ 1/2 * mm_per_tooth, -d],
[ 1/2 * mm_per_tooth + 0.01, a-height],
[-1/2 * pitch - 0.01, a-height],
[-1/2 * pitch, -d],
[-1/4 * pitch + backlash - xd, -d],
[-1/4 * pitch + backlash + xa, a],
[ 1/4 * pitch - backlash - xa, a],
[ 1/4 * pitch - backlash + xd, -d],
[ 1/2 * pitch, -d],
[ 1/2 * pitch + 0.01, a-height],
]
);
}
@ -438,22 +666,22 @@ n2 = 20; //green gear
n3 = 5; //blue gear
n4 = 20; //orange gear
n5 = 8; //gray rack
mm_per_tooth = 9; //all meshing gears need the same mm_per_tooth (and the same pressure_angle)
pitch = 9; //all meshing gears need the same `pitch` (and the same `PA`)
thickness = 6;
hole = 3;
height = 12;
d1 =pitch_radius(mm_per_tooth,n1);
d12=pitch_radius(mm_per_tooth,n1) + pitch_radius(mm_per_tooth,n2);
d13=pitch_radius(mm_per_tooth,n1) + pitch_radius(mm_per_tooth,n3);
d14=pitch_radius(mm_per_tooth,n1) + pitch_radius(mm_per_tooth,n4);
d1 =pitch_radius(pitch,n1);
d12=pitch_radius(pitch,n1) + pitch_radius(pitch,n2);
d13=pitch_radius(pitch,n1) + pitch_radius(pitch,n3);
d14=pitch_radius(pitch,n1) + pitch_radius(pitch,n4);
translate([ 0, 0, 0]) rotate([0,0, $t*360/n1]) color([1.00,0.75,0.75]) gear(mm_per_tooth,n1,thickness,hole);
translate([ 0, d12, 0]) rotate([0,0,-($t+n2/2-0*n1+1/2)*360/n2]) color([0.75,1.00,0.75]) gear(mm_per_tooth,n2,thickness,hole);
translate([ d13, 0, 0]) rotate([0,0,-($t-n3/4+n1/4+1/2)*360/n3]) color([0.75,0.75,1.00]) gear(mm_per_tooth,n3,thickness,hole);
translate([ d13, 0, 0]) rotate([0,0,-($t-n3/4+n1/4+1/2)*360/n3]) color([0.75,0.75,1.00]) gear(mm_per_tooth,n3,thickness,hole);
translate([-d14, 0, 0]) rotate([0,0,-($t-n4/4-n1/4+1/2-floor(n4/4)-3)*360/n4]) color([1.00,0.75,0.50]) gear(mm_per_tooth,n4,thickness,hole,teeth_to_hide=n4-3);
translate([(-floor(n5/2)-floor(n1/2)+$t+n1/2-1/2)*9, -d1+0.0, 0]) rotate([0,0,0]) color([0.75,0.75,0.75]) rack(mm_per_tooth,n5,thickness,height);
translate([ 0, 0, 0]) rotate([0,0, $t*360/n1]) color([1.00,0.75,0.75]) gear(pitch,n1,thickness,hole);
translate([ 0, d12, 0]) rotate([0,0,-($t+n2/2-0*n1+1/2)*360/n2]) color([0.75,1.00,0.75]) gear(pitch,n2,thickness,hole);
translate([ d13, 0, 0]) rotate([0,0,-($t-n3/4+n1/4+1/2)*360/n3]) color([0.75,0.75,1.00]) gear(pitch,n3,thickness,hole);
translate([ d13, 0, 0]) rotate([0,0,-($t-n3/4+n1/4+1/2)*360/n3]) color([0.75,0.75,1.00]) gear(pitch,n3,thickness,hole);
translate([-d14, 0, 0]) rotate([0,0,-($t-n4/4-n1/4+1/2-floor(n4/4)-3)*360/n4]) color([1.00,0.75,0.50]) gear(pitch,n4,thickness,hole,hide=n4-3);
translate([(-floor(n5/2)-floor(n1/2)+$t+n1/2-1/2)*9, -d1+0.0, 0]) rotate([0,0,0]) color([0.75,0.75,0.75]) rack(pitch,n5,thickness,height);
*/