First proper version of BottleCap adapter

BottleCap/CapAdapter.scad

@@ -0,0 +1,93 @@
+// Soda bottle cap Co2 dispensing adapter
+// Made in July 2017 by xythobuz@xythobuz.de
+// Licensed under CC-BY-SA-NC
+
+// Necks & Caps for DIY projects
+// Xavan June 2016
+// https://www.thingiverse.com/thing:1654620
+// Minimum Radius: ~15mm
+// License: CC-BY
+include <NecksCaps.scad>;
+
+// cap-type specific
+diameter = 30.4;
+wall_height = 1.5;
+
+// Universal Hose Coupler & Funnel Maker
+// Mooncactus January 2013
+// https://www.thingiverse.com/thing:44850
+// License: CC-BY-SA
+include <HoseAdapter.scad>;
+
+channel_diameter = 4;
+wall_size = 4;
+pipe_diameter = 4;
+pipe_wall_size = 1.2;
+pipe_height = 20;
+
+hose_offset = 6.5;
+
+thread_diameter = 5;
+thread_pitch = 0.8;
+thread_height = 15;
+
+// OpenSCAD Threads
+// http://dkprojects.net/openscad-threads/
+include <threads.scad>;
+
+module cap() {
+    rotate([180, 0, 0])
+        //38mm3start (); // diameter: 42, radius: 21
+        28PCO1810 (); // diameter: 30.43, radius: 15.215
+        //28PCO1881 (); // diameter: 30.4, radius: 15.2
+    
+    cylinder(d = diameter, h = channel_diameter + (2 * wall_size));
+}
+
+module adapter() {
+    difference() {
+        cap();
+        
+        // gas input hole
+        translate([-diameter / 2 - 1, 0, (channel_diameter / 2) + wall_size])
+            rotate([0, 90, 0])
+            cylinder(d = channel_diameter, h = diameter / 2 - wall_size + 1);
+        
+        // liquid output hole
+        translate([wall_size, 0, (channel_diameter / 2) + wall_size])
+            rotate([0, 90, 0])
+            cylinder(d = channel_diameter, h = diameter / 2 - wall_size + 1);
+        
+        // gas input outlet
+        translate([-wall_size, 0, wall_size + channel_diameter - 20])
+            cylinder(d = channel_diameter, h = 20);
+        
+        // liquid output inlet
+        translate([wall_size, 0, wall_size + channel_diameter - 20])
+            cylinder(d = channel_diameter, h = 20);
+    }
+    
+    // liquit output inlet
+    translate([wall_size, 0, -pipe_height - wall_height])
+    difference() {
+        cylinder(d = pipe_diameter + (2 * pipe_wall_size), h = pipe_height);
+        
+        translate([0, 0, -1])
+            cylinder(d = pipe_diameter, h = pipe_height + 2);
+        
+        translate([0, 0, -1])
+            metric_thread(thread_diameter, thread_pitch, thread_height + 1, internal = true);
+    }
+    
+    translate([-diameter - hose_offset, 0, 6])
+        rotate([0, 90, 0])
+        tube_adapter();
+    
+    translate([diameter + hose_offset, 0, 6])
+        rotate([0, -90, 0])
+        tube_adapter();
+}
+
+translate([0, 0, channel_diameter + (2 * wall_size)])
+rotate([180, 0, 0])
+    adapter();

BottleCap/HoseAdapter.scad

