threads.scad

   1 /*\r
   2  * ISO-standard metric threads, following this specification:\r
   3  *          http://en.wikipedia.org/wiki/ISO_metric_screw_thread\r
   4  *\r
   5  * Copyright 2020 Dan Kirshner - dan_kirshner@yahoo.com\r
   6  * This program is free software: you can redistribute it and/or modify\r
   7  * it under the terms of the GNU General Public License as published by\r
   8  * the Free Software Foundation, either version 3 of the License, or\r
   9  * (at your option) any later version.\r
  10  *\r
  11  * This program is distributed in the hope that it will be useful,\r
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14  * GNU General Public License for more details.\r
  15  *\r
  16  * See <http://www.gnu.org/licenses/>.\r
  17  *\r
  18  * Version 2.4.  2019-07-14  Add test option - do not render threads.\r
  19  * Version 2.3.  2017-08-31  Default for leadin: 0 (best for internal threads).\r
  20  * Version 2.2.  2017-01-01  Correction for angle; leadfac option.  (Thanks to\r
  21  *                           Andrew Allen <a2intl@gmail.com>.)\r
  22  * Version 2.1.  2016-12-04  Chamfer bottom end (low-z); leadin option.\r
  23  * Version 2.0.  2016-11-05  Backwards compatibility (earlier OpenSCAD) fixes.\r
  24  * Version 1.9.  2016-07-03  Option: tapered.\r
  25  * Version 1.8.  2016-01-08  Option: (non-standard) angle.\r
  26  * Version 1.7.  2015-11-28  Larger x-increment - for small-diameters.\r
  27  * Version 1.6.  2015-09-01  Options: square threads, rectangular threads.\r
  28  * Version 1.5.  2015-06-12  Options: thread_size, groove.\r
  29  * Version 1.4.  2014-10-17  Use "faces" instead of "triangles" for polyhedron\r
  30  * Version 1.3.  2013-12-01  Correct loop over turns -- don't have early cut-off\r
  31  * Version 1.2.  2012-09-09  Use discrete polyhedra rather than linear_extrude ()\r
  32  * Version 1.1.  2012-09-07  Corrected to right-hand threads!\r
  33  */\r
  34 \r
  35 // Examples.\r
  36 //\r
  37 // Standard M8 x 1.\r
  38 // metric_thread (diameter=8, pitch=1, length=4);\r
  39 \r
  40 // Square thread.\r
  41 // metric_thread (diameter=8, pitch=1, length=4, square=true);\r
  42 \r
  43 // Non-standard: long pitch, same thread size.\r
  44 //metric_thread (diameter=8, pitch=4, length=4, thread_size=1, groove=true);\r
  45 \r
  46 // Non-standard: 20 mm diameter, long pitch, square "trough" width 3 mm,\r
  47 // depth 1 mm.\r
  48 //metric_thread (diameter=20, pitch=8, length=16, square=true, thread_size=6,\r
  49 //               groove=true, rectangle=0.333);\r
  50 \r
  51 // English: 1/4 x 20.\r
  52 //english_thread (diameter=1/4, threads_per_inch=20, length=1);\r
  53 \r
  54 // Tapered.  Example -- pipe size 3/4" -- per:\r
  55 // http://www.engineeringtoolbox.com/npt-national-pipe-taper-threads-d_750.html\r
  56 // english_thread (diameter=1.05, threads_per_inch=14, length=3/4, taper=1/16);\r
  57 \r
  58 // Thread for mounting on Rohloff hub.\r
  59 //difference () {\r
  60 //   cylinder (r=20, h=10, $fn=100);\r
  61 //\r
  62 //   metric_thread (diameter=34, pitch=1, length=10, internal=true, n_starts=6);\r
  63 //}\r
  64 \r
  65 \r
  66 // ----------------------------------------------------------------------------\r
  67 function segments (diameter) = min (50, max (ceil (diameter*6), 25));\r
  68 \r
  69 \r
  70 // ----------------------------------------------------------------------------\r
  71 // diameter -    outside diameter of threads in mm. Default: 8.\r
  72 // pitch    -    thread axial "travel" per turn in mm.  Default: 1.\r
  73 // length   -    overall axial length of thread in mm.  Default: 1.\r
  74 // internal -    true = clearances for internal thread (e.g., a nut).\r
  75 //               false = clearances for external thread (e.g., a bolt).\r
  76 //               (Internal threads should be "cut out" from a solid using\r
  77 //               difference ()).  Default: false.\r
  78 // n_starts -    Number of thread starts (e.g., DNA, a "double helix," has\r
  79 //               n_starts=2).  See wikipedia Screw_thread.  Default: 1.\r
  80 // thread_size - (non-standard) axial width of a single thread "V" - independent\r
  81 //               of pitch.  Default: same as pitch.\r
  82 // groove      - (non-standard) true = subtract inverted "V" from cylinder\r
  83 //                (rather thanadd protruding "V" to cylinder).  Default: false.\r
  84 // square      - true = square threads (per\r
  85 //               https://en.wikipedia.org/wiki/Square_thread_form).  Default:\r
  86 //               false.\r
  87 // rectangle   - (non-standard) "Rectangular" thread - ratio depth/(axial) width\r
  88 //               Default: 0 (standard "v" thread).\r
  89 // angle       - (non-standard) angle (deg) of thread side from perpendicular to\r
  90 //               axis (default = standard = 30 degrees).\r
  91 // taper       - diameter change per length (National Pipe Thread/ANSI B1.20.1\r
  92 //               is 1" diameter per 16" length). Taper decreases from 'diameter'\r
  93 //               as z increases.  Default: 0 (no taper).\r
  94 // leadin      - 0 (default): no chamfer; 1: chamfer (45 degree) at max-z end;\r
  95 //               2: chamfer at both ends, 3: chamfer at z=0 end.\r
  96 // leadfac     - scale of leadin chamfer (default: 1.0 = 1/2 thread).\r
  97 // test        - true = do not render threads (just draw "blank" cylinder).\r
  98 //               Default: false (draw threads).\r
  99 module metric_thread (diameter=8, pitch=1, length=1, internal=false, n_starts=1,\r
 100                       thread_size=-1, groove=false, square=false, rectangle=0,\r
 101                       angle=30, taper=0, leadin=0, leadfac=1.0, test=false)\r
 102 {\r
 103    // thread_size: size of thread "V" different than travel per turn (pitch).\r
 104    // Default: same as pitch.\r
 105    local_thread_size = thread_size == -1 ? pitch : thread_size;\r
 106    local_rectangle = rectangle ? rectangle : 1;\r
 107 \r
 108    n_segments = segments (diameter);\r
 109    h = (test && ! internal) ? 0 : (square || rectangle) ? local_thread_size*local_rectangle/2 : local_thread_size / (2 * tan(angle));\r
 110 \r
 111    h_fac1 = (square || rectangle) ? 0.90 : 0.625;\r
 112 \r
 113    // External thread includes additional relief.\r
 114    h_fac2 = (square || rectangle) ? 0.95 : 5.3/8;\r
 115 \r
 116    tapered_diameter = diameter - length*taper;\r
 117 \r
 118    difference () {\r
 119       union () {\r
 120          if (! groove) {\r
 121             if (! test) {\r
 122                metric_thread_turns (diameter, pitch, length, internal, n_starts,\r
 123                                     local_thread_size, groove, square, rectangle, angle,\r
 124                                     taper);\r
 125             }\r
 126          }\r
 127 \r
 128          difference () {\r
 129 \r
 130             // Solid center, including Dmin truncation.\r
 131             if (groove) {\r
 132                cylinder (r1=diameter/2, r2=tapered_diameter/2,\r
 133                          h=length, $fn=n_segments);\r
 134             } else if (internal) {\r
 135                cylinder (r1=diameter/2 - h*h_fac1, r2=tapered_diameter/2 - h*h_fac1,\r
 136                          h=length, $fn=n_segments);\r
 137             } else {\r
 138 \r
 139                // External thread.\r
 140                cylinder (r1=diameter/2 - h*h_fac2, r2=tapered_diameter/2 - h*h_fac2,\r
 141                          h=length, $fn=n_segments);\r
 142             }\r
 143 \r
 144             if (groove) {\r
 145                if (! test) {\r
 146                   metric_thread_turns (diameter, pitch, length, internal, n_starts,\r
 147                                        local_thread_size, groove, square, rectangle,\r
 148                                        angle, taper);\r
 149                }\r
 150             }\r
 151          }\r
 152       }\r
 153 \r
 154       // chamfer z=0 end if leadin is 2 or 3\r
 155       if (leadin == 2 || leadin == 3) {\r
 156          difference () {\r
 157             cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments);\r
 158 \r
 159             cylinder (r2=diameter/2, r1=diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,\r
 160                       $fn=n_segments);\r
 161          }\r
 162       }\r
 163 \r
 164       // chamfer z-max end if leadin is 1 or 2.\r
 165       if (leadin == 1 || leadin == 2) {\r
 166          translate ([0, 0, length + 0.05 - h*h_fac1*leadfac]) {\r
 167             difference () {\r
 168                cylinder (r=diameter/2 + 1, h=h*h_fac1*leadfac, $fn=n_segments);\r
 169                cylinder (r1=tapered_diameter/2, r2=tapered_diameter/2 - h*h_fac1*leadfac, h=h*h_fac1*leadfac,\r
 170                          $fn=n_segments);\r
 171             }\r
 172          }\r
 173       }\r
 174    }\r
 175 }\r
 176 \r
 177 \r
 178 // ----------------------------------------------------------------------------\r
 179 // Input units in inches.\r
 180 // Note: units of measure in drawing are mm!\r
 181 module english_thread (diameter=0.25, threads_per_inch=20, length=1,\r
 182                       internal=false, n_starts=1, thread_size=-1, groove=false,\r
 183                       square=false, rectangle=0, angle=30, taper=0, leadin=0,\r
 184                       leadfac=1.0, test=false)\r
 185 {\r
 186    // Convert to mm.\r
 187    mm_diameter = diameter*25.4;\r
 188    mm_pitch = (1.0/threads_per_inch)*25.4;\r
 189    mm_length = length*25.4;\r
 190 \r
 191    echo (str ("mm_diameter: ", mm_diameter));\r
 192    echo (str ("mm_pitch: ", mm_pitch));\r
 193    echo (str ("mm_length: ", mm_length));\r
 194    metric_thread (mm_diameter, mm_pitch, mm_length, internal, n_starts,\r
 195                   thread_size, groove, square, rectangle, angle, taper, leadin,\r
 196                   leadfac, test);\r
 197 }\r
 198 \r
 199 // ----------------------------------------------------------------------------\r
 200 module metric_thread_turns (diameter, pitch, length, internal, n_starts,\r
 201                             thread_size, groove, square, rectangle, angle,\r
 202                             taper)\r
 203 {\r
 204    // Number of turns needed.\r
 205    n_turns = floor (length/pitch);\r
 206 \r
 207    intersection () {\r
 208 \r
 209       // Start one below z = 0.  Gives an extra turn at each end.\r
 210       for (i=[-1*n_starts : n_turns+1]) {\r
 211          translate ([0, 0, i*pitch]) {\r
 212             metric_thread_turn (diameter, pitch, internal, n_starts,\r
 213                                 thread_size, groove, square, rectangle, angle,\r
 214                                 taper, i*pitch);\r
 215          }\r
 216       }\r
 217 \r
 218       // Cut to length.\r
 219       translate ([0, 0, length/2]) {\r
 220          cube ([diameter*3, diameter*3, length], center=true);\r
 221       }\r
 222    }\r
 223 }\r
 224 \r
 225 \r
 226 // ----------------------------------------------------------------------------\r
 227 module metric_thread_turn (diameter, pitch, internal, n_starts, thread_size,\r
 228                            groove, square, rectangle, angle, taper, z)\r
 229 {\r
 230    n_segments = segments (diameter);\r
 231    fraction_circle = 1.0/n_segments;\r
 232    for (i=[0 : n_segments-1]) {\r
 233       rotate ([0, 0, i*360*fraction_circle]) {\r
 234          translate ([0, 0, i*n_starts*pitch*fraction_circle]) {\r
 235             //current_diameter = diameter - taper*(z + i*n_starts*pitch*fraction_circle);\r
 236             thread_polyhedron ((diameter - taper*(z + i*n_starts*pitch*fraction_circle))/2,\r
 237                                pitch, internal, n_starts, thread_size, groove,\r
 238                                square, rectangle, angle);\r
 239          }\r
 240       }\r
 241    }\r
 242 }\r
 243 \r
 244 \r
 245 // ----------------------------------------------------------------------------\r
 246 module thread_polyhedron (radius, pitch, internal, n_starts, thread_size,\r
 247                           groove, square, rectangle, angle)\r
 248 {\r
 249    n_segments = segments (radius*2);\r
 250    fraction_circle = 1.0/n_segments;\r
 251 \r
 252    local_rectangle = rectangle ? rectangle : 1;\r
 253 \r
 254    h = (square || rectangle) ? thread_size*local_rectangle/2 : thread_size / (2 * tan(angle));\r
 255    outer_r = radius + (internal ? h/20 : 0); // Adds internal relief.\r
 256    //echo (str ("outer_r: ", outer_r));\r
 257 \r
 258    // A little extra on square thread -- make sure overlaps cylinder.\r
 259    h_fac1 = (square || rectangle) ? 1.1 : 0.875;\r
 260    inner_r = radius - h*h_fac1; // Does NOT do Dmin_truncation - do later with\r
 261                                 // cylinder.\r
 262 \r
 263    translate_y = groove ? outer_r + inner_r : 0;\r
 264    reflect_x   = groove ? 1 : 0;\r
 265 \r
 266    // Make these just slightly bigger (keep in proportion) so polyhedra will\r
 267    // overlap.\r
 268    x_incr_outer = (! groove ? outer_r : inner_r) * fraction_circle * 2 * PI * 1.02;\r
 269    x_incr_inner = (! groove ? inner_r : outer_r) * fraction_circle * 2 * PI * 1.02;\r
 270    z_incr = n_starts * pitch * fraction_circle * 1.005;\r
 271 \r
 272    /*\r
 273     (angles x0 and x3 inner are actually 60 deg)\r
 274 \r
 275                           /\  (x2_inner, z2_inner) [2]\r
 276                          /  \\r
 277    (x3_inner, z3_inner) /    \\r
 278                   [3]   \     \\r
 279                         |\     \ (x2_outer, z2_outer) [6]\r
 280                         | \    /\r
 281                         |  \  /|\r
 282              z          |[7]\/ / (x1_outer, z1_outer) [5]\r
 283              |          |   | /\r
 284              |   x      |   |/\r
 285              |  /       |   / (x0_outer, z0_outer) [4]\r
 286              | /        |  /     (behind: (x1_inner, z1_inner) [1]\r
 287              |/         | /\r
 288     y________|          |/\r
 289    (r)                  / (x0_inner, z0_inner) [0]\r
 290 \r
 291    */\r
 292 \r
 293    x1_outer = outer_r * fraction_circle * 2 * PI;\r
 294 \r
 295    z0_outer = (outer_r - inner_r) * tan(angle);\r
 296    //echo (str ("z0_outer: ", z0_outer));\r
 297 \r
 298    //polygon ([[inner_r, 0], [outer_r, z0_outer],\r
 299    //        [outer_r, 0.5*pitch], [inner_r, 0.5*pitch]]);\r
 300    z1_outer = z0_outer + z_incr;\r
 301 \r
 302    // Give internal square threads some clearance in the z direction, too.\r
 303    bottom = internal ? 0.235 : 0.25;\r
 304    top    = internal ? 0.765 : 0.75;\r
 305 \r
 306    translate ([0, translate_y, 0]) {\r
 307       mirror ([reflect_x, 0, 0]) {\r
 308 \r
 309          if (square || rectangle) {\r
 310 \r
 311             // Rule for face ordering: look at polyhedron from outside: points must\r
 312             // be in clockwise order.\r
 313             polyhedron (\r
 314                points = [\r
 315                          [-x_incr_inner/2, -inner_r, bottom*thread_size],         // [0]\r
 316                          [x_incr_inner/2, -inner_r, bottom*thread_size + z_incr], // [1]\r
 317                          [x_incr_inner/2, -inner_r, top*thread_size + z_incr],    // [2]\r
 318                          [-x_incr_inner/2, -inner_r, top*thread_size],            // [3]\r
 319 \r
 320                          [-x_incr_outer/2, -outer_r, bottom*thread_size],         // [4]\r
 321                          [x_incr_outer/2, -outer_r, bottom*thread_size + z_incr], // [5]\r
 322                          [x_incr_outer/2, -outer_r, top*thread_size + z_incr],    // [6]\r
 323                          [-x_incr_outer/2, -outer_r, top*thread_size]             // [7]\r
 324                         ],\r
 325 \r
 326                faces = [\r
 327                          [0, 3, 7, 4],  // This-side trapezoid\r
 328 \r
 329                          [1, 5, 6, 2],  // Back-side trapezoid\r
 330 \r
 331                          [0, 1, 2, 3],  // Inner rectangle\r
 332 \r
 333                          [4, 7, 6, 5],  // Outer rectangle\r
 334 \r
 335                          // These are not planar, so do with separate triangles.\r
 336                          [7, 2, 6],     // Upper rectangle, bottom\r
 337                          [7, 3, 2],     // Upper rectangle, top\r
 338 \r
 339                          [0, 5, 1],     // Lower rectangle, bottom\r
 340                          [0, 4, 5]      // Lower rectangle, top\r
 341                         ]\r
 342             );\r
 343          } else {\r
 344 \r
 345             // Rule for face ordering: look at polyhedron from outside: points must\r
 346             // be in clockwise order.\r
 347             polyhedron (\r
 348                points = [\r
 349                          [-x_incr_inner/2, -inner_r, 0],                        // [0]\r
 350                          [x_incr_inner/2, -inner_r, z_incr],                    // [1]\r
 351                          [x_incr_inner/2, -inner_r, thread_size + z_incr],      // [2]\r
 352                          [-x_incr_inner/2, -inner_r, thread_size],              // [3]\r
 353 \r
 354                          [-x_incr_outer/2, -outer_r, z0_outer],                 // [4]\r
 355                          [x_incr_outer/2, -outer_r, z0_outer + z_incr],         // [5]\r
 356                          [x_incr_outer/2, -outer_r, thread_size - z0_outer + z_incr], // [6]\r
 357                          [-x_incr_outer/2, -outer_r, thread_size - z0_outer]    // [7]\r
 358                         ],\r
 359 \r
 360                faces = [\r
 361                          [0, 3, 7, 4],  // This-side trapezoid\r
 362 \r
 363                          [1, 5, 6, 2],  // Back-side trapezoid\r
 364 \r
 365                          [0, 1, 2, 3],  // Inner rectangle\r
 366 \r
 367                          [4, 7, 6, 5],  // Outer rectangle\r
 368 \r
 369                          // These are not planar, so do with separate triangles.\r
 370                          [7, 2, 6],     // Upper rectangle, bottom\r
 371                          [7, 3, 2],     // Upper rectangle, top\r
 372 \r
 373                          [0, 5, 1],     // Lower rectangle, bottom\r
 374                          [0, 4, 5]      // Lower rectangle, top\r
 375                         ]\r
 376             );\r
 377          }\r
 378       }\r
 379    }\r
 380 }\r
 381 \r
 382 \r