Difference between revisions of "Gewinde"

From BITPlan Wiki
Jump to navigation Jump to search
Line 2: Line 2:
 
* http://www.emuge-franken-bg.com/attachments/article/97/15%20Gewindetabellen.pdf
 
* http://www.emuge-franken-bg.com/attachments/article/97/15%20Gewindetabellen.pdf
 
* https://dkprojects.net/openscad-threads/
 
* https://dkprojects.net/openscad-threads/
 +
<source lang='openscad'>
 +
/*
 +
* ISO-standard metric threads, following this specification:
 +
*          http://en.wikipedia.org/wiki/ISO_metric_screw_thread
 +
*
 +
* Copyright 2020 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 <http://www.gnu.org/licenses/>.
 +
*
 +
* Version 2.5.  2020-04-11  Leadin option works for internal threads.
 +
* Version 2.4.  2019-07-14  Add test option - do not render threads.
 +
* 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 <a2intl@gmail.com>.)
 +
* 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.
 +
//
 +
// Broom Stick
 +
metric_thread (diameter=23.5, pitch=2.5, length=15,taper=0.2);
 +
th=36;
 +
tr=23.7/2;
 +
tt=1.5;
 +
translate([0,0,-th/2]) difference() {
 +
    cylinder(h=th,r=tr+tt,center=true);
 +
    cylinder(h=th+0.1,r=tr,center=true);
 +
}
 +
 +
// 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, max (ceil (diameter*6), 25));
 +
 +
 +
// ----------------------------------------------------------------------------
 +
// 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 ()).  Default: false.
 +
// n_starts -    Number of thread starts (e.g., DNA, a "double helix," has
 +
//              n_starts=2).  See wikipedia Screw_thread.  Default: 1.
 +
// thread_size - (non-standard) axial width of a single thread "V" - independent
 +
//              of pitch.  Default: same as pitch.
 +
// groove      - (non-standard) true = subtract inverted "V" from cylinder
 +
//                (rather thanadd protruding "V" to cylinder).  Default: false.
 +
// square      - true = square threads (per
 +
//              https://en.wikipedia.org/wiki/Square_thread_form).  Default:
 +
//              false.
 +
// rectangle  - (non-standard) "Rectangular" thread - ratio depth/(axial) width
 +
//              Default: 0 (standard "v" thread).
 +
// 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.  Default: 0 (no taper).
 +
// 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 length (default: 1.0 = 1/2 thread).
 +
// test        - true = do not render threads (just draw "blank" cylinder).
 +
//              Default: false (draw threads).
 +
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, test=false)
 +
{
 +
  // 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 = (test && ! internal) ? 0 : (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) {
 +
            if (! test) {
 +
              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) {
 +
              if (! test) {
 +
                  metric_thread_turns (diameter, pitch, length, internal, n_starts,
 +
                                      local_thread_size, groove, square, rectangle,
 +
                                      angle, taper);
 +
              }
 +
            }
 +
        }
 +
 +
        // Internal thread lead-in: take away from external solid.
 +
        if (internal) {
 +
 +
            // "Negative chamfer" z=0 end if leadin is 2 or 3.
 +
            if (leadin == 2 || leadin == 3) {
 +
              cylinder (r1=diameter/2, r2=diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,
 +
                        $fn=n_segments);
 +
            }
 +
 +
            // "Negative 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]) {
 +
                  cylinder (r1=tapered_diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,
 +
                            r2=tapered_diameter/2,
 +
                            $fn=n_segments);
 +
              }
 +
            }
 +
        }
 +
      }
 +
 +
      if (! internal) {
 +
 +
        // 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, test=false)
 +
{
 +
  // 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, test);
 +
}
 +
 +
// ----------------------------------------------------------------------------
 +
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
 +
                        ]
 +
            );
 +
        }
 +
      }
 +
  }
 +
}
 +
</source>
 
[[Category:3DPrint]]
 
[[Category:3DPrint]]

Revision as of 14:21, 11 February 2021

/*
 * ISO-standard metric threads, following this specification:
 *          http://en.wikipedia.org/wiki/ISO_metric_screw_thread
 *
 * Copyright 2020 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 <http://www.gnu.org/licenses/>.
 *
 * Version 2.5.  2020-04-11  Leadin option works for internal threads.
 * Version 2.4.  2019-07-14  Add test option - do not render threads.
 * 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 <a2intl@gmail.com>.)
 * 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.
//
// Broom Stick
metric_thread (diameter=23.5, pitch=2.5, length=15,taper=0.2);
th=36;
tr=23.7/2;
tt=1.5;
translate([0,0,-th/2]) difference() {
    cylinder(h=th,r=tr+tt,center=true);
    cylinder(h=th+0.1,r=tr,center=true);
}

// 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, max (ceil (diameter*6), 25));


// ----------------------------------------------------------------------------
// 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 ()).  Default: false.
// n_starts -    Number of thread starts (e.g., DNA, a "double helix," has
//               n_starts=2).  See wikipedia Screw_thread.  Default: 1.
// thread_size - (non-standard) axial width of a single thread "V" - independent
//               of pitch.  Default: same as pitch.
// groove      - (non-standard) true = subtract inverted "V" from cylinder
//                (rather thanadd protruding "V" to cylinder).  Default: false.
// square      - true = square threads (per
//               https://en.wikipedia.org/wiki/Square_thread_form).  Default:
//               false.
// rectangle   - (non-standard) "Rectangular" thread - ratio depth/(axial) width
//               Default: 0 (standard "v" thread).
// 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.  Default: 0 (no taper).
// 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 length (default: 1.0 = 1/2 thread).
// test        - true = do not render threads (just draw "blank" cylinder).
//               Default: false (draw threads).
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, test=false)
{
   // 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 = (test && ! internal) ? 0 : (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) {
            if (! test) {
               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) {
               if (! test) {
                  metric_thread_turns (diameter, pitch, length, internal, n_starts,
                                       local_thread_size, groove, square, rectangle,
                                       angle, taper);
               }
            }
         }

         // Internal thread lead-in: take away from external solid.
         if (internal) {

            // "Negative chamfer" z=0 end if leadin is 2 or 3.
            if (leadin == 2 || leadin == 3) {
               cylinder (r1=diameter/2, r2=diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,
                         $fn=n_segments);
            }

            // "Negative 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]) {
                  cylinder (r1=tapered_diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,
                            r2=tapered_diameter/2,
                            $fn=n_segments);
               }
            }
         }
      }

      if (! internal) {

         // 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, test=false)
{
   // 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, test);
}

// ----------------------------------------------------------------------------
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
                        ]
            );
         }
      }
   }
}
Retrieved from "https://wiki.bitplan.com/index.php?title=Gewinde&oldid=13791"