@@ -0,0 +1,139 @@
+// preview[view:north east, tilt:top diagonal]
+
+// Top cone base diameter. Usually equal or slightly bigger than the top diameter.
+cone2_max=12.0;
+
+// Top cone top diameter. Usually equal or slightly smaller than the base radius
+cone2_min=12.0;
+
+// Height of the top cone
+cone2_height=2;
+
+// Wall thickness of the top cone
+cone2_wall=4.0;
+
+// Top cone protuding width of barb-like outer rings to prevent the hose from slipping (zero to disable)
+cone2_barb_width=0;
+
+
+// Bottom cone base diameter (the outside of the lower cone. Usually equal or slightly smaller than the top, unless you want to make a funnel)
+cone1_min=6.8;
+
+// Bottom top diameter (usually equal or slightly bigger than the base radius, unless you want to make a funnel)
+cone1_max=8.6;
+
+// Height of the bottom cone
+cone1_height=18;
+
+// Wall thickness of the bottom cone
+cone1_wall=1.5;
+
+// Bottom cone protuding width of barb-like outer rings to prevent the hose from slipping (zero to disable)
+cone1_barb_width=0.8;
+
+
+// Junction height: how tall is the connection between the two cones. Make sure it is thick enough so as to avoid excessively thin walls and/or steep inner overhang. Twice the wall thickness is a good starting value.
+join_height=3;
+
+// Barb flatness ratio (advanced). Sets barb height as a factor of barb size. Eg. 1.0 means a 1:1 x/y aspect ratio (aka 45°), and 2.0 makes a flatter barb.
+barb_flatness_ratio=2;
+
+// Barb spacing ratio (advanced). Sets barb spacing as a factor of barb height. So 0 means adjacent barbs, and 1 give an identical flat space as the barbs themselves.
+barb_spacing_ratio=2;
+
+// Barb symetry ratio (advanced). Avoid overhang by using a strictly positive value (easier print). Symetrical barbs correspond to 0.5. Negative values give concave barbs, and makes sense only for the lower cone. Values higher than 0.5 lead to reversed barbing (probably useless). -0.2 to 1.2 are good values
+barb_skew_ratio=0.15;
+
+// This is only useful to double-check the objet shape and walls before printing
+check_guts=0; // [0:no,1:yes]
+
+//
+// universal_hose_adapter.scad
+//
+// By Jérémie FRANCOIS / MoonCactus / contact@tecrd.com
+//
+// Check the webservice on http://www.tecrd.com/page/liens/universal_hose_adapter (temporary URL)
+// Remixed for the Thingiverse customizer (less usable imo for now...)
+//
+
+
+
+// $fa=10;		// how fine the curved objets are (max angle between broken parts)
+tol=1*0.05;	// tolerance (mostly useful for openscad preview)
+
+function xpos(dmin, dmax, height, hpos) = ( dmin+(dmax-dmin)*hpos/height )/2;
+
+module hollow_cone(dmin, dmax, height, wall, barb_width) // TODO: spokes
+{
+	if(dmin>0 && dmax>0 && height>0)
+	{
+		// Hollow cone body
+		difference()
+		{
+			cylinder(r1=dmin/2, r2=dmax/2, h=height);
+			if(wall>0)
+				translate([0,0,-tol])
+					cylinder(r1= dmin/2-wall, r2= dmax/2-wall, h=height+2*tol);
+		}
+		// Babed-like rings
+		if(barb_width>0 && barb_flatness_ratio!=0)
+		{
+			for(bs=[barb_width*barb_flatness_ratio : 1 : barb_width*barb_flatness_ratio]) // this is just to simulate a "local" variable... :(
+			{
+				for(hpos=[
+					bs/2
+					: barb_width * barb_flatness_ratio * (1 + barb_spacing_ratio)
+					: height - bs/2]
+				)
+				{
+					translate([0,0,hpos])
+					rotate_extrude()
+						polygon( points=[
+							[xpos(dmin,dmax,height,hpos)-tol, 0],
+							[xpos(dmin,dmax,height,hpos + bs*(1-barb_skew_ratio)) + barb_width, bs * (1-barb_skew_ratio)],
+							[xpos(dmin,dmax,height,hpos + bs)-tol, bs],
+						] );
+				}
+			}
+		}
+	}
+}
+
+module tube_adapter() {
+	difference()
+	{
+		union()
+		{
+			//color([1,0,0])
+			hollow_cone(cone1_min, cone1_max, cone1_height, cone1_wall, cone1_barb_width);
+
+			//color([0,0,1])
+				translate([0,0,cone1_height+join_height+cone2_height])
+					rotate([180,0,0])
+						hollow_cone(cone2_min, cone2_max, cone2_height, cone2_wall, cone2_barb_width);
+
+			// intermediate section
+			if(join_height>0)
+			{
+				//color([0,1,0])
+				translate([0,0,cone1_height])
+				rotate_extrude()
+					polygon( points=[
+						[ cone1_max/2-cone1_wall, 0],
+						[ cone1_max/2, 0],
+						[ max(cone1_max,cone2_max)/2, join_height/2],
+						[ cone2_max/2, join_height],
+						[ cone2_max/2-cone2_wall, join_height],
+						[ min(cone1_max/2-cone1_wall,cone2_max/2-cone2_wall), join_height/2],
+					] );
+			}
+		}
+
+		if(check_guts!=0)
+		{
+			// I failed to understand how/if the customizer default view worked, so I split the part twice at opposite places... :p
+			scale([0.5,1,1]) rotate([0,0,45]) translate([0,0,-tol]) cube([100,100,100]);
+			//scale([0.5,1,1]) rotate([0,0,180+45]) translate([0,0,-tol]) cube([100,100,100]);
+		}
+	}
+}

