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