commit a5d640e5b8ca34c901f9c9600aa42aff4946ad2e Author: mattmcw Date: Sun Feb 18 10:09:33 2024 -0500 Initialize project diff --git a/Triangles.scad b/Triangles.scad new file mode 100644 index 0000000..2d027b3 --- /dev/null +++ b/Triangles.scad @@ -0,0 +1,215 @@ +/* +Triangles.scad + Author: Tim Koopman + https://github.com/tkoopman/Delta-Diamond/blob/master/OpenSCAD/Triangles.scad + + angleCA + /|\ + a / H \ c + / | \ + angleAB ------- angleBC + b + +Standard Parameters + center: true/false + If true same as centerXYZ = [true, true, true] + + centerXYZ: Vector of 3 true/false values [CenterX, CenterY, CenterZ] + center must be left undef + + height: The 3D height of the Triangle. Ignored if heights defined + + heights: Vector of 3 height values heights @ [angleAB, angleBC, angleCA] + If CenterZ is true each height will be centered individually, this means + the shape will be different depending on CenterZ. Most times you will want + CenterZ to be true to get the shape most people want. +*/ + +/* +Triangle + a: Length of side a + b: Length of side b + angle: angle at point angleAB +*/ +module Triangle( + a, b, angle, height=1, heights=undef, + center=undef, centerXYZ=[false,false,false]) +{ + // Calculate Heights at each point + heightAB = ((heights==undef) ? height : heights[0])/2; + heightBC = ((heights==undef) ? height : heights[1])/2; + heightCA = ((heights==undef) ? height : heights[2])/2; + centerZ = (center || (center==undef && centerXYZ[2]))?0:max(heightAB,heightBC,heightCA); + + // Calculate Offsets for centering + offsetX = (center || (center==undef && centerXYZ[0]))?((cos(angle)*a)+b)/3:0; + offsetY = (center || (center==undef && centerXYZ[1]))?(sin(angle)*a)/3:0; + + pointAB1 = [-offsetX,-offsetY, centerZ-heightAB]; + pointAB2 = [-offsetX,-offsetY, centerZ+heightAB]; + pointBC1 = [b-offsetX,-offsetY, centerZ-heightBC]; + pointBC2 = [b-offsetX,-offsetY, centerZ+heightBC]; + pointCA1 = [(cos(angle)*a)-offsetX,(sin(angle)*a)-offsetY, centerZ-heightCA]; + pointCA2 = [(cos(angle)*a)-offsetX,(sin(angle)*a)-offsetY, centerZ+heightCA]; + + polyhedron( + points=[ pointAB1, pointBC1, pointCA1, + pointAB2, pointBC2, pointCA2 ], + faces=[ + [0, 1, 2], + [3, 5, 4], + [0, 3, 1], + [1, 3, 4], + [1, 4, 2], + [2, 4, 5], + [2, 5, 0], + [0, 5, 3] ] ); +} + +/* +Isosceles Triangle + Exactly 2 of the following paramaters must be defined. + If all 3 defined H will be ignored. + b: length of side b + angle: angle at points angleAB & angleBC. +*/ +module Isosceles_Triangle( + b, angle, H=undef, height=1, heights=undef, + center=undef, centerXYZ=[true, false, false]) +{ + valid = (angle!=undef)?((angle < 90) && (b!=undef||H!=undef)) : (b!=undef&&H!=undef); + ANGLE = (angle!=undef) ? angle : atan(H / (b/2)); + a = (b==undef)?(H/sin((180-(angle*2))/2)) : + (b / cos(ANGLE))/2; + B = (b==undef)? (cos(angle)*a)*2:b; + if (valid) + { + Triangle(a=a, b=B, angle=ANGLE, height=height, heights=heights, + center=center, centerXYZ=centerXYZ); + } else { + echo("Invalid Isosceles_Triangle. Must specify any 2 of b, angle and H, and if angle used angle must be less than 90"); + } +} + +/* +Right Angled Triangle + Create a Right Angled Triangle where the hypotenuse will be calculated. + + |\ + a| \ + | \ + ---- + b + a: length of side a + b: length of side b +*/ +module Right_Angled_Triangle( + a, b, height=1, heights=undef, + center=undef, centerXYZ=[false, false, false]) +{ + Triangle(a=a, b=b, angle=90, height=height, heights=heights, + center=center, centerXYZ=centerXYZ); +} + +/* +Wedge + Is same as Right Angled Triangle with 2 different heights, and rotated. + Good for creating support structures. +*/ +module Wedge(a, b, w1, w2) +{ + rotate([90,0,0]) + Right_Angled_Triangle(a, b, heights=[w1, w2, w1], centerXYZ=[false, false, true]); +} + +/* +Equilateral Triangle + Create a Equilateral Triangle. + + l: Length of all sides (a, b & c) + H: Triangle size will be based on the this 2D height + When using H, l is ignored. +*/ +module Equilateral_Triangle( + l=10, H=undef, height=1, heights=undef, + center=undef, centerXYZ=[true,false,false]) +{ + L = (H==undef)?l:H/sin(60); + Triangle(a=L,b=L,angle=60,height=height, heights=heights, + center=center, centerXYZ=centerXYZ); +} + +/* +Trapezoid + Create a Basic Trapezoid (Based on Isosceles_Triangle) + + d + /----\ + / | \ + a / H \ c + / | \ + angle ------------ angle + b + + b: Length of side b + angle: Angle at points angleAB & angleBC + H: The 2D height at which the triangle should be cut to create the trapezoid + heights: If vector of size 3 (Standard for triangles) both cd & da will be the same height, if vector have 4 values [ab,bc,cd,da] than each point can have different heights. +*/ +module Trapezoid( + b, angle=60, H, height=1, heights=undef, + center=undef, centerXYZ=[true,false,false]) +{ + validAngle = (angle < 90); + adX = H / tan(angle); + + // Calculate Heights at each point + heightAB = ((heights==undef) ? height : heights[0])/2; + heightBC = ((heights==undef) ? height : heights[1])/2; + heightCD = ((heights==undef) ? height : heights[2])/2; + heightDA = ((heights==undef) ? height : ((len(heights) > 3)?heights[3]:heights[2]))/2; + + // Centers + centerX = (center || (center==undef && centerXYZ[0]))?0:b/2; + centerY = (center || (center==undef && centerXYZ[1]))?0:H/2; + centerZ = (center || (center==undef && centerXYZ[2]))?0:max(heightAB,heightBC,heightCD,heightDA); + + // Points + y = H/2; + bx = b/2; + dx = (b-(adX*2))/2; + + pointAB1 = [centerX-bx, centerY-y, centerZ-heightAB]; + pointAB2 = [centerX-bx, centerY-y, centerZ+heightAB]; + pointBC1 = [centerX+bx, centerY-y, centerZ-heightBC]; + pointBC2 = [centerX+bx, centerY-y, centerZ+heightBC]; + pointCD1 = [centerX+dx, centerY+y, centerZ-heightCD]; + pointCD2 = [centerX+dx, centerY+y, centerZ+heightCD]; + pointDA1 = [centerX-dx, centerY+y, centerZ-heightDA]; + pointDA2 = [centerX-dx, centerY+y, centerZ+heightDA]; + + validH = (adX < b/2); + + if (validAngle && validH) + { + polyhedron( + points=[ pointAB1, pointBC1, pointCD1, pointDA1, + pointAB2, pointBC2, pointCD2, pointDA2 ], + triangles=[ + [0, 1, 2], + [0, 2, 3], + [4, 6, 5], + [4, 7, 6], + [0, 4, 1], + [1, 4, 5], + [1, 5, 2], + [2, 5, 6], + [2, 6, 3], + [3, 6, 7], + [3, 7, 0], + [0, 7, 4] ] ); + } else { + if (!validAngle) echo("Trapezoid invalid, angle must be less than 90"); + else echo("Trapezoid invalid, H is larger than triangle"); + } +} \ No newline at end of file diff --git a/gnal_v3.scad b/gnal_v3.scad new file mode 100644 index 0000000..dc6e0ba --- /dev/null +++ b/gnal_v3.scad @@ -0,0 +1,827 @@ +//GNAL v3 Shared Library + +include <./path_extrude.scad>; +include <./threads.scad>; +include <./Triangles.scad>; + +/** + * THREADS + * TOP (large screw) + * metric_thread (diameter=13.6, pitch=1.5 ,thread_size = 1.6, length = 21); + * TOP VOID + * metric_thread (diameter=13.6 + .5, pitch=1.5, thread_size = 1.6, length = 21); + * + clone translated along Z by 0.2mm + * BOTTOM (small screw) + * metric_thread (diameter=10, pitch=1.5, thread_size = 1.6, length=LEN); + * SINGLE LEVEL (middle screw) + * + */ + +DEBUG = false; +FINE = 200; + +OD = 10 + .5; +PITCH = 1.5; +THREAD = 1.6; +LEN = 21; + +INSERT_D = 26; +SINGLE_THREAD_D = 12; + +function X (start_r, spacing, fn, r, i) = (start_r + (r * spacing) + (i * calcIncrement(spacing, fn))) * cos(i * calcAngle(fn)); +function Y (start_r, spacing, fn, r, i) = (start_r + (r * spacing) + (i * calcIncrement(spacing, fn))) * sin(i * calcAngle(fn)); + +function circ (d) = PI * d; +function calcFacetSize (end_d, fn) = circ( end_d ) / fn; +//function calcSteps(rotations, fn) = fn * rotations; +function calcAngle (fn) = 360 / fn; +function calcFn(start_d, start_fn, end_d, spacing, r) = start_fn + + ( ((circ(calcR(start_d, spacing, r) * 2) - circ(start_d) ) + / (circ(end_d) - circ(start_d))) * ($fn - start_fn)); +function calcR(start_d, spacing, r) = (start_d / 2) + (spacing * r); +function calcIncrement(spacing, fn) = spacing / fn; + +/** + * spiral_7 - Combination of spiral_3 and spiral_4 that doesn't sacrifice + * performance. Hits an overflow when $fn is higher than 245 which creates + * 8418 vectors at 60 rotations. This is an edge case, only appearing in OpenSCAD + * 2019.05 (and maybe earlier), but should be explored. + **/ +module spiral (rotations = 40, start_d = 48, spacing = 2.075, bottom = -7.1, fn) { + + //bottom = -7.1; + w = 1.4; + top_w = .8; + top_offset = (w - top_w); + h = 2.2; + + facetProfile = [ + [w, -bottom], + [0, -bottom], + [0, 0], + [top_offset, -h], + [w, -h], + [w, 0] + ]; + + end_d = start_d + (spacing * 2 * rotations); + end_r = end_d / 2; + start_r = start_d / 2; + + facetSize = calcFacetSize(end_d, fn); + start_fn = round(circ(start_d) / facetSize); + + + spiralPath = [ for (r = [0 : rotations - 1]) for (i = [0 : round(calcFn(start_d, start_fn, end_d, spacing, r )) - 1 ]) + [ + X(start_r, spacing, round(calcFn(start_d, start_fn, end_d, spacing, r )), r, i), + Y(start_r, spacing, round(calcFn(start_d, start_fn, end_d, spacing, r )), r, i), + 0] + ]; + path_extrude(exShape=facetProfile, exPath=spiralPath); +} + +module spiral_reinforcement ( start_d = 48, spacing = 2.075, bottom = -2, fn) { + rotations = 1; + w = 1; + top_w = .8; + top_offset = (w - top_w); + h = 2.2; + + facetProfile = [ + [w, -bottom], + [0, -bottom], + [0, 0], + [0, -h], + [w, -h], + [w, 0] + ]; + + end_d = start_d + (spacing * 2 * rotations); + end_r = end_d / 2; + start_r = start_d / 2; + + facetSize = calcFacetSize(end_d, fn); + start_fn = round(circ(start_d) / facetSize); + + + spiralPath = [ for (r = [0 : rotations - 1]) for (i = [0 : round(calcFn(start_d, start_fn, end_d, spacing, r )) - 1 ]) + [ + X(start_r, spacing, round(calcFn(start_d, start_fn, end_d, spacing, r )), r, i), + Y(start_r, spacing, round(calcFn(start_d, start_fn, end_d, spacing, r )), r, i), + 0] + ]; + path_extrude(exShape=facetProfile, exPath=spiralPath); +} + +/** + * Core (center of the reel) + **/ +module gnal_spiral_core () { + $fn = 360; + + core_center_h = 4.2 + 3;; + + core_bottom_outer_d = 53; + core_bottom_outer_void_d = 44; + core_bottom_outer_h = 4.2; + + core_d = 29.5; + core_h = 8.5; + + core_bottom_d = 26; + core_bottom_h = 4.2; + + top_z_offset = (core_h / 2) - (core_center_h / 2); + + core_void_outer_d = 20.5; + core_void_inner_d = 14.5; + core_void_h = 11.5; + + arms_outer_d = 48; + arms_inner_d = 48 - 7; + + void_d = 18; + + film_void = 0.6; + + difference () { + union() { + //center + translate([0, 0, -core_center_h / 2]) { + cylinder(r = (core_bottom_outer_d - 1) / 2, h = core_center_h, center = true); + } + //top + translate([0, 0, top_z_offset]) { + cylinder(r = core_d / 2, h = core_h + core_center_h, center = true); + } + } + cylinder(r = void_d / 2, h = 30, center = true); + translate([0, 0, -7.2]) spiral_insert_void(); + } + + //arms + difference () { + union () { + translate([0, 0, top_z_offset]) difference() { + //adjusted arm (shorter) + intersection () { + cylinder(r = arms_outer_d / 2, h = core_h + core_center_h, center = true); + translate([1, 0, 0]) cylinder(r = arms_outer_d / 2, h = core_h + core_center_h, center = true); + } + intersection () { + cylinder(r = arms_inner_d / 2, h = core_h + core_center_h + 1, center = true); + translate([1, 0, 0]) cylinder(r = arms_inner_d / 2, h = core_h + core_center_h + 1, center = true); + } + translate([0, arms_outer_d / 2, 0]) cube([arms_outer_d, arms_outer_d, arms_outer_d], center = true); + } + //rounded arm end + translate([(arms_outer_d + arms_inner_d) / 4, 0, top_z_offset]) cylinder(r = 3.5 / 2, h = core_h + core_center_h, center = true, $fn = 40); + //adjusted arm + translate([-((arms_outer_d + arms_inner_d) / 4) + 1, 0, top_z_offset]) cylinder(r = 3.5 / 2, h = core_h + core_center_h, center = true, $fn = 40); + difference () { + rotate([0, 0, -120]) translate([13.75, 0, top_z_offset]) cube([16, 20, core_h + core_center_h], center = true); + //remove piece from adjusted arm + translate([-19, -14, 0]) rotate([0, 0, 10]) cube([4, 4, 30], center = true); + //remove piece from non-adjusted arm + rotate([0, 0, 45]) translate([-19, -14, 0]) rotate([0, 0, -10]) cube([4, 4, 30], center = true); + rotate([0, 0, -120 - 37]) translate([18, 0, top_z_offset]) { + cylinder(r = 6.8 / 2, h = 30, center = true); + translate([-4, -2, 0]) cube([4, 4, 30], center = true); + } + rotate([0, 0, -120 + 37]) translate([18, 0, top_z_offset]) { + cylinder(r = 6.8 / 2, h = 30, center = true); + translate([-4, 2, 0]) cube([4, 4, 30], center = true); + } + } + } + //film void (notches) + rotate([0, 0, -120]) { + translate([20, -5, 0]) { + rotate([0, 0, 45]) { + cube([20, film_void, 30], center = true); + } + } + } + rotate([0, 0, -120]) { + translate([20, 5, 0]) { + rotate([0, 0, -45]) { + cube([20, film_void, 30], center = true); + } + } + } + + //flatten piece + rotate([0, 0, -120]) translate([25, 0, 0]) difference () { + cylinder(r = 8 / 2, h = 30, center = true); + translate([-6.9, 0, 0]) cube([8, 8, 30], center = true); + } + cylinder(r = core_void_outer_d / 2, h = core_void_h, center = true); + rotate([0, 0, -120]) translate([20, 0, -1.5]) rotate([0, 0, 45]) cube([20, 20, 3.01], center = true); + cylinder(r = void_d / 2, h = 30, center = true); + translate([0, 0, -7.2]) spiral_insert_void(); + } +} + +module spiral_insert_void () { + intersection () { + rotate([0, 45, 0]) cube([3, INSERT_D + 2, 3], center = true); + cylinder(r = (INSERT_D + 1) / 2, h = 6, center = true); + } + intersection () { + rotate([0, 45, 90]) cube([3, INSERT_D + 2, 3], center = true); + cylinder(r = (INSERT_D + 1) / 2, h = 6, center = true); + } +} + +module gnal_spiral_bottom_insert_s8 () { + $fn = 160; + OD = 10.5 + .3; + void_d = 18 - .6; + H = 17; + D2 = INSERT_D; + + translate([0, 0, 0]) difference () { + union () { + cylinder(r = void_d / 2, h = H, center = true); + //skirt + translate([0, 0, -(H - 1) / 2]) cylinder(r = D2 / 2, h = 1.5, center = true); + //notches + translate([0, 0, -((H - 2.5) / 2) - .1]) { + intersection () { + cylinder(r = D2 / 2, h = 6, center = true); + difference () { + rotate([0, 45, 0]) cube([3, D2 + 2, 3], center = true); + translate([0, 0, -1.5]) cube([6, D2 + 3, 3], center = true); + } + } + intersection () { + cylinder(r = D2 / 2, h = 6, center = true); + rotate([0, 0, 90]) difference () { + rotate([0, 45, 0]) cube([3, D2 + 2, 3], center = true); + translate([0, 0, -1.5]) cube([6, D2 + 3, 3], center = true); + } + } + } + } + translate([0, 0, -LEN / 2]) { + if (DEBUG) { + cylinder(r = OD / 2, h = LEN); + } else { + metric_thread (diameter=OD, pitch=PITCH, thread_size = THREAD, length=LEN); + } + } + } +} + +module gnal_spiral_bottom_insert_16 () { + $fn = 160; + OD = 10.5 + .3; + + void_d = 18 - .6; + H = 17 + 8; + D2 = INSERT_D; + + RIDGES = 8; + RIDGE_D = 3; + + translate([0, 0, 0]) difference () { + union () { + cylinder(r = void_d / 2, h = H, center = true); + //skirt + translate([0, 0, -(H - 1) / 2]) cylinder(r = D2 / 2, h = 1.5, center = true); + //notches + translate([0, 0, -((H - 2.5) / 2) - .1]) { + intersection () { + cylinder(r = D2 / 2, h = 6, center = true); + difference () { + rotate([0, 45, 0]) cube([3, D2 + 2, 3], center = true); + translate([0, 0, -1.5]) cube([6, D2 + 3, 3], center = true); + } + } + intersection () { + cylinder(r = D2 / 2, h = 6, center = true); + rotate([0, 0, 90]) difference () { + rotate([0, 45, 0]) cube([3, D2 + 2, 3], center = true); + translate([0, 0, -1.5]) cube([6, D2 + 3, 3], center = true); + } + } + } + } + translate([0, 0, -(H / 2) - 2]) { + if (DEBUG) { + cylinder(r = OD / 2, h = LEN + 8); + } else { + metric_thread (diameter=OD, pitch=PITCH, thread_size = THREAD, length=LEN + 8); + } + } + translate([0, 0, 8.5]) { + for (i = [0: RIDGES - 1]) { + rotate([0, 0, i * (360 / RIDGES)]) translate([void_d / 2, 0, 0]) cylinder(r = RIDGE_D / 2, h = 8.1, center = true); + } + } + } +} + +/** + * Comment to preserve my sanity when developing: This single-spiral + * insert is the same height as the s8 insert but has a different + * diameter void fo the screw to prevent mismatching of spindle screws + * designed for different purposes. + **/ +module gnal_spiral_bottom_insert_single () { + $fn = 160; + void_d = 18 - .6; + H = 17; + D2 = INSERT_D; + + translate([0, 0, 0]) difference () { + union () { + cylinder(r = void_d / 2, h = H, center = true); + //skirt + translate([0, 0, -(H - 1) / 2]) cylinder(r = D2 / 2, h = 1.5, center = true); + //notches + translate([0, 0, -((H - 2.5) / 2) - .1]) { + intersection () { + cylinder(r = D2 / 2, h = 6, center = true); + difference () { + rotate([0, 45, 0]) cube([3, D2 + 2, 3], center = true); + translate([0, 0, -1.5]) cube([6, D2 + 3, 3], center = true); + } + } + intersection () { + cylinder(r = D2 / 2, h = 6, center = true); + rotate([0, 0, 90]) difference () { + rotate([0, 45, 0]) cube([3, D2 + 2, 3], center = true); + translate([0, 0, -1.5]) cube([6, D2 + 3, 3], center = true); + } + } + } + } + translate([0, 0, -LEN / 2]) { + if (DEBUG) { + cylinder(r = SINGLE_THREAD_D / 2, h = LEN); + } else { + metric_thread (diameter=SINGLE_THREAD_D, pitch=PITCH, thread_size = THREAD, length = LEN); + } + } + } +} + +/** + * Spacers + **/ + +module spacer_ridges () { + ridges = 16; + for (i = [0 : ridges]) { + rotate([0, 0, i * (360 / ridges)]) translate([13.5, 0, 0]) cylinder(r = 1.25, h = 8, $fn = 60); + } +} + +module spacer_ridges_loose () { + ridges = 16; + intersection () { + union () { + for (i = [0 : ridges]) { + rotate([0, 0, i * (360 / ridges)]) translate([13.7, 0, 0]) cylinder(r = 1.25, h = 8, $fn = 60); + } + } + cylinder(r = 13.7, h = 12, center = true); + } +} +module spacer_outer_ridges () { + ridges = 24; + H = 6.5; + difference () { + union () { + for (i = [0 : ridges]) { + rotate([0, 0, i * (360 / ridges)]) translate([14.6, 0, -4.75]) cylinder(r = 1.25, h = 8, $fn = 30); + } + } + translate([0, 0, -4.1]) difference () { + cylinder(r = 33 / 2, h = 4, center = true, $fn = 100); + cylinder(r2 = 33 / 2, r1 = 27.75 / 2, h = 4.1, center = true, $fn = 100); + } + } +} + +module gnal_spacer_solid () { + core_d = 29.5; + core_bottom_d = 26.2 + .2; + void_d = 18; + h = 8; + + RIDGES = 8; + RIDGE_D = 3; + translate([0, 0, 0]) difference () { + union () { + difference () { + cylinder(r = core_d / 2, h = h, center = true, $fn = 200); + } + translate([0, 0, -.75]) rotate([0, 180, 0]) spacer_outer_ridges(); + } + } +} + +/** + * This spacer attaches to the top piece when it is used + * for Super8 film. + **/ +module gnal_spacer () { + add = 3.25; + core_d = 29.5; + core_bottom_d = 26.2 + .2; + void_d = 22.5; + h = 8 + add; + translate([0, 0, (add / 2) - 1]) difference () { + union () { + difference () { + cylinder(r = core_d / 2, h = h, center = true, $fn = 200); + translate([0, 0, 8]) cylinder(r = core_bottom_d / 2, h = h, center = true, $fn = 200); + cylinder(r = void_d / 2, h = h + 1, center = true, $fn = 200); + } + translate([0, 0, 0]) spacer_ridges_loose(); + spacer_outer_ridges(); + } + //trim top + translate([0, 0, h - 0.1]) cylinder(r = (core_d + 1) / 2, h = h, center = true, $fn = 200); + //trim bottom + translate([0, 0, -h + 0.9]) cylinder(r = (core_d + 1) / 2, h = h, center = true, $fn = 200); + } +} + + +module gnal_spacer_16 () { + core_d = 29.5; + core_bottom_d = 26.2 + .2; + void_d = 18.3; + h = 8; + + RIDGES = 8; + RIDGE_D = 3; + difference () { + gnal_spacer_solid(); + cylinder(r = void_d / 2, h = h + 1, center = true, $fn = 200); + } + translate([0, 0, 0]) { + for (i = [0: RIDGES - 1]) { + rotate([0, 0, i * (360 / RIDGES)]) translate([void_d / 2, 0, 0]) cylinder(r = RIDGE_D / 2, h = 8, center = true); + } + } +} + +/** + * Spindles + **/ + +module gnal_spindle_base ( ) { + D = 8.45 * 2; + H = 20; + union() { + translate([0, 0, -15]) { + cylinder(r = D / 2, h = H, center = true, $fn = FINE); + } + } +} + +module gnal_spindle_bottom_base ( HEX = false) { + //for grip + BUMP = 2; //diameter + BUMPS = 6; + TOP_D = 19; + TOP_H = 9.5; + TOP_OFFSET = -24.5; + + union() { + gnal_spindle_base(); + //hex version + if (HEX) { + translate([0, 0, TOP_OFFSET]) { + cylinder(r = 11.1, h = TOP_H, center = true, $fn = 6); + } + } else { + translate([0, 0, TOP_OFFSET]) { + cylinder(r = TOP_D / 2, h = TOP_H, center = true, $fn = FINE); + } + } + for (i = [0 : BUMPS]) { + rotate([0, 0, (360 / BUMPS) * i]) { + translate([0, 8.9, TOP_OFFSET]) { + cylinder(r = BUMP, h = TOP_H, center = true, $fn = 60); + } + } + } + } +} + +module outer_screw (LEN) { + OD = 10; + PITCH = 1.5; + THREAD = 1.6; + + difference () { + translate([0, 0, -7.1]) { + if (DEBUG) { + cylinder(r = OD / 2, h = LEN); + } else { + metric_thread (diameter=OD, pitch=PITCH, thread_size = THREAD, length=LEN); + } + } + //bevel top of screw + translate([0, 0, LEN - 8]) difference() { + cylinder(r = 8, h = 3, center = true, $fn = FINE); + cylinder(r1 = 6, r2 = 3, h = 3.01, center = true, $fn = FINE); + } + } +} + +module gnal_spindle_bottom (ALT = false, HEX = false) { + OD = 13.6 + .5; + PITCH = 1.5; + THREAD = 1.6; + IN_LEN = 21; + + LEN = 17.1; + ALT_LEN = 27.1; + difference () { + gnal_spindle_bottom_base(HEX); + //inner screw negative + translate([0, 0, -30]) union() { + if (DEBUG) { + cylinder(r = OD / 2, h = IN_LEN); + } else { + metric_thread (diameter=OD, pitch=PITCH, thread_size = THREAD, length = IN_LEN); + } + translate([0, 0, 0.2]) { + if (DEBUG) { + cylinder(r = OD / 2, h = IN_LEN); + } else { + metric_thread (diameter=OD, pitch=PITCH, thread_size = THREAD, length = IN_LEN); + } + } + } + } + + difference () { + //outer screw + if (ALT) { + outer_screw(ALT_LEN); + } else { + outer_screw(LEN); + } + } +} + +module number_one () { + rotate([0, 45, 0]) cube([1, 6, 1], center = true); + translate([0, 6 / 2, 0]) rotate([45, 0, 0]) cube([2, 1, 1], center = true); + translate([0, -6 / 2, 0]) rotate([45, 0, 0]) cube([2, 1, 1], center = true); +} + +module gnal_spindle_top () { + D = 50; + THICKNESS = 2.5; + H = 19.5; + ROUND = 8; + + HANDLE_D = 13.25; + HANDLE_BASE = 16; + HANDLE_TOP = 13; + HANDLE_H = 54.5; + + NOTCHES = 17; + NOTCH = 1.5; + FINE = 200; + + difference () { + //cup + translate([0, 0, ROUND - 2]) minkowski () { + cylinder(r = (D / 2) - ROUND, h = (H * 2) - ROUND, center = true, $fn = FINE); + sphere(r = ROUND, $fn = FINE); + } + translate([0, 0, ROUND - 2 + THICKNESS]) minkowski () { + cylinder(r = (D / 2) - THICKNESS - ROUND, h = (H * 2) - ROUND, center = true, $fn = 200); + sphere(r = ROUND, $fn = FINE); + } + //hollow out cup + translate([0, 0, H + ROUND - 4 - 3]) { + cylinder(r = (D / 2) + 1, h = H * 2, center = true); + } + + //inner cup bevel + translate([0, 0, (H / 2) - ROUND - 1]) { + cylinder(r1 = (D / 2) - 2.5, r2 = (D / 2) - 2.5 + 1, h = 1, center = true, $fn = FINE); + } + //outer cup bevel + translate([0, 0, (H / 2) - ROUND - 1]) { + difference () { + cylinder(r = (D / 2) + .25, h = 1, center = true, $fn = FINE); + cylinder(r2 = (D / 2) - .8, r1 = (D / 2) - .8 + 1, h = 1, center = true, $fn = FINE); + } + } + //hole in cup + translate([21, 0, -10]) cylinder(r = 3 / 2, h = 40, center = true, $fn = 40); + } + + //reference cylinder + //translate([0, 0, -6.6]) color("red") cylinder(r = 50 / 2, h = 19.57, center = true); + + //handle + translate([0, 0, -15]) { + difference() { + cylinder(r1 = HANDLE_BASE / 2, r2 = HANDLE_TOP / 2, h = HANDLE_H, $fn = FINE); + //text + translate([3 / 2, 0, 15 + 39.75]) number_one(); + translate([-3 / 2, 0, 15 + 39.75]) number_one(); + //ring negative + translate([0, 0, 31 + 14.5]) { + difference () { + cylinder(r = HANDLE_D / 2 + 2, h = 20, center = true); + cylinder(r = HANDLE_D / 2 - .5, h = 20 + 1, center = true); + } + } + //handle notches + for(i = [0 : NOTCHES]) { + rotate([0, 0, i * (360 / NOTCHES)]) { + translate([0, HANDLE_D / 2 - .5, 31 + 14.5]) { + rotate([0.75, 0, 0]) rotate([0, 0, 45]) { + Right_Angled_Triangle(a = NOTCH, b = NOTCH, height = 20, centerXYZ=[true, true, true]); + } + } + } + } + //bevel handle at top + translate([0, 0, 54.01]) { + difference () { + cylinder(r = 13 / 2, h = 1, center = true); + cylinder(r1 = 12.5 / 2, r2 = 11.5 / 2, h = 1.01, center = true); + } + } + } + + } + //attach handle with pyramid cylinder + translate ([0, 0, -13.7]) { + cylinder(r1 = 16 / 2 + 2, r2 = 16 / 2 - .1, h = 3, center = true, $fn = FINE); + } + //plate under cup + translate([0, 0, -17.75]) { + cylinder(r = 31.5 / 2, h = 1, center = true, $fn = FINE); + } + //screw + translate([0, 0, -37.5]) { + if (DEBUG) { + cylinder(r = 13.6 / 2, h = 21); + } else { + metric_thread (diameter=13.6, pitch = PITCH, thread_size = THREAD, length = 21); + } + } + //cylinder plug + translate([0, 0, -37.5 + (21 / 2) - 1]) { + cylinder(r = 12 / 2, h = 21, center = true, $fn = FINE); + } +} + +module gnal_spindle_single () { + D = 50; + THICKNESS = 2.5; + H = 19.5; + ROUND = 8; + + HANDLE_D = 13.25; + HANDLE_BASE = 16; + HANDLE_TOP = 13; + HANDLE_H = 54.5; + + NOTCHES = 17; + NOTCH = 1.5; + FINE = 200; + + SINGLE_INSERT = 11; + + difference () { + //cup + translate([0, 0, ROUND - 2]) minkowski () { + cylinder(r = (D / 2) - ROUND, h = (H * 2) - ROUND, center = true, $fn = FINE); + sphere(r = ROUND, $fn = FINE); + } + translate([0, 0, ROUND - 2 + THICKNESS]) minkowski () { + cylinder(r = (D / 2) - THICKNESS - ROUND, h = (H * 2) - ROUND, center = true, $fn = 200); + sphere(r = ROUND, $fn = FINE); + } + //hollow out cup + translate([0, 0, H + ROUND - 4 - 3]) { + cylinder(r = (D / 2) + 1, h = H * 2, center = true); + } + + //inner cup bevel + translate([0, 0, (H / 2) - ROUND - 1]) { + cylinder(r1 = (D / 2) - 2.5, r2 = (D / 2) - 2.5 + 1, h = 1, center = true, $fn = FINE); + } + //outer cup bevel + translate([0, 0, (H / 2) - ROUND - 1]) { + difference () { + cylinder(r = (D / 2) + .25, h = 1, center = true, $fn = FINE); + cylinder(r2 = (D / 2) - .8, r1 = (D / 2) - .8 + 1, h = 1, center = true, $fn = FINE); + } + } + //hole in cup + translate([21, 0, -10]) cylinder(r = 3 / 2, h = 40, center = true, $fn = 40); + } + + //reference cylinder + //translate([0, 0, -6.6]) color("red") cylinder(r = 50 / 2, h = 19.57, center = true); + + //handle + + translate([0, 0, -15]) { + difference() { + cylinder(r1 = HANDLE_BASE / 2, r2 = HANDLE_TOP / 2, h = HANDLE_H, $fn = FINE); + //text + translate([0, 0, 15 + 39.75]) number_one(); + //ring negative + translate([0, 0, 31 + 14.5]) { + difference () { + cylinder(r = HANDLE_D / 2 + 2, h = 20, center = true); + cylinder(r = HANDLE_D / 2 - .5, h = 20 + 1, center = true); + } + } + //handle notches + for(i = [0 : NOTCHES]) { + rotate([0, 0, i * (360 / NOTCHES)]) { + translate([0, HANDLE_D / 2 - .5, 31 + 14.5]) { + rotate([0.75, 0, 0]) rotate([0, 0, 45]) { + Right_Angled_Triangle(a = NOTCH, b = NOTCH, height = 20, centerXYZ=[true, true, true]); + } + } + } + } + //bevel handle at top + translate([0, 0, 54.01]) { + difference () { + cylinder(r = 13 / 2, h = 1, center = true); + cylinder(r1 = 12.5 / 2, r2 = 11.5 / 2, h = 1.01, center = true); + } + } + } + + } + //attach handle with pyramid cylinder + translate ([0, 0, -13.7]) { + cylinder(r1 = 16 / 2 + 2, r2 = 16 / 2 - .1, h = 3, center = true, $fn = FINE); + } + //plate under cup + translate([0, 0, -17.75]) { + cylinder(r = 31.5 / 2, h = 1, center = true, $fn = FINE); + } + //insert for single layer + translate ([0, 0, -24.25]) { + cylinder(r = 22 / 2, h = 14, center = true, $fn = FINE); + } + //screw + translate([0, 0, -37.5 - SINGLE_INSERT]) { + if (DEBUG) { + cylinder(r = SINGLE_THREAD_D / 2, h = 21); + } else { + metric_thread (diameter=SINGLE_THREAD_D, pitch = PITCH, thread_size = THREAD, length = 21); + } + } + //cylinder plug + translate([0, 0, -37.5 - SINGLE_INSERT + (21 / 2) - 1]) { + cylinder(r = 10 / 2, h = 21, center = true, $fn = FINE); + } +} + +module gnal_stacking_spindle () { + OD = 10.5 + .3; + IN_LEN = 21; + + LEN = 17.1; + ALT_LEN = 27.1; + difference () { + union () { + gnal_spindle_base(); + translate([0, 0, -23.75]) gnal_spacer_solid(); + } + //inner screw negative + translate([0, 0, -30]) union() { + if (DEBUG) { + cylinder(r = OD / 2, h = IN_LEN); + } else { + metric_thread (diameter=OD, pitch=PITCH, thread_size = THREAD, length = IN_LEN); + } + translate([0, 0, 0.2]) { + if (DEBUG) { + cylinder(r = OD / 2, h = IN_LEN); + } else { + metric_thread (diameter=OD, pitch=PITCH, thread_size = THREAD, length = IN_LEN); + } + } + } + } + + difference () { + outer_screw(LEN - 2); + } +} \ No newline at end of file diff --git a/paterson16.scad b/paterson16.scad new file mode 100644 index 0000000..9e30535 --- /dev/null +++ b/paterson16.scad @@ -0,0 +1,89 @@ +include <./gnal_v3.scad>; + +$fn = 250; + +REEL_H = 42; +REEL_D = 99; +REEL_OUTER_WALL_H = 4; +REEL_OUTER_WALL_W = 3; + +REEL_INNER_D = 25.7 + 6; +REEL_INNER_H = 19.5; +REEL_INNER_WALL_W = 3; + +SPOKE_H = 3; + +module reel_frame () { + //outer wall + translate([0, 0, REEL_OUTER_WALL_H / 2]) difference () { + cylinder(r = REEL_D / 2, h = REEL_OUTER_WALL_H, center = true); + cylinder(r = (REEL_D / 2) - REEL_OUTER_WALL_W, h = REEL_OUTER_WALL_H + 1, center = true); + } + + //inner wall + translate([0, 0, REEL_INNER_H / 2]) difference () { + cylinder(r = REEL_INNER_D / 2, h = REEL_INNER_H, center = true); + cylinder(r = (REEL_INNER_D / 2) - REEL_INNER_WALL_W, h = REEL_INNER_H + 1, center = true); + translate([14, 0, 0]) rotate([0, 0, 45]) cube([10, 0.3, 20], center = true); + translate([0, 0, -REEL_INNER_H / 2]) intersection () { + cylinder(r = 30.5 / 2, h = 6, center = true); + rotate([0, 45, 0]) cube([3, 31, 3], center = true); + } + } + //top notches + translate([0, 0, 19.4]) difference () { + intersection () { + cylinder(r = 30 / 2, h = 6, center = true); + rotate([0, 45, 0]) cube([3, 30, 3], center = true); + } + cylinder(r = (REEL_INNER_D / 2) - REEL_INNER_WALL_W, h = 6 + 1, center = true); + } + + //spokes + translate([0, 0, SPOKE_H / 2]) for (i = [0:5]) { + rotate([0, 0, i * (360 / 6)]) { + translate([0, ((REEL_D - REEL_INNER_D) / 2) - 1.5, 0]) { + cube([4.5, (REEL_D - REEL_INNER_D) / 2, SPOKE_H], center = true); + } + } + } + + translate([0, 0, 4]) rotate([0, 0, 8]) spiral(rotations = 15, fn = $fn, start_d = 29.5, bottom = -4); +} + +module reel_top () { + //outer wall + translate([0, 0, SPOKE_H / 2]) difference () { + cylinder(r = REEL_D / 2, h = SPOKE_H, center = true); + cylinder(r = (REEL_D / 2) - REEL_OUTER_WALL_W, h = REEL_OUTER_WALL_H + 1, center = true); + } + + //inner wall + translate([0, 0, SPOKE_H / 2]) difference () { + cylinder(r = REEL_INNER_D / 2, h = SPOKE_H, center = true); + cylinder(r = (REEL_INNER_D / 2) - REEL_INNER_WALL_W, h = REEL_INNER_H + 1, center = true); + translate([0, 0, -SPOKE_H / 2]) intersection () { + cylinder(r = 30.5 / 2, h = 6, center = true); + rotate([0, 45, 0]) cube([3, 31, 3], center = true); + } + } + + translate([0, 0, SPOKE_H / 2]) difference () { + cylinder(r = (REEL_INNER_D + REEL_D) / 4, h = SPOKE_H, center = true); + cylinder(r = ((REEL_INNER_D + REEL_D) / 4) - REEL_INNER_WALL_W, h = REEL_INNER_H + 1, center = true); + } + + //spokes + translate([0, 0, SPOKE_H / 2]) for (i = [0:5]) { + rotate([0, 0, i * (360 / 6)]) { + translate([0, ((REEL_D - REEL_INNER_D) / 2) - 1.5, 0]) { + cube([4.5, (REEL_D - REEL_INNER_D) / 2, SPOKE_H], center = true); + } + } + } +} + + +//reel_frame(); +rotate([180, 0, 0]) reel_top(); +//translate([0, 0, -19.5]) reel_frame(); diff --git a/path_extrude.scad b/path_extrude.scad new file mode 100644 index 0000000..aa2b0da --- /dev/null +++ b/path_extrude.scad @@ -0,0 +1,195 @@ +// path_extrude.scad -- Extrude a path in 3D space +// usage: add "use ;" to the top of your OpenSCAD source code + +// Copyright (C) 2014-2019 David Eccles (gringer) + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +// Determine the projection of a point on a plane centered at c1 with normal n1 +function project(p, c, n) = + p - (n * (p - c)) * n / (n * n); + +// determine angle between two points with a given normal orientation +// see https://stackoverflow.com/questions/14066933/ +// direct-way-of-computing-clockwise-angle-between-2-vectors +// dot = p1 * p2; +// det = (p1[0]*p2[1]*n1[2] + p2[0]*n1[1]*p1[2] + n1[0]*p1[1]*p2[2]) - +// (n1[0]*p2[1]*p1[2] + p1[0]*n1[1]*p2[2] + p2[0]*p1[1]*n1[2]); +// atan2(det, dot); +// determine angle between two planar points and a centre +// with a given normal orientation +function getPlanarAngle(p1, p2, c1, n1) = + let(p1 = p1-c1, n1=n1 / norm(n1), p2=p2-c1) + atan2((p1[0]*p2[1]*n1[2] + p2[0]*n1[1]*p1[2] + n1[0]*p1[1]*p2[2]) - + (n1[0]*p2[1]*p1[2] + p1[0]*n1[1]*p2[2] + p2[0]*p1[1]*n1[2]), p1 * p2); + +function c3D(tPoints) = + (len(tPoints[0]) == undef) ? // single point + c3D([tPoints])[0] : + (len(tPoints[0]) < 3) ? // collection of 2D points + tPoints * [[1,0,0],[0,1,0]] : + tPoints; // 3D points + +// translate a point (or points) +function myTranslate(ofs, points, acc = []) = + (len(points[0]) == undef) ? + myTranslate(ofs, [points])[0] : + [ for(i = [0:(len(points) - 1)]) + [ for(d = [0:(len(points[0])-1)]) (ofs[d] + points[i][d])]]; + +// rotate a point (or points) +function myRotate(rotVec, points) = + let(rotX = [[1, 0, 0], + [0, cos(rotVec[0]), -sin(rotVec[0])], + [0, sin(rotVec[0]), cos(rotVec[0])]], + rotY = [[ cos(rotVec[1]), 0,-sin(rotVec[1])], + [ 0, 1, 0], + [ sin(rotVec[1]), 0, cos(rotVec[1])]], + rotZ = [[ cos(rotVec[2]), sin(rotVec[2]), 0], + [ sin(rotVec[2]), -cos(rotVec[2]), 0], + [0, 0, 1]]) + (len(points[0]) == undef) ? + myRotate(rotVec, [points])[0] : + c3D(points) * rotX * rotY * rotZ; + +// Determine spherical rotation for cartesian coordinates +function rToS(pt) = + [-acos((pt[2]) / norm(pt)), + 0, + -atan2(pt[0],pt[1])]; + +function calcPreRot(p1, p2, p3) = + let(n1=p2-p1, // normal between the two points (i.e. the plane that the polygon sits on) + n2=p3-p2, + rt1=rToS(n1), + rt2=rToS(n2), + pj1=(p2 + myRotate(rt2, [[1e42,0,0]])[0]), + pj2=project(p=(p1 + myRotate(rt1, [[1e42,0,0]])[0]), c=p2, n=n2)) + getPlanarAngle(p1=pj1, p2=pj2, c1=p2, n1=n2); + +function cumSum(x, res=[]) = + (len(x) == len(res)) ? concat([0], res) : + (len(res) == 0) ? cumSum(x=x, res=[x[0]]) : + cumSum(x=x, res=concat(res, [x[len(res)] + res[len(res)-1]])); + +// Create extrusion side panels for one polygon segment as triangles. +// Note: panels are not necessarily be planar due to path twists +function makeSides(shs, pts, ofs=0) = + concat( + [for(i=[0:(shs-1)]) [i+ofs, ((i+1) % shs + ofs + shs) % (shs * pts), + (i+1) % shs + ofs]], + [for(i=[0:(shs-1)]) [((i+1) % shs + ofs + shs) % (shs * pts), + i+ofs, (i + ofs + shs) % (shs * pts)]]); + +// Concatenate the contents of the outermost list +function flatten(A, acc = [], aDone = 0) = + (aDone >= len(A)) ? acc : + flatten(A, acc=concat(acc, A[aDone]), aDone = aDone + 1); + +// Linearly interpolate between two shapes +function makeTween(shape1, shape2, t) = + (t == 0) ? shape1 : + (t == 1) ? shape2 : + [for (i=[0:(len(shape1)-1)]) + (shape1[i]*(1-t) + shape2[i % len(shape2)]*(t))]; + +// Extrude a 2D shape through a 3D path +// Note: merge has two effects: +// 1) Removes end caps +// 2) Adjusts the rotation of each path point +// so that the end and start match up +module path_extrude(exPath, exShape, exShape2=[], + exRots = [0], exScale = [1], merge=false, preRotate=true){ + exShapeTween = (len(exShape2) == 0) ? + exShape : exShape2; + shs = len(exShape); // shs: shape size + pts = len(exPath); // pts: path size + exPathX = (merge) ? concat(exPath, [exPath[0], exPath[1]]) : + concat(exPath, + [exPath[pts-1] + (exPath[pts-1] - exPath[pts-2]), + exPath[pts-1] + 2*(exPath[pts-1] - exPath[pts-2])]); + exScaleX = (len(exScale) == len(exPath)) ? exScale : + [for (i = [0:(pts-1)]) exScale[i % len(exScale)]]; + preRots = [for(i = [0:(pts-1)]) + preRotate ? + calcPreRot(p1=exPathX[i], // "current" point on the path + p2=exPathX[(i+1)], // "next" point on the path + p3=exPathX[(i+2)]) : + 0 ]; + cumPreRots = cumSum(preRots); + seDiff = cumPreRots[len(cumPreRots)-1]; // rotation difference (start - end) + // rotation adjustment to get start to look like end + seAdj = -seDiff / (len(cumPreRots)); + adjPreRots = (!merge) ? cumPreRots : + [for(i = [0:(pts-1)]) (cumPreRots[i] + seAdj * i)]; + adjExRots = (len(exRots) == 1) ? + [for(i = [0:(len(adjPreRots)-1)]) (adjPreRots[i] + exRots[0])] : + [for(i = [0:(len(adjPreRots)-1)]) (adjPreRots[i] + exRots[i % len(exRots)])]; + phPoints = flatten([ + for(i = [0:(pts-1)]) + let(p1=exPathX[i], + p2=exPathX[(i+1)], + n1=p2-p1, // normal between the two points + rt1=rToS(n1)) + myTranslate(p1, myRotate(rt1, myRotate([0,0,-adjExRots[i]], + c3D(makeTween(exShape, exShapeTween, i / (pts-1)) * + exScaleX[i])))) + ]); + if(merge){ // just the surface, no end caps + polyhedron(points=phPoints, + faces=flatten([ + for(i = [0:(pts-1)]) + makeSides(shs, pts, ofs=shs*i) + ]) + ); + } else { + polyhedron(points=phPoints, + faces=concat( + flatten([ + for(i = [0:(pts-2)]) + makeSides(shs, pts, ofs=shs*i) + ]), + concat( // add in start / end covers + [[for(i= [0:(shs-1)]) i]], + [[for(i= [(len(phPoints)-1):-1:(len(phPoints)-shs)]) i]] + ) + )); + } +} + +myPathTrefoil = [ for(t = [0:(360 / 101):359]) [ // trefoil knot + 5*(.41*cos(t) - .18*sin(t) - .83*cos(2*t) - .83*sin(2*t) - + .11*cos(3*t) + .27*sin(3*t)), + 5*(.36*cos(t) + .27*sin(t) - 1.13*cos(2*t) + .30*sin(2*t) + + .11*cos(3*t) - .27*sin(3*t)), + 5*(.45*sin(t) - .30*cos(2*t) +1.13*sin(2*t) - + .11*cos(3*t) + .27*sin(3*t))] ]; + +myPointsOctagon = + let(ofs1=15) + [ for(t = [0:(360/8):359]) + ((t==90)?1:2) * [cos(t+ofs1),sin(t+ofs1)]]; +myPointsChunkOctagon = + let(ofs1=15) + [ for(t = [0:(360/8):359]) + ((t==90)?0.4:1.9) * + [cos((t * 135/360 + 45)+ofs1+45)+0.5,sin((t * 135/360 + 45)+ofs1+45)]]; +//myPoints = [ for(t = [0:(360/8):359]) 2 * [cos(t+45),sin(t+45)]]; + +pts=[2,0,0.5]; + +/*translate([0,0,0]) { + path_extrude(exRots = [$t*360], exShape=myPointsOctagon, + exPath=myPathTrefoil, merge=true); +}*/ diff --git a/threads.scad b/threads.scad new file mode 100644 index 0000000..a254f06 --- /dev/null +++ b/threads.scad @@ -0,0 +1,372 @@ +/* + * ISO-standard metric threads, following this specification: + * http://en.wikipedia.org/wiki/ISO_metric_screw_thread + * + * Copyright 2017 Dan Kirshner - dan_kirshner@yahoo.com + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * See . + * + * Version 2.3. 2017-08-31 Default for leadin: 0 (best for internal threads). + * Version 2.2. 2017-01-01 Correction for angle; leadfac option. (Thanks to + * Andrew Allen .) + * Version 2.1. 2016-12-04 Chamfer bottom end (low-z); leadin option. + * Version 2.0. 2016-11-05 Backwards compatibility (earlier OpenSCAD) fixes. + * Version 1.9. 2016-07-03 Option: tapered. + * Version 1.8. 2016-01-08 Option: (non-standard) angle. + * Version 1.7. 2015-11-28 Larger x-increment - for small-diameters. + * Version 1.6. 2015-09-01 Options: square threads, rectangular threads. + * Version 1.5. 2015-06-12 Options: thread_size, groove. + * Version 1.4. 2014-10-17 Use "faces" instead of "triangles" for polyhedron + * Version 1.3. 2013-12-01 Correct loop over turns -- don't have early cut-off + * Version 1.2. 2012-09-09 Use discrete polyhedra rather than linear_extrude () + * Version 1.1. 2012-09-07 Corrected to right-hand threads! + */ + +// Examples. +// +// Standard M8 x 1. +// metric_thread (diameter=8, pitch=1, length=4); + +// Square thread. +// metric_thread (diameter=8, pitch=1, length=4, square=true); + +// Non-standard: long pitch, same thread size. +//metric_thread (diameter=8, pitch=4, length=4, thread_size=1, groove=true); + +// Non-standard: 20 mm diameter, long pitch, square "trough" width 3 mm, +// depth 1 mm. +//metric_thread (diameter=20, pitch=8, length=16, square=true, thread_size=6, +// groove=true, rectangle=0.333); + +// English: 1/4 x 20. +//english_thread (diameter=1/4, threads_per_inch=20, length=1); + +// Tapered. Example -- pipe size 3/4" -- per: +// http://www.engineeringtoolbox.com/npt-national-pipe-taper-threads-d_750.html +// english_thread (diameter=1.05, threads_per_inch=14, length=3/4, taper=1/16); + +// Thread for mounting on Rohloff hub. +//difference () { +// cylinder (r=20, h=10, $fn=100); +// +// metric_thread (diameter=34, pitch=1, length=10, internal=true, n_starts=6); +//} + + +// ---------------------------------------------------------------------------- +function segments (diameter) = min (50, ceil (diameter*6)); + + +// ---------------------------------------------------------------------------- +// diameter - outside diameter of threads in mm. Default: 8. +// pitch - thread axial "travel" per turn in mm. Default: 1. +// length - overall axial length of thread in mm. Default: 1. +// internal - true = clearances for internal thread (e.g., a nut). +// false = clearances for external thread (e.g., a bolt). +// (Internal threads should be "cut out" from a solid using +// difference ()). +// n_starts - Number of thread starts (e.g., DNA, a "double helix," has +// n_starts=2). See wikipedia Screw_thread. +// thread_size - (non-standard) axial width of a single thread "V" - independent +// of pitch. Default: same as pitch. +// groove - (non-standard) subtract inverted "V" from cylinder (rather than +// add protruding "V" to cylinder). +// square - Square threads (per +// https://en.wikipedia.org/wiki/Square_thread_form). +// rectangle - (non-standard) "Rectangular" thread - ratio depth/(axial) width +// Default: 1 (square). +// angle - (non-standard) angle (deg) of thread side from perpendicular to +// axis (default = standard = 30 degrees). +// taper - diameter change per length (National Pipe Thread/ANSI B1.20.1 +// is 1" diameter per 16" length). Taper decreases from 'diameter' +// as z increases. +// leadin - 0 (default): no chamfer; 1: chamfer (45 degree) at max-z end; +// 2: chamfer at both ends, 3: chamfer at z=0 end. +// leadfac - scale of leadin chamfer (default: 1.0 = 1/2 thread). +module metric_thread (diameter=8, pitch=1, length=1, internal=false, n_starts=1, + thread_size=-1, groove=false, square=false, rectangle=0, + angle=30, taper=0, leadin=0, leadfac=1.0) +{ + // thread_size: size of thread "V" different than travel per turn (pitch). + // Default: same as pitch. + local_thread_size = thread_size == -1 ? pitch : thread_size; + local_rectangle = rectangle ? rectangle : 1; + + n_segments = segments (diameter); + h = (square || rectangle) ? local_thread_size*local_rectangle/2 : local_thread_size / (2 * tan(angle)); + + h_fac1 = (square || rectangle) ? 0.90 : 0.625; + + // External thread includes additional relief. + h_fac2 = (square || rectangle) ? 0.95 : 5.3/8; + + tapered_diameter = diameter - length*taper; + + difference () { + union () { + if (! groove) { + metric_thread_turns (diameter, pitch, length, internal, n_starts, + local_thread_size, groove, square, rectangle, angle, + taper); + } + + difference () { + + // Solid center, including Dmin truncation. + if (groove) { + cylinder (r1=diameter/2, r2=tapered_diameter/2, + h=length, $fn=n_segments); + } else if (internal) { + cylinder (r1=diameter/2 - h*h_fac1, r2=tapered_diameter/2 - h*h_fac1, + h=length, $fn=n_segments); + } else { + + // External thread. + cylinder (r1=diameter/2 - h*h_fac2, r2=tapered_diameter/2 - h*h_fac2, + h=length, $fn=n_segments); + } + + if (groove) { + metric_thread_turns (diameter, pitch, length, internal, n_starts, + local_thread_size, groove, square, rectangle, + angle, taper); + } + } + } + + // chamfer z=0 end if leadin is 2 or 3 + if (leadin == 2 || leadin == 3) { + difference () { + cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments); + + cylinder (r2=diameter/2, r1=diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac, + $fn=n_segments); + } + } + + // chamfer z-max end if leadin is 1 or 2. + if (leadin == 1 || leadin == 2) { + translate ([0, 0, length + 0.05 - h*h_fac1*leadfac]) { + difference () { + cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments); + cylinder (r1=tapered_diameter/2, r2=tapered_diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac, + $fn=n_segments); + } + } + } + } +} + + +// ---------------------------------------------------------------------------- +// Input units in inches. +// Note: units of measure in drawing are mm! +module english_thread (diameter=0.25, threads_per_inch=20, length=1, + internal=false, n_starts=1, thread_size=-1, groove=false, + square=false, rectangle=0, angle=30, taper=0, leadin=0, + leadfac=1.0) +{ + // Convert to mm. + mm_diameter = diameter*25.4; + mm_pitch = (1.0/threads_per_inch)*25.4; + mm_length = length*25.4; + + echo (str ("mm_diameter: ", mm_diameter)); + echo (str ("mm_pitch: ", mm_pitch)); + echo (str ("mm_length: ", mm_length)); + metric_thread (mm_diameter, mm_pitch, mm_length, internal, n_starts, + thread_size, groove, square, rectangle, angle, taper, leadin, + leadfac); +} + +// ---------------------------------------------------------------------------- +module metric_thread_turns (diameter, pitch, length, internal, n_starts, + thread_size, groove, square, rectangle, angle, + taper) +{ + // Number of turns needed. + n_turns = floor (length/pitch); + + intersection () { + + // Start one below z = 0. Gives an extra turn at each end. + for (i=[-1*n_starts : n_turns+1]) { + translate ([0, 0, i*pitch]) { + metric_thread_turn (diameter, pitch, internal, n_starts, + thread_size, groove, square, rectangle, angle, + taper, i*pitch); + } + } + + // Cut to length. + translate ([0, 0, length/2]) { + cube ([diameter*3, diameter*3, length], center=true); + } + } +} + + +// ---------------------------------------------------------------------------- +module metric_thread_turn (diameter, pitch, internal, n_starts, thread_size, + groove, square, rectangle, angle, taper, z) +{ + n_segments = segments (diameter); + fraction_circle = 1.0/n_segments; + for (i=[0 : n_segments-1]) { + rotate ([0, 0, i*360*fraction_circle]) { + translate ([0, 0, i*n_starts*pitch*fraction_circle]) { + //current_diameter = diameter - taper*(z + i*n_starts*pitch*fraction_circle); + thread_polyhedron ((diameter - taper*(z + i*n_starts*pitch*fraction_circle))/2, + pitch, internal, n_starts, thread_size, groove, + square, rectangle, angle); + } + } + } +} + + +// ---------------------------------------------------------------------------- +module thread_polyhedron (radius, pitch, internal, n_starts, thread_size, + groove, square, rectangle, angle) +{ + n_segments = segments (radius*2); + fraction_circle = 1.0/n_segments; + + local_rectangle = rectangle ? rectangle : 1; + + h = (square || rectangle) ? thread_size*local_rectangle/2 : thread_size / (2 * tan(angle)); + outer_r = radius + (internal ? h/20 : 0); // Adds internal relief. + //echo (str ("outer_r: ", outer_r)); + + // A little extra on square thread -- make sure overlaps cylinder. + h_fac1 = (square || rectangle) ? 1.1 : 0.875; + inner_r = radius - h*h_fac1; // Does NOT do Dmin_truncation - do later with + // cylinder. + + translate_y = groove ? outer_r + inner_r : 0; + reflect_x = groove ? 1 : 0; + + // Make these just slightly bigger (keep in proportion) so polyhedra will + // overlap. + x_incr_outer = (! groove ? outer_r : inner_r) * fraction_circle * 2 * PI * 1.02; + x_incr_inner = (! groove ? inner_r : outer_r) * fraction_circle * 2 * PI * 1.02; + z_incr = n_starts * pitch * fraction_circle * 1.005; + + /* + (angles x0 and x3 inner are actually 60 deg) + + /\ (x2_inner, z2_inner) [2] + / \ + (x3_inner, z3_inner) / \ + [3] \ \ + |\ \ (x2_outer, z2_outer) [6] + | \ / + | \ /| + z |[7]\/ / (x1_outer, z1_outer) [5] + | | | / + | x | |/ + | / | / (x0_outer, z0_outer) [4] + | / | / (behind: (x1_inner, z1_inner) [1] + |/ | / + y________| |/ + (r) / (x0_inner, z0_inner) [0] + + */ + + x1_outer = outer_r * fraction_circle * 2 * PI; + + z0_outer = (outer_r - inner_r) * tan(angle); + //echo (str ("z0_outer: ", z0_outer)); + + //polygon ([[inner_r, 0], [outer_r, z0_outer], + // [outer_r, 0.5*pitch], [inner_r, 0.5*pitch]]); + z1_outer = z0_outer + z_incr; + + // Give internal square threads some clearance in the z direction, too. + bottom = internal ? 0.235 : 0.25; + top = internal ? 0.765 : 0.75; + + translate ([0, translate_y, 0]) { + mirror ([reflect_x, 0, 0]) { + + if (square || rectangle) { + + // Rule for face ordering: look at polyhedron from outside: points must + // be in clockwise order. + polyhedron ( + points = [ + [-x_incr_inner/2, -inner_r, bottom*thread_size], // [0] + [x_incr_inner/2, -inner_r, bottom*thread_size + z_incr], // [1] + [x_incr_inner/2, -inner_r, top*thread_size + z_incr], // [2] + [-x_incr_inner/2, -inner_r, top*thread_size], // [3] + + [-x_incr_outer/2, -outer_r, bottom*thread_size], // [4] + [x_incr_outer/2, -outer_r, bottom*thread_size + z_incr], // [5] + [x_incr_outer/2, -outer_r, top*thread_size + z_incr], // [6] + [-x_incr_outer/2, -outer_r, top*thread_size] // [7] + ], + + faces = [ + [0, 3, 7, 4], // This-side trapezoid + + [1, 5, 6, 2], // Back-side trapezoid + + [0, 1, 2, 3], // Inner rectangle + + [4, 7, 6, 5], // Outer rectangle + + // These are not planar, so do with separate triangles. + [7, 2, 6], // Upper rectangle, bottom + [7, 3, 2], // Upper rectangle, top + + [0, 5, 1], // Lower rectangle, bottom + [0, 4, 5] // Lower rectangle, top + ] + ); + } else { + + // Rule for face ordering: look at polyhedron from outside: points must + // be in clockwise order. + polyhedron ( + points = [ + [-x_incr_inner/2, -inner_r, 0], // [0] + [x_incr_inner/2, -inner_r, z_incr], // [1] + [x_incr_inner/2, -inner_r, thread_size + z_incr], // [2] + [-x_incr_inner/2, -inner_r, thread_size], // [3] + + [-x_incr_outer/2, -outer_r, z0_outer], // [4] + [x_incr_outer/2, -outer_r, z0_outer + z_incr], // [5] + [x_incr_outer/2, -outer_r, thread_size - z0_outer + z_incr], // [6] + [-x_incr_outer/2, -outer_r, thread_size - z0_outer] // [7] + ], + + faces = [ + [0, 3, 7, 4], // This-side trapezoid + + [1, 5, 6, 2], // Back-side trapezoid + + [0, 1, 2, 3], // Inner rectangle + + [4, 7, 6, 5], // Outer rectangle + + // These are not planar, so do with separate triangles. + [7, 2, 6], // Upper rectangle, bottom + [7, 3, 2], // Upper rectangle, top + + [0, 5, 1], // Lower rectangle, bottom + [0, 4, 5] // Lower rectangle, top + ] + ); + } + } + } +}