BottleCap/NecksCaps.scad

@@ -0,0 +1,218 @@
+// Necks & Caps for DIY projects
+// Xavan June 2016
+//https://www.thingiverse.com/thing:1654620
+
+
+//***** Bouchons / Caps *****
+//38mm3start ();
+//28PCO1810 ();
+//28PCO1881 ();
+//TestMotif ();
+
+//***** Goulots / Necks *****
+//N38mm3start ();
+//N28PCO1810 ();
+//N28PCO1881 ();
+
+//TestMotif (); // threadform test
+
+
+//***** ************   *****
+$fn=64;
+
+module screw (Sta,End,Pas,Ray){ // filet - thread
+Ste=5;//pas angulaire
+//Pas mm/360°
+//Ray rayon centre du motif
+//Sta angle de départ
+//End angle de fin   
+for (Rz = [Sta:Ste:End]) {//Rz rotation Z
+    a= Rz>Sta ? 1: 0;
+    b= Rz<End ? 1: 0;
+Ap=Pas*(Rz-Sta)/360;//Ap avancement du pas en Z
+Ap1=Ap+Pas*Ste/360;//Ap1 avancement du pas en Z+1
+hull (){
+rotate ([0,0,Rz])translate([Ray,0,Ap])motif (a);
+rotate ([0,0,Rz+Ste]) translate([Ray,0,Ap1])motif (b);
+}
+}
+}
+  
+
+module motif (a){//trapeze - threadform
+//$Z1 largeur base
+//$Z2 largeur sommet
+//$X1 distance base sommet  
+// dans le plan x-z
+cube([0.1,0.1,$Z1],true);
+translate([-a*$X1,0,0])cube([0.1,0.1,$Z2],true);
+} 
+
+
+module bouchon (Rb,Hb,Ep,Nc){//cap
+//Rb ray bouchon interieur
+//Hb haut bouchon interieur
+//Eb epais bouchon
+//Nc nb crans
+
+difference(){
+   
+translate ([0,0,(Hb+Ep)/2])cylinder(Hb+Ep, r=Rb+Ep, center=true);
+        translate ([0,0,(Ep)/2])
+        
+translate ([0,0,Hb/2+Ep])cylinder(Hb, r=Rb, center=true);  
+   
+    }
+    // crans
+for (Rz = [0:360/Nc:360]) {
+rotate ([0,0,Rz])translate ([Rb+Ep,0,Hb/2+Ep])cube([Ep/2,Ep,Hb],true);
+}
+    }
+ 
+ module goulot (Rb,Hb,Ep){//neck
+//Rb ray goulot exterieur
+//Hb haut goulot 
+//Eb epais goulot
+
+difference(){
+ union(){  
+hull(){//exterieur
+    translate ([0,0,Hb/2])cylinder(Hb, r=Rb-Ep/3, center=true);translate ([0,0,(Hb-Ep/3)/2])cylinder(Hb-Ep/3, r=Rb, center=true);
+} 
+     hull(){//base
+    translate ([0,0,Ep/4])cylinder(Ep/2, r=Rb+Ep, center=true);
+    translate ([0,0,Ep/2])cylinder(Ep, r=Rb, center=true); 
+       }  
+}     
+translate ([0,0,Hb/2])cylinder(Hb, r=Rb-Ep, center=true); //interieur 
+   
+    }
+    }    
+
+module TestMotif (){
+$Z1=2;//largeur base
+$Z2=1;//largeur sommet
+$X1=1;//distance base sommet (std 1.0)
+hull(){
+motif (1);
+}
+}
+
+//****************BOUCHONS-CAPS*********************
+module 38mm3start () {
+jeu=0.5;//jeu
+Ray=38/2+jeu;//rayon centre du motif
+Pas=9;//pas de vis
+Ep=1.5;//épaisseur bouchon
+Ej=0;//épaisseur joint gasket
+Dd=1.5+Ej+(Pas/3)/2;//distance demarrage depuis la base
+Df=2;//distance fin
+    
+$Z1=2;//largeur base
+$Z2=1;//largeur sommet
+$X1=1;//distance base sommet (std 1.0)
+
+translate([0,0,Ep+Dd]){
+screw (0,180,Pas,Ray);
+screw (120,300,Pas,Ray);
+screw (240,420,Pas,Ray);
+}
+bouchon (Ray,Dd+Pas/2+Df,Ep,32);
+}
+
+module 28PCO1810 () {
+jeu=0.5;//jeu
+Ray=27.43/2+jeu;//rayon centre du motif
+Pas=3.18;//pas de vis
+Ep=1;//épaisseur bouchon
+Ej=0;//épaisseur joint gasket
+Dd=1.5+Ej+Pas/2;//distance demarrage depuis la base
+Df=2;//distance fin
+    
+$Z1=2;//largeur base
+$Z2=1;//largeur sommet
+$X1=1.1;//distance base sommet (std 1.18)
+    
+translate([0,0,Ep+Dd]){
+screw (0,720,Pas,Ray);
+}
+bouchon (Ray,Dd+2*Pas+Df,Ep,48);
+}
+
+module 28PCO1881 () {
+jeu=0.5;//jeu
+Ray=27.40/2+jeu;//rayon centre du motif
+Pas=2.7;//pas de vis
+Ep=1;//épaisseur bouchon
+Ej=0;//épaisseur joint gasket
+Dd=1.5+Ej+Pas/2;//distance demarrage depuis la base
+Df=2;//distance fin
+    
+$Z1=1.8;//largeur base
+$Z2=0.8;//largeur sommet
+$X1=1.1;//distance base sommet (std 1.165)
+    
+translate([0,0,Ep+Dd]){
+screw (0,650,Pas,Ray);
+}
+bouchon (Ray,Dd+2*Pas+Df,Ep,48);
+}
+
+//******************GOULOTS-NECKS*******************
+
+module N28PCO1810  () {
+Ray=25.07/2;//rayon externe
+Pas=3.18;//pas de vis
+Ep=1.7;//épaisseur bouchon
+Dd=13;//hauteur depuis l'épaulement
+Df=1.7;//distance fin
+    
+$Z1=2;//largeur base
+$Z2=1;//largeur sommet
+$X1=-1;//distance base sommet (std 1.0)
+
+translate([0,0,Dd+Ep-Df-2*Pas-$Z1/2]){
+screw (0,720,Pas,Ray);
+}
+goulot (Ray,Dd+Ep,Ep);
+}
+
+module N28PCO1881  () {
+Ray=25.07/2;//rayon externe
+Pas=2.7;//pas de vis
+Ep=1.0;//épaisseur bouchon
+Dd=10;//hauteur depuis l'épaulement
+Df=1.7;//distance fin
+    
+$Z1=1.8;//largeur base
+$Z2=0.8;//largeur sommet
+$X1=-1.1;//distance base sommet (std 1.165)
+
+translate([0,0,Dd+Ep-Df-650*Pas/360-$Z1/2]){
+screw (0,650,Pas,Ray);
+}
+goulot (Ray,Dd+Ep,Ep);
+}
+
+module N38mm3start  () {
+Ray=36/2;//rayon externe
+Pas=9;//pas de vis
+Ep=1.4;//épaisseur bouchon
+Dd=9.2;//hauteur depuis l'épaulement
+Df=1.5;//distance fin
+    
+$Z1=2;//largeur base
+$Z2=1;//largeur sommet
+$X1=-1;//distance base sommet (std 1.165)
+
+translate([0,0,Dd+Ep-Df-Pas/2-$Z1/2]){
+screw (0,180,Pas,Ray);
+screw (120,300,Pas,Ray);
+screw (240,420,Pas,Ray);
+}
+difference(){
+    goulot (Ray,Dd+Ep,Ep);
+    //biseautage
+translate ([0,0,Dd])cylinder(h=2*Ep, r1=Ray-Ep, r2=Ray-Ep/1.5, center=true);
+}
+}

BottleCap/threads.scad

@@ -0,0 +1,371 @@
+/*
+ * ISO-standard metric threads, following this specification:
+ *          http://en.wikipedia.org/wiki/ISO_metric_screw_thread
+ *
+ * Copyright 2016 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.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.
+//
+// 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      - 1 (default): chamfer (45 degree) at max-z end; 0: no chamfer;
+//               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=1, 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=1)
+{
+   // 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);
+}
+
+// ----------------------------------------------------------------------------
+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
+                        ]
+            );
+         }
+      }
+   }
+}
+
+