Updated readme and images

length calculations.

.gitattributes

@@ -0,0 +1,16 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto eol=lf
+
+# Declare text files that are normalized and converted on checkout.
+*.scad text
+*.py   text
+*.md   text
+
+# Handle Windows batch and command files 
+*.{bat,[bB][aA][tT]} text eol=crlf
+*.{cmd,[cC][mM][dD]} text eol=crlf
+
+# Denote files that are binary and should not be modified.
+*.png binary
+*.jpg binary
+

.gitignore

@@ -7,6 +7,7 @@ tests/bom/
 *.log
 *.html
 bounds.json
+options.json
 times.txt
 *_diff.png
 *.echo

docs/usage.md

@@ -26,7 +26,7 @@ OpenSCAD has to be setup to find libraries by setting the ```OPENSCADPATH``` env
 in the directory it points to. This can be done with ```git clone https://github.com/nophead/NopSCADlib.git``` while in that directory or, if you don't want to use GIT,
 by downloading https://github.com/nophead/NopSCADlib/archive/master.zip and unzipping it to a directory called NopSCADlib.
 
-The ```NopSCADlib/scripts``` directory needs to be added to the executable search path.
+The ```NopSCADlib/scripts``` directory needs to be added to the executable search path, ```PATH``` on Windows and ```path``` on Linux and Mac.
 
 The installation can be tested by opening ```NopSCADlib/libtest.scad``` in the OpenSCAD GUI. It should render all the objects in the library in about 1 minute.
 

global_defs.scad

@@ -39,6 +39,7 @@ pp2_colour      = is_undef($pp2_colour)      ? "red"  : $pp2_colour;      // pri
 pp3_colour      = is_undef($pp3_colour)      ? "blue" : $pp3_colour;      // printed part colour 3
 pp4_colour      = is_undef($pp4_colour)      ? "darkorange" : $pp4_colour;// printed part colour 4
 show_rays       = is_undef($show_rays)       ? false  : $show_rays;       // show camera sight lines and light direction
+show_threads    = is_undef($show_threads)    ? false  : $show_threads;    // show screw threads
 
 // Minimum wall is about two filaments wide but we extrude it closer to get better bonding
 squeezed_wall = $preview ? 2 * extrusion_width - layer_height * (1 - PI / 4)
@@ -59,7 +60,9 @@ grey60                          = [0.6, 0.6, 0.6];
 grey70                          = [0.7, 0.7, 0.7];
 grey80                          = [0.8, 0.8, 0.8];
 grey90                          = [0.9, 0.9, 0.9];
-brass                           = "gold";
+gold                            = [255/255, 215/255, 0/255];
+brass                           = [255/255, 220/255, 100/255];
+silver                          = [0.75, 0.75, 0.75];
 
 /*
  * Enums

lib.scad

@@ -62,6 +62,9 @@ include <vitamins/spools.scad>
 include <vitamins/mains_sockets.scad>
 include <vitamins/ldrs.scad>
 include <vitamins/geared_steppers.scad>
+include <vitamins/extrusions.scad>
+include <vitamins/sk_brackets.scad>
+include <vitamins/scs_bearing_blocks.scad>
 
 use <vitamins/jack.scad>
 use <vitamins/meter.scad>
@@ -90,3 +93,4 @@ use <utils/layout.scad>
 use <utils/round.scad>
 use <utils/offset.scad>
 use <utils/sector.scad>
+use <utils/thread.scad>

libtest.scad

@@ -32,6 +32,7 @@ use <tests/cable_strips.scad>
 use <tests/components.scad>
 use <tests/d_connectors.scad>
 use <tests/displays.scad>
+use <tests/extrusions.scad>
 use <tests/fans.scad>
 use <tests/fuseholder.scad>
 use <tests/geared_steppers.scad>
@@ -135,13 +136,13 @@ translate([x5, cable_grommets_y + 250])
 translate([900, 600])
     box_test();
 
-translate([850, 1170])
+translate([850, 1260])
     bbox_test();
 
 x0 = 0;
 inserts_y = 0;
 nuts_y = inserts_y + 20;
-washers_y = nuts_y + 60;
+washers_y = nuts_y + 100;
 screws_y = washers_y + 120;
 o_rings_y = screws_y + 130;
 springs_y = o_rings_y + 20;
@@ -152,7 +153,7 @@ leadnuts_y = pillars_y + 40;
 pulleys_y = leadnuts_y +40;
 hot_ends_y = pulleys_y + 60;
 linear_bearings_y = hot_ends_y + 50;
-sheets_y = linear_bearings_y + 50;
+sheets_y = linear_bearings_y + 100;
 pcbs_y = sheets_y + 40;
 displays_y = pcbs_y + 150;
 fans_y = displays_y + 100;
@@ -203,6 +204,10 @@ translate([x0, linear_bearings_y]) {
     rods();
 }
 
+translate([x0+150, linear_bearings_y+30]) {
+    extrusions();
+}
+
 translate([x0 + 10, hot_ends_y])
     hot_ends();
 
@@ -249,7 +254,7 @@ buttons_y = spades_y + 40;
 jacks_y = buttons_y + 40;
 microswitches_y = jacks_y + 40;
 rockers_y = microswitches_y + 40;
-toggles_y = rockers_y + 40;
+toggles_y = rockers_y + 60;
 components_y = toggles_y + 40;
 
 translate([x2, leds_y])

printed/screw_knob.scad

@@ -34,7 +34,7 @@ knob_waves = 5;
 knob_height = knob_stem_h + knob_thickness;
 function knob_height() = knob_height;
 
-module screw_knob(screw) { //! Generate the STL foe a knob to fit the specified hex screw
+module screw_knob(screw) { //! Generate the STL for a knob to fit the specified hex screw
     stl(str("screw_knob_M", screw_radius(screw) * 20));
 
     knob_stem_r = nut_trap_radius(screw_nut(screw)) + knob_wall;

readme.md

@@ -28,15 +28,17 @@ See [usage](docs/usage.md) for requirements, installation instructions and a usa
 <tr><td> <a href = "#Components">Components</a> </td><td> <a href = "#Pulleys">Pulleys</a> </td><td> <a href = "#Fan_guard">Fan_guard</a> </td><td> <a href = "#Offset">Offset</a> </td><td></td></tr>
 <tr><td> <a href = "#D_connectors">D_connectors</a> </td><td> <a href = "#Rails">Rails</a> </td><td> <a href = "#Fixing_block">Fixing_block</a> </td><td> <a href = "#Quadrant">Quadrant</a> </td><td></td></tr>
 <tr><td> <a href = "#Displays">Displays</a> </td><td> <a href = "#Ring_terminals">Ring_terminals</a> </td><td> <a href = "#Flat_hinge">Flat_hinge</a> </td><td> <a href = "#Round">Round</a> </td><td></td></tr>
-<tr><td> <a href = "#Fans">Fans</a> </td><td> <a href = "#Rockers">Rockers</a> </td><td> <a href = "#Foot">Foot</a> </td><td> <a href = "#Rounded_cylinder">Rounded_cylinder</a> </td><td></td></tr>
-<tr><td> <a href = "#Fuseholder">Fuseholder</a> </td><td> <a href = "#Rod">Rod</a> </td><td> <a href = "#Handle">Handle</a> </td><td> <a href = "#Rounded_polygon">Rounded_polygon</a> </td><td></td></tr>
-<tr><td> <a href = "#Geared_steppers">Geared_steppers</a> </td><td> <a href = "#Screws">Screws</a> </td><td> <a href = "#Pcb_mount">Pcb_mount</a> </td><td> <a href = "#Sector">Sector</a> </td><td></td></tr>
-<tr><td> <a href = "#Green_terminals">Green_terminals</a> </td><td> <a href = "#Sealing_strip">Sealing_strip</a> </td><td> <a href = "#Psu_shroud">Psu_shroud</a> </td><td> <a href = "#Sweep">Sweep</a> </td><td></td></tr>
-<tr><td> <a href = "#Hot_ends">Hot_ends</a> </td><td> <a href = "#Sheets">Sheets</a> </td><td> <a href = "#Ribbon_clamp">Ribbon_clamp</a> </td><td> <a href = "#Tube">Tube</a> </td><td></td></tr>
-<tr><td> <a href = "#Hygrometer">Hygrometer</a> </td><td> <a href = "#Spades">Spades</a> </td><td> <a href = "#Screw_knob">Screw_knob</a> </td><td></td><td></td></tr>
-<tr><td> <a href = "#Iecs">Iecs</a> </td><td> <a href = "#Spools">Spools</a> </td><td> <a href = "#Socket_box">Socket_box</a> </td><td></td><td></td></tr>
-<tr><td> <a href = "#Inserts">Inserts</a> </td><td> <a href = "#Springs">Springs</a> </td><td> <a href = "#Ssr_shroud">Ssr_shroud</a> </td><td></td><td></td></tr>
-<tr><td> <a href = "#Jack">Jack</a> </td><td> <a href = "#Ssrs">Ssrs</a> </td><td> <a href = "#Strap_handle">Strap_handle</a> </td><td></td><td></td></tr>
+<tr><td> <a href = "#Extrusions">Extrusions</a> </td><td> <a href = "#Rockers">Rockers</a> </td><td> <a href = "#Foot">Foot</a> </td><td> <a href = "#Rounded_cylinder">Rounded_cylinder</a> </td><td></td></tr>
+<tr><td> <a href = "#Fans">Fans</a> </td><td> <a href = "#Rod">Rod</a> </td><td> <a href = "#Handle">Handle</a> </td><td> <a href = "#Rounded_polygon">Rounded_polygon</a> </td><td></td></tr>
+<tr><td> <a href = "#Fuseholder">Fuseholder</a> </td><td> <a href = "#Screws">Screws</a> </td><td> <a href = "#Pcb_mount">Pcb_mount</a> </td><td> <a href = "#Sector">Sector</a> </td><td></td></tr>
+<tr><td> <a href = "#Geared_steppers">Geared_steppers</a> </td><td> <a href = "#Scs_bearing_blocks">Scs_bearing_blocks</a> </td><td> <a href = "#Psu_shroud">Psu_shroud</a> </td><td> <a href = "#Sweep">Sweep</a> </td><td></td></tr>
+<tr><td> <a href = "#Green_terminals">Green_terminals</a> </td><td> <a href = "#Sealing_strip">Sealing_strip</a> </td><td> <a href = "#Ribbon_clamp">Ribbon_clamp</a> </td><td> <a href = "#Thread">Thread</a> </td><td></td></tr>
+<tr><td> <a href = "#Hot_ends">Hot_ends</a> </td><td> <a href = "#Sheets">Sheets</a> </td><td> <a href = "#Screw_knob">Screw_knob</a> </td><td> <a href = "#Tube">Tube</a> </td><td></td></tr>
+<tr><td> <a href = "#Hygrometer">Hygrometer</a> </td><td> <a href = "#Sk_brackets">Sk_brackets</a> </td><td> <a href = "#Socket_box">Socket_box</a> </td><td></td><td></td></tr>
+<tr><td> <a href = "#Iecs">Iecs</a> </td><td> <a href = "#Spades">Spades</a> </td><td> <a href = "#Ssr_shroud">Ssr_shroud</a> </td><td></td><td></td></tr>
+<tr><td> <a href = "#Inserts">Inserts</a> </td><td> <a href = "#Spools">Spools</a> </td><td> <a href = "#Strap_handle">Strap_handle</a> </td><td></td><td></td></tr>
+<tr><td> <a href = "#Jack">Jack</a> </td><td> <a href = "#Springs">Springs</a> </td><td></td><td></td><td></td></tr>
+<tr><td> <a href = "#Kp_pillow_blocks">Kp_pillow_blocks</a> </td><td> <a href = "#Ssrs">Ssrs</a> </td><td></td><td></td><td></td></tr>
 <tr><td> <a href = "#Ldrs">Ldrs</a> </td><td> <a href = "#Stepper_motors">Stepper_motors</a> </td><td></td><td></td><td></td></tr>
 <tr><td> <a href = "#Leadnuts">Leadnuts</a> </td><td> <a href = "#Toggles">Toggles</a> </td><td></td><td></td><td></td></tr>
 <tr><td> <a href = "#Leds">Leds</a> </td><td> <a href = "#Transformers">Transformers</a> </td><td></td><td></td><td></td></tr>
@@ -92,8 +94,10 @@ Also single bearing balls are modelled as just a silver sphere and a BOM entry.
 | Qty | Module call | BOM entry |
 | ---:|:--- |:---|
 |   1 | ```ball_bearing(BB608)``` |  Ball bearing 608-2RS 8mm x 22mm x 7mm |
+|   1 | ```ball_bearing(BB6200)``` |  Ball bearing 6200-2RS 10mm x 30mm x 9mm |
+|   1 | ```ball_bearing(BB6201)``` |  Ball bearing 6201-2RS 12mm x 32mm x 10mm |
 |   1 | ```ball_bearing(BB624)``` |  Ball bearing 624-2RS 4mm x 13mm x 5mm |
-|   2 | ``` bearing_ball(3)``` |  Steel ball 3mm |
+|   4 | ``` bearing_ball(3)``` |  Steel ball 3mm |
 
 
 <a href="#top">Top</a>
@@ -195,7 +199,7 @@ Individual teeth are not drawn, instead they are represented by a lighter colour
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```belt(type, points, gap = 0, gap_pt = undef)``` | Draw a belt path given a set of points and pitch radii where the pulleys are. Closed loop unless a gap is specified |
+| ```belt(type, points, gap = 0, gap_pt = undef, belt_colour = grey20, tooth_colour = grey50)``` | Draw a belt path given a set of points and pitch radii where the pulleys are. Closed loop unless a gap is specified |
 
 ![belts](tests/png/belts.png)
 
@@ -212,7 +216,7 @@ Individual teeth are not drawn, instead they are represented by a lighter colour
 |   2 | ```pulley(GT2x16_plain_idler)``` |  Pulley GT2 idler smooth 9.63mm |
 |   2 | ```pulley(GT2x20ob_pulley)``` |  Pulley GT2OB 20 teeth |
 |   1 | ```screw(M3_cs_cap_screw, 20)``` |  Screw M3 cs cap x 20mm |
-|   4 | ```screw(M3_grub_screw, 6)``` |  Screw M3 grub x 6mm |
+|   4 | ```screw(M3_grub_screw, 6)``` |  Screw M3 grub x  6mm |
 
 
 <a href="#top">Top</a>
@@ -585,6 +589,54 @@ LCD dispays.
 |   1 | ```display(SSD1963_4p3)``` |  LCD display SSD1963 4.3" |
 
 
+<a href="#top">Top</a>
+
+---
+<a name="Extrusions"></a>
+## Extrusions
+Aluminium  extrusion.
+
+
+[vitamins/extrusions.scad](vitamins/extrusions.scad) Object definitions.
+
+[vitamins/extrusion.scad](vitamins/extrusion.scad) Implementation.
+
+[tests/extrusions.scad](tests/extrusions.scad) Code for this example.
+
+### Properties
+| Function | Description |
+|:--- |:--- |
+| ```extrusion_center_hole(type)``` | Diameter of center hole |
+| ```extrusion_center_square(type)``` | Size of center square |
+| ```extrusion_channel_width(type)``` | Channel width |
+| ```extrusion_channel_width_internal(type)``` | Internal channel width |
+| ```extrusion_corner_hole(type)``` | Diameter of corner hole |
+| ```extrusion_fillet(type)``` | Radius of corner fillet |
+| ```extrusion_height(type)``` | Height of extrusion |
+| ```extrusion_spar_thickness(type)``` | Spar thickness |
+| ```extrusion_tab_thickness(type)``` | Tab thickness |
+| ```extrusion_width(type)``` | Width of extrusion |
+
+### Modules
+| Module | Description |
+|:--- |:--- |
+| ```extrusion(type, length, cornerHole = false)``` | Draw the specified extrusion |
+
+![extrusions](tests/png/extrusions.png)
+
+### Vitamins
+| Qty | Module call | BOM entry |
+| ---:|:--- |:---|
+|   1 | ```extrusion(E2020, 80)``` |  Extrusion E2020 x 80mm |
+|   1 | ```extrusion(E2040, 80)``` |  Extrusion E2040 x 80mm |
+|   1 | ```extrusion(E2060, 80)``` |  Extrusion E2060 x 80mm |
+|   1 | ```extrusion(E2080, 80)``` |  Extrusion E2080 x 80mm |
+|   1 | ```extrusion(E3030, 80)``` |  Extrusion E3030 x 80mm |
+|   1 | ```extrusion(E3060, 80)``` |  Extrusion E3060 x 80mm |
+|   1 | ```extrusion(E4040, 80)``` |  Extrusion E4040 x 80mm |
+|   1 | ```extrusion(E4080, 80)``` |  Extrusion E4080 x 80mm |
+
+
 <a href="#top">Top</a>
 
 ---
@@ -774,7 +826,7 @@ Parametric green terminal blocks
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```green_terminal(type, ways, skip = [])``` | Draw green terminal blocks, skip can be used to remove pins. |
+| ```green_terminal(type, ways, skip = [], colour = "lime")``` | Draw green terminal blocks, skip can be used to remove pins. |
 | ```terminal_254(ways, skip = [])``` | Draw 0.1" terminal block |
 
 ![green_terminals](tests/png/green_terminals.png)
@@ -943,10 +995,11 @@ IEC mains inlets and outlet.
 |   1 | ```iec(IEC_inlet)``` |  IEC inlet |
 |   1 | ```iec(IEC_inlet_atx)``` |  IEC inlet for ATX |
 |   1 | ```iec(IEC_outlet)``` |  IEC outlet RS 811-7193 |
-|  10 | ```nut(M3_nut, nyloc = true)``` |  Nut M3 x 2.4mm nyloc |
+|   1 | ```iec(IEC_switched_fused_inlet)``` |  IEC320 C14 switched fused inlet module |
+|  12 | ```nut(M3_nut, nyloc = true)``` |  Nut M3 x 2.4mm nyloc |
 |   4 | ```screw(M3_cs_cap_screw, 10)``` |  Screw M3 cs cap x 10mm |
-|   6 | ```screw(M3_cs_cap_screw, 12)``` |  Screw M3 cs cap x 12mm |
-|  10 | ```washer(M3_washer)``` |  Washer  M3 x 7mm x 0.5mm |
+|   8 | ```screw(M3_cs_cap_screw, 12)``` |  Screw M3 cs cap x 12mm |
+|  12 | ```washer(M3_washer)``` |  Washer  M3 x 7mm x 0.5mm |
 
 
 <a href="#top">Top</a>
@@ -1037,6 +1090,57 @@ E.g. a "brown" socket for mains live needs to be displayed as "sienna" to look r
 |   1 | ```jack_4mm_shielded("brown", 3, "sienna")``` |  4mm shielded jack socket brown |
 
 
+<a href="#top">Top</a>
+
+---
+<a name="Kp_pillow_blocks"></a>
+## Kp_pillow_blocks
+KP pillow block bearings
+
+
+[vitamins/kp_pillow_blocks.scad](vitamins/kp_pillow_blocks.scad) Object definitions.
+
+[vitamins/kp_pillow_block.scad](vitamins/kp_pillow_block.scad) Implementation.
+
+[tests/kp_pillow_blocks.scad](tests/kp_pillow_blocks.scad) Code for this example.
+
+### Properties
+| Function | Description |
+|:--- |:--- |
+| ```kp_base_height(type)``` | Height of base containing the bolts |
+| ```kp_diameter(type)``` | Rod hole diameter |
+| ```kp_hole_offset(type)``` | Rod hole offset |
+| ```kp_screw_separation(type)``` | Separation of bolts in the base |
+
+### Functions
+| Function | Description |
+|:--- |:--- |
+| ```kp_size(type)``` | Size of bracket |
+
+### Modules
+| Module | Description |
+|:--- |:--- |
+| ```kp_pillow_block(type)``` | Draw the KP pillow block |
+| ```kp_pillow_block_assembly(type, part_thickness = 2, screw_type = M5_cap_screw, nut_type = undef)``` | Assembly with fasteners in place |
+| ```kp_pillow_block_hole_positions(type)``` | Place children at hole positions |
+
+![kp_pillow_blocks](tests/png/kp_pillow_blocks.png)
+
+### Vitamins
+| Qty | Module call | BOM entry |
+| ---:|:--- |:---|
+|   1 | ```kp_pillow_block(KP000)``` |  KP000 pillow block |
+|   1 | ```kp_pillow_block(KP001)``` |  KP001 pillow block |
+|   1 | ```kp_pillow_block(KP08)``` |  KP08 pillow block |
+|   2 | ```sliding_t_nut(M4_sliding_t_nut)``` |  Nut M4 sliding T |
+|   2 | ```sliding_t_nut(M5_sliding_t_nut)``` |  Nut M5 sliding T |
+|   2 | ```nut(M5_nut, nyloc = undef)``` |  Nut M5 x 4mm  |
+|   2 | ```screw(M4_cap_screw, 10)``` |  Screw M4 cap x 10mm |
+|   4 | ```screw(M5_cap_screw, 12)``` |  Screw M5 cap x 12mm |
+|   2 | ```washer(M4_washer)``` |  Washer  M4 x 9mm x 0.8mm |
+|   6 | ```washer(M5_washer)``` |  Washer  M5 x 10mm x 1mm |
+
+
 <a href="#top">Top</a>
 
 ---
@@ -1103,7 +1207,9 @@ Nuts for leadscrews.
 | ```leadnut_hole_dia(type)``` | The diameter of the screw holes |
 | ```leadnut_hole_pitch(type)``` | The radia pitch of the screw holes |
 | ```leadnut_holes(type)``` | The number of screw holes |
+| ```leadnut_lead(type)``` | Screw lead |
 | ```leadnut_od(type)``` | Outer diameter of the shank |
+| ```leadnut_pitch(type)``` | Screw pitch |
 | ```leadnut_screw(type)``` | The type of the fixing screws |
 
 ### Functions
@@ -1244,6 +1350,9 @@ LMnUU linear bearings.
 | Function | Description |
 |:--- |:--- |
 | ```bearing_dia(type)``` | Outside diameter |
+| ```bearing_groove_dia(type)``` | Groove diameter |
+| ```bearing_groove_length(type)``` | Groove length |
+| ```bearing_groove_spacing(type)``` | Spacing between grooves, outer to outer, ie includes the grooves themselves |
 | ```bearing_length(type)``` | Total length |
 | ```bearing_rod_dia(type)``` | Internal diameter |
 
@@ -1262,12 +1371,21 @@ LMnUU linear bearings.
 ### Vitamins
 | Qty | Module call | BOM entry |
 | ---:|:--- |:---|
+|   1 | ```linear_bearing(LM10LUU)``` |  Linear bearing LM10LUU |
 |   1 | ```linear_bearing(LM10UU)``` |  Linear bearing LM10UU |
+|   1 | ```linear_bearing(LM12LUU)``` |  Linear bearing LM12LUU |
 |   1 | ```linear_bearing(LM12UU)``` |  Linear bearing LM12UU |
+|   1 | ```linear_bearing(LM16LUU)``` |  Linear bearing LM16LUU |
+|   1 | ```linear_bearing(LM16UU)``` |  Linear bearing LM16UU |
+|   1 | ```linear_bearing(LM3LUU)``` |  Linear bearing LM3LUU |
 |   1 | ```linear_bearing(LM3UU)``` |  Linear bearing LM3UU |
+|   1 | ```linear_bearing(LM4LUU)``` |  Linear bearing LM4LUU |
 |   1 | ```linear_bearing(LM4UU)``` |  Linear bearing LM4UU |
+|   1 | ```linear_bearing(LM5LUU)``` |  Linear bearing LM5LUU |
 |   1 | ```linear_bearing(LM5UU)``` |  Linear bearing LM5UU |
+|   1 | ```linear_bearing(LM6LUU)``` |  Linear bearing LM6LUU |
 |   1 | ```linear_bearing(LM6UU)``` |  Linear bearing LM6UU |
+|   1 | ```linear_bearing(LM8LUU)``` |  Linear bearing LM8LUU |
 |   1 | ```linear_bearing(LM8UU)``` |  Linear bearing LM8UU |
 
 
@@ -1559,11 +1677,16 @@ If a nut is given a child then it gets placed on its top surface.
 |   1 | ```nut(M2p5_nut)``` |  Nut M2.5 x 2.2mm  |
 |   1 | ```nut(M2p5_nut, nyloc = true)``` |  Nut M2.5 x 2.2mm nyloc |
 |   1 | ```nut(M2p5_nut, nylon = true)``` |  Nut M2.5 x 2.2mm nylon |
+|   1 | ```sliding_t_nut(M3_hammer_nut)``` |  Nut M3 hammer |
+|   1 | ```sliding_t_nut(M3_sliding_t_nut)``` |  Nut M3 sliding T |
 |   1 | ```nut(M3_nut)``` |  Nut M3 x 2.4mm  |
 |   1 | ```nut(M3_nut, brass = true)``` |  Nut M3 x 2.4mm brass |
 |   1 | ```nut(M3_nut, nyloc = true)``` |  Nut M3 x 2.4mm nyloc |
+|   1 | ```sliding_t_nut(M4_hammer_nut)``` |  Nut M4 hammer |
+|   1 | ```sliding_t_nut(M4_sliding_t_nut)``` |  Nut M4 sliding T |
 |   1 | ```nut(M4_nut)``` |  Nut M4 x 3.2mm  |
 |   1 | ```nut(M4_nut, nyloc = true)``` |  Nut M4 x 3.2mm nyloc |
+|   1 | ```sliding_t_nut(M5_sliding_t_nut)``` |  Nut M5 sliding T |
 |   1 | ```nut(M5_nut)``` |  Nut M5 x 4mm  |
 |   1 | ```nut(M5_nut, nyloc = true)``` |  Nut M5 x 4mm nyloc |
 |   1 | ```nut(M6_half_nut)``` |  Nut M6 x 3mm  |
@@ -1691,6 +1814,7 @@ PCBs and perfboard with optional components. The shape can be a rectangle with o
 | Module | Description |
 |:--- |:--- |
 | ```barrel_jack(cutout = false)``` | Draw barrel power jack |
+| ```buzzer(height, diameter, colour)``` | Draw PCB buzzer with specified height, diameter and color |
 | ```chip(length, width, thickness, colour, cutout = false)``` | Draw a coloured cube to represent a chip, or other rectangular component |
 | ```flat_flex(cutout = false)``` | Draw flat flexistrip connector as used on RPI0 |
 | ```flex(cutout = false)``` | Draw flexistrip connector |
@@ -1734,7 +1858,7 @@ PCBs and perfboard with optional components. The shape can be a rectangle with o
 |   1 | ```molex_254(2)``` |  Molex KK header 2 way |
 |   1 | ```molex_254(3)``` |  Molex KK header 3 way |
 |  16 | ```nut(M2_nut, nyloc = true)``` |  Nut M2 x 1.6mm nyloc |
-|  28 | ```nut(M2p5_nut, nyloc = true)``` |  Nut M2.5 x 2.2mm nyloc |
+|  32 | ```nut(M2p5_nut, nyloc = true)``` |  Nut M2.5 x 2.2mm nyloc |
 |  12 | ```nut(M3_nut, nyloc = true)``` |  Nut M3 x 2.4mm nyloc |
 |  12 | ```nut(M4_nut, nyloc = true)``` |  Nut M4 x 3.2mm nyloc |
 |   1 | ```pcb(PI_IO)``` |  PI_IO V2 |
@@ -1745,11 +1869,13 @@ PCBs and perfboard with optional components. The shape can be a rectangle with o
 |   1 | ```pcb(PERF74x51)``` |  Perfboard 74 x 51mm |
 |   1 | ```pcb(PERF80x20)``` |  Perfboard 80 x 20mm |
 |   1 | ```pin_socket(2p54header, 13, 2, right_angle = true)``` |  Pin socket 13 x 2 right_angle |
+|   1 | ```pcb(RAMPSEndstop)``` |  RAMPS Endstop Switch |
 |   1 | ```pcb(RPI3)``` |  Raspberry Pi 3 |
 |   1 | ```pcb(RPI0)``` |  Raspberry Pi Zero |
 |  16 | ```screw(M2_cap_screw, 25)``` |  Screw M2 cap x 25mm |
 |   4 | ```screw(M2p5_cap_screw, 16)``` |  Screw M2.5 cap x 16mm |
 |   8 | ```screw(M2p5_cap_screw, 20)``` |  Screw M2.5 cap x 20mm |
+|   4 | ```screw(M2p5_cap_screw, 35)``` |  Screw M2.5 cap x 35mm |
 |   8 | ```screw(M2p5_pan_screw, 20)``` |  Screw M2.5 pan x 20mm |
 |   4 | ```screw(M2p5_pan_screw, 25)``` |  Screw M2.5 pan x 25mm |
 |   4 | ```screw(M2p5_pan_screw, 35)``` |  Screw M2.5 pan x 35mm |
@@ -1761,7 +1887,7 @@ PCBs and perfboard with optional components. The shape can be a rectangle with o
 |   2 | ```green_terminal(gt_2p54, 4)``` |  Terminal block 4 way 0.1" |
 |   1 |  |  USB A to Mini B lead |
 |  16 | ```washer(M2_washer)``` |  Washer  M2 x 5mm x 0.3mm |
-|  28 | ```washer(M2p5_washer)``` |  Washer  M2.5 x 5.9mm x 0.5mm |
+|  32 | ```washer(M2p5_washer)``` |  Washer  M2.5 x 5.9mm x 0.5mm |
 |  12 | ```washer(M3_washer)``` |  Washer  M3 x 7mm x 0.5mm |
 |  12 | ```washer(M4_washer)``` |  Washer  M4 x 9mm x 0.8mm |
 |   1 | ```pcb(ZC_A0591)``` |  ZC-A0591 ULN2003 driver PCB |
@@ -1777,6 +1903,7 @@ PCBs and perfboard with optional components. The shape can be a rectangle with o
 |   4 | pcb_spacer25110_2.stl |
 |   4 | pcb_spacer25120_2.stl |
 |   4 | pcb_spacer25230.stl |
+|   4 | pcb_spacer25240.stl |
 |   4 | pcb_spacer2570.stl |
 |   4 | pcb_spacer2580.stl |
 |   4 | pcb_spacer2590.stl |
@@ -1866,6 +1993,7 @@ Pin headers and sockets, etc.
 |:--- |:--- |
 | ```box_header(type, cols = 1, rows = 1, smt = false, cutout = false)``` | Draw box header |
 | ```idc_transition(type, cols = 5, skip = [], cutout = false)``` | Draw IDC transition header |
+| ```jst_xh_header(type, pin_count, right_angle=false, colour, pin_colour)``` | Draw JST XH connector |
 | ```pin(type, length = undef)``` | Draw a header pin |
 | ```pin_header(type, cols = 1, rows = 1, smt = false, right_angle = false, cutout = false)``` | Draw pin header |
 | ```pin_socket(type, cols = 1, rows = 1, right_angle = false, height = 0, smt = false, cutout = false)``` | Draw pin socket |
@@ -1953,10 +2081,10 @@ Face order is bottom, top, left, right, front, back.
 |   1 | ```psu(PD_150_12)``` |  PSU PD-150-12 |
 |   1 | ```psu(S_250_48)``` |  PSU S-250-48 |
 |   1 | ```psu(S_300_12)``` |  PSU S-300-12 |
-|   4 | ```screw(No632_pan_screw, 8)``` |  Screw 6-32 pan x 8mm |
-|   4 | ```screw(M3_cap_screw, 8)``` |  Screw M3 cap x 8mm |
-|   8 | ```screw(M3_pan_screw, 8)``` |  Screw M3 pan x 8mm |
-|   4 | ```screw(M4_cap_screw, 8)``` |  Screw M4 cap x 8mm |
+|   4 | ```screw(No632_pan_screw, 8)``` |  Screw 6-32 pan x  8mm |
+|   4 | ```screw(M3_cap_screw, 8)``` |  Screw M3 cap x  8mm |
+|   8 | ```screw(M3_pan_screw, 8)``` |  Screw M3 pan x  8mm |
+|   4 | ```screw(M4_cap_screw, 8)``` |  Screw M4 cap x  8mm |
 |  12 | ```washer(M3_washer)``` |  Washer  M3 x 7mm x 0.5mm |
 |   8 | ```washer(M4_washer)``` |  Washer  M4 x 9mm x 0.8mm |
 
@@ -2022,10 +2150,10 @@ Timing belt pulleys, both toothed and plain with internal bearings for idlers.
 |   1 | ```pulley(GT2x20um_pulley)``` |  Pulley GT2UM 20 teeth |
 |   1 | ```pulley(T2p5x16_pulley)``` |  Pulley T2.5 16 teeth |
 |   1 | ```pulley(T5x10_pulley)``` |  Pulley T5 10 teeth |
-|   1 | ```screw(M3_grub_screw, 3)``` |  Screw M3 grub x 3mm |
-|   2 | ```screw(M3_grub_screw, 4)``` |  Screw M3 grub x 4mm |
-|   4 | ```screw(M3_grub_screw, 6)``` |  Screw M3 grub x 6mm |
-|   1 | ```screw(M4_grub_screw, 6)``` |  Screw M4 grub x 6mm |
+|   1 | ```screw(M3_grub_screw, 3)``` |  Screw M3 grub x  3mm |
+|   2 | ```screw(M3_grub_screw, 4)``` |  Screw M3 grub x  4mm |
+|   4 | ```screw(M3_grub_screw, 6)``` |  Screw M3 grub x  6mm |
+|   1 | ```screw(M4_grub_screw, 6)``` |  Screw M4 grub x  6mm |
 
 
 <a href="#top">Top</a>
@@ -2074,10 +2202,10 @@ Linear rails with carriages.
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```carriage(type, rail)``` | Draw the specified carriage |
+| ```carriage(type, rail, end_color = grey20, wiper_color = grey20)``` | Draw the specified carriage |
 | ```carriage_hole_positions(type)``` | Position children over screw holes |
 | ```rail(type, length)``` | Draw the specified rail |
-| ```rail_assembly(type, length, pos)``` | Rail and carriage assembly |
+| ```rail_assembly(type, length, pos, carriage_end_color = grey20, carriage_wiper_color = grey20)``` | Rail and carriage assembly |
 | ```rail_hole_positions(type, length, first = 0, screws = 100, both_ends = true)``` | Position children over screw holes |
 | ```rail_screws(type, length, thickness, screws = 100)``` | Place screws in the rail |
 
@@ -2185,7 +2313,7 @@ Rocker switch. Also used for neon indicator in the same form factor.
 | ```rocker_height(type)``` | Body height |
 | ```rocker_part(type)``` | Part description |
 | ```rocker_pivot(type)``` | Pivot distance from the back of the flange |
-| ```rocker_slot_h(type)``` | Panel slow height |
+| ```rocker_slot_h(type)``` | Panel slot height |
 | ```rocker_slot_w(type)``` | Panel slot width |
 | ```rocker_spades(type)``` | Spade types and positions |
 | ```rocker_width(type)``` | Body width |
@@ -2193,7 +2321,7 @@ Rocker switch. Also used for neon indicator in the same form factor.
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```rocker(type)``` | Draw the specified rocker switch |
+| ```rocker(type, colour)``` | Draw the specified rocker switch |
 | ```rocker_hole(type, h = 0)``` | Make a hole to accept a rocker switch, by default 2D, set h for 3D |
 
 ![rockers](tests/png/rockers.png)
@@ -2201,8 +2329,8 @@ Rocker switch. Also used for neon indicator in the same form factor.
 ### Vitamins
 | Qty | Module call | BOM entry |
 | ---:|:--- |:---|
-|   1 | ```rocker(neon_indicator)``` |  Neon Indicator H8630FBNAL |
-|   1 | ```rocker(small_rocker)``` |  Rocker Switch PRASA1-16F-BB0BW |
+|   2 | ```rocker(neon_indicator)``` |  Neon Indicator H8630FBNAL |
+|   2 | ```rocker(small_rocker)``` |  Rocker Switch PRASA1-16F-BB0BW |
 
 
 <a href="#top">Top</a>
@@ -2220,16 +2348,23 @@ Steel rods and studding with chamfered ends.
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```rod(d , l)``` | Draw a smooth rod with specified length and diameter |
-| ```studding(d , l)``` | Draw a threaded rod with specified length and diameter |
+| ```leadscrew(d , l, lead, starts, center = true)``` | Draw a leadscrew with specified diameter, length, lead and number of starts |
+| ```rod(d , l, center = true)``` | Draw a smooth rod with specified diameter and length |
+| ```studding(d , l, center = true)``` | Draw a threaded rod with specified diameter and length |
 
 ![rod](tests/png/rod.png)
 
 ### Vitamins
 | Qty | Module call | BOM entry |
 | ---:|:--- |:---|
+|   1 | ```leadscrew(10, 80, 8, 4)``` |  Leadscrew 10 x 80mm, 8mm lead, 4 starts |
+|   1 | ```leadscrew(12, 80, 12, 4)``` |  Leadscrew 12 x 80mm, 12mm lead, 4 starts |
+|   1 | ```leadscrew(16, 80, 16, 4)``` |  Leadscrew 16 x 80mm, 16mm lead, 4 starts |
+|   1 | ```leadscrew(6, 80, 2, 1)``` |  Leadscrew 6 x 80mm, 2mm lead, 1 starts |
+|   1 | ```leadscrew(8, 80, 8, 4)``` |  Leadscrew 8 x 80mm, 8mm lead, 4 starts |
 |   1 | ```rod(10, 80)``` |  Smooth rod 10mm x 80mm |
 |   1 | ```rod(12, 80)``` |  Smooth rod 12mm x 80mm |
+|   1 | ```rod(16, 80)``` |  Smooth rod 16mm x 80mm |
 |   1 | ```rod(3, 80)``` |  Smooth rod 3mm x 80mm |
 |   1 | ```rod(4, 80)``` |  Smooth rod 4mm x 80mm |
 |   1 | ```rod(5, 80)``` |  Smooth rod 5mm x 80mm |
@@ -2237,6 +2372,7 @@ Steel rods and studding with chamfered ends.
 |   1 | ```rod(8, 80)``` |  Smooth rod 8mm x 80mm |
 |   1 | ```studding(10, 80)``` |  Threaded rod M10 x 80mm |
 |   1 | ```studding(12, 80)``` |  Threaded rod M12 x 80mm |
+|   1 | ```studding(16, 80)``` |  Threaded rod M16 x 80mm |
 |   1 | ```studding(3, 80)``` |  Threaded rod M3 x 80mm |
 |   1 | ```studding(4, 80)``` |  Threaded rod M4 x 80mm |
 |   1 | ```studding(5, 80)``` |  Threaded rod M5 x 80mm |
@@ -2295,21 +2431,21 @@ Machine screws and wood screws with various head styles.
 | Qty | Module call | BOM entry |
 | ---:|:--- |:---|
 |   1 | ```screw(No632_pan_screw, 30)``` |  Screw 6-32 pan x 30mm |
-|   1 | ```screw(M2_cap_screw, 25)``` |  Screw M2 cap x 25mm |
-|   1 | ```screw(M2_cs_cap_screw, 25)``` |  Screw M2 cs cap x 25mm |
-|   1 | ```screw(M2p5_cap_screw, 25)``` |  Screw M2.5 cap x 25mm |
-|   1 | ```screw(M2p5_pan_screw, 30)``` |  Screw M2.5 pan x 30mm |
-|   1 | ```screw(M3_cap_screw, 25)``` |  Screw M3 cap x 25mm |
-|   1 | ```screw(M3_cs_cap_screw, 25)``` |  Screw M3 cs cap x 25mm |
-|   1 | ```screw(M3_dome_screw, 25)``` |  Screw M3 dome x 25mm |
-|   1 | ```screw(M3_grub_screw, 6)``` |  Screw M3 grub x 6mm |
-|   1 | ```screw(M3_hex_screw, 30)``` |  Screw M3 hex x 30mm |
-|   1 | ```screw(M3_low_cap_screw, 25)``` |  Screw M3 low cap x 25mm |
-|   1 | ```screw(M3_pan_screw, 30)``` |  Screw M3 pan x 30mm |
+|   1 | ```screw(M2_cap_screw, 10)``` |  Screw M2 cap x 10mm |
+|   1 | ```screw(M2_cs_cap_screw, 10)``` |  Screw M2 cs cap x 10mm |
+|   1 | ```screw(M2p5_cap_screw, 10)``` |  Screw M2.5 cap x 10mm |
+|   1 | ```screw(M2p5_pan_screw, 10)``` |  Screw M2.5 pan x 10mm |
+|   1 | ```screw(M3_cap_screw, 10)``` |  Screw M3 cap x 10mm |
+|   1 | ```screw(M3_cs_cap_screw, 10)``` |  Screw M3 cs cap x 10mm |
+|   1 | ```screw(M3_dome_screw, 10)``` |  Screw M3 dome x 10mm |
+|   1 | ```screw(M3_grub_screw, 6)``` |  Screw M3 grub x  6mm |
+|   1 | ```screw(M3_hex_screw, 10)``` |  Screw M3 hex x 10mm |
+|   1 | ```screw(M3_low_cap_screw, 10)``` |  Screw M3 low cap x 10mm |
+|   1 | ```screw(M3_pan_screw, 10)``` |  Screw M3 pan x 10mm |
 |   1 | ```screw(M4_cap_screw, 25)``` |  Screw M4 cap x 25mm |
 |   1 | ```screw(M4_cs_cap_screw, 25)``` |  Screw M4 cs cap x 25mm |
 |   1 | ```screw(M4_dome_screw, 25)``` |  Screw M4 dome x 25mm |
-|   1 | ```screw(M4_grub_screw, 6)``` |  Screw M4 grub x 6mm |
+|   1 | ```screw(M4_grub_screw, 6)``` |  Screw M4 grub x  6mm |
 |   1 | ```screw(M4_hex_screw, 30)``` |  Screw M4 hex x 30mm |
 |   1 | ```screw(M4_pan_screw, 30)``` |  Screw M4 pan x 30mm |
 |   1 | ```screw(M5_cap_screw, 30)``` |  Screw M5 cap x 30mm |
@@ -2320,12 +2456,70 @@ Machine screws and wood screws with various head styles.
 |   1 | ```screw(M6_pan_screw, 30)``` |  Screw M6 pan x 30mm |
 |   1 | ```screw(M8_cap_screw, 35)``` |  Screw M8 cap x 35mm |
 |   1 | ```screw(M8_hex_screw, 30)``` |  Screw M8 hex x 30mm |
-|   1 | ```screw(No2_screw, 30)``` |  Screw No2 pan wood x 30mm |
-|   1 | ```screw(No4_screw, 30)``` |  Screw No4 pan wood x 30mm |
+|   1 | ```screw(No2_screw, 10)``` |  Screw No2 pan wood x 10mm |
+|   1 | ```screw(No4_screw, 10)``` |  Screw No4 pan wood x 10mm |
 |   1 | ```screw(No6_cs_screw, 30)``` |  Screw No6 cs wood x 30mm |
 |   1 | ```screw(No6_screw, 30)``` |  Screw No6 pan wood x 30mm |
 
 
+<a href="#top">Top</a>
+
+---
+<a name="Scs_bearing_blocks"></a>
+## Scs_bearing_blocks
+[vitamins/scs_bearing_blocks.scad](vitamins/scs_bearing_blocks.scad) Object definitions.
+
+[vitamins/scs_bearing_block.scad](vitamins/scs_bearing_block.scad) Implementation.
+
+[tests/scs_bearing_blocks.scad](tests/scs_bearing_blocks.scad) Code for this example.
+
+### Properties
+| Function | Description |
+|:--- |:--- |
+| ```scs_bearing(type)``` | Linear bearing used |
+| ```scs_block_center_height(type)``` | Height of the center of the block |
+| ```scs_block_side_height(type)``` | Height of the side of the block, this determines the minimum screw length |
+| ```scs_hole_offset(type)``` | Offset of bearing hole from base of block |
+| ```scs_screw(type)``` | Screw type |
+| ```scs_screw_separation_x(type)``` | Screw separation in X direction |
+| ```scs_screw_separation_z(type)``` | Screw separation in Z direction |
+
+### Functions
+| Function | Description |
+|:--- |:--- |
+| ```scs_size(type)``` | Size of scs bracket bounding block |
+
+### Modules
+| Module | Description |
+|:--- |:--- |
+| ```scs_bearing_block(type)``` | Draw the specified SCS bearing block |
+| ```scs_bearing_block_assembly(type, part_thickness, screw_type, nut_type)``` | Assembly with screws and nuts in place |
+| ```scs_bearing_block_hole_positions(type)``` | Place children at hole positions |
+
+![scs_bearing_blocks](tests/png/scs_bearing_blocks.png)
+
+### Vitamins
+| Qty | Module call | BOM entry |
+| ---:|:--- |:---|
+|  12 | ```nut(M4_nut)``` |  Nut M4 x 3.2mm  |
+|  24 | ```nut(M5_nut)``` |  Nut M5 x 4mm  |
+|   1 | ```scs_bearing_block(SCS10LUU)``` |  SCS10LUU bearing block |
+|   1 | ```scs_bearing_block(SCS10UU)``` |  SCS10UU bearing block |
+|   1 | ```scs_bearing_block(SCS12LUU)``` |  SCS12LUU bearing block |
+|   1 | ```scs_bearing_block(SCS12UU)``` |  SCS12UU bearing block |
+|   1 | ```scs_bearing_block(SCS16LUU)``` |  SCS16LUU bearing block |
+|   1 | ```scs_bearing_block(SCS16UU)``` |  SCS16UU bearing block |
+|   1 | ```scs_bearing_block(SCS6UU)``` |  SCS6UU bearing block |
+|   1 | ```scs_bearing_block(SCS8LUU)``` |  SCS8LUU bearing block |
+|   1 | ```scs_bearing_block(SCS8UU)``` |  SCS8UU bearing block |
+|   4 | ```screw(M4_cap_screw, 25)``` |  Screw M4 cap x 25mm |
+|   8 | ```screw(M4_cap_screw, 30)``` |  Screw M4 cap x 30mm |
+|  16 | ```screw(M5_cap_screw, 35)``` |  Screw M5 cap x 35mm |
+|   8 | ```screw(M5_cap_screw, 45)``` |  Screw M5 cap x 45mm |
+|  12 | ```washer(M4_washer)``` |  Washer  M4 x 9mm x 0.8mm |
+|  24 | ```washer(M5_washer)``` |  Washer  M5 x 10mm x 1mm |
+
+
 <a href="#top">Top</a>
 
 ---
@@ -2415,6 +2609,58 @@ Note that modules that drill holes will return a 2D object if ```h``` is set to
 |   1 | ```sheet(Steel06, 30, 30, 2)``` |  Sheet mild steel 30mm x 30mm x 0.6mm |
 
 
+<a href="#top">Top</a>
+
+---
+<a name="Sk_brackets"></a>
+## Sk_brackets
+SK shaft support brackets
+
+
+[vitamins/sk_brackets.scad](vitamins/sk_brackets.scad) Object definitions.
+
+[vitamins/sk_bracket.scad](vitamins/sk_bracket.scad) Implementation.
+
+[tests/sk_brackets.scad](tests/sk_brackets.scad) Code for this example.
+
+### Properties
+| Function | Description |
+|:--- |:--- |
+| ```sk_base_height(type)``` | Height of base containing the screws |
+| ```sk_diameter(type)``` | Rod hole diameter |
+| ```sk_hole_offset(type)``` | Rod hole offset |
+| ```sk_screw_separation(type)``` | Separation of screws in the base |
+
+### Functions
+| Function | Description |
+|:--- |:--- |
+| ```sk_size(type)``` | Size of bracket |
+
+### Modules
+| Module | Description |
+|:--- |:--- |
+| ```sk_bracket(type)``` | SK shaft support bracket |
+| ```sk_bracket_assembly(type, part_thickness = 2, screw_type = M5_cap_screw, nut_type = undef)``` | Assembly with fasteners in place |
+| ```sk_bracket_hole_positions(type)``` | Place children at hole positions |
+
+![sk_brackets](tests/png/sk_brackets.png)
+
+### Vitamins
+| Qty | Module call | BOM entry |
+| ---:|:--- |:---|
+|   2 | ```sliding_t_nut(M4_sliding_t_nut)``` |  Nut M4 sliding T |
+|   2 | ```sliding_t_nut(M5_sliding_t_nut)``` |  Nut M5 sliding T |
+|   4 | ```nut(M5_nut, nyloc = undef)``` |  Nut M5 x 4mm  |
+|   1 | ```sk_bracket(SK10)``` |  SK10 shaft support bracket |
+|   1 | ```sk_bracket(SK12)``` |  SK12 shaft support bracket |
+|   1 | ```sk_bracket(SK16)``` |  SK16 shaft support bracket |
+|   1 | ```sk_bracket(SK8)``` |  SK8 shaft support bracket |
+|   2 | ```screw(M4_cap_screw, 12)``` |  Screw M4 cap x 12mm |
+|   6 | ```screw(M5_cap_screw, 16)``` |  Screw M5 cap x 16mm |
+|   2 | ```washer(M4_washer)``` |  Washer  M4 x 9mm x 0.8mm |
+|  10 | ```washer(M5_washer)``` |  Washer  M5 x 10mm x 1mm |
+
+
 <a href="#top">Top</a>
 
 ---
@@ -2481,7 +2727,7 @@ Filament spool models
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```spool(type)``` | Draw specified spool |
+| ```spool(type, filament_depth = 0, filament_colour = "white", filament_d = 3)``` | Draw specified spool with optional filament |
 
 ![spools](tests/png/spools.png)
 
@@ -2609,7 +2855,7 @@ NEMA stepper motor model.
 | ```NEMA_length(type)``` | Body length |
 | ```NEMA_radius(type)``` | End cap radius |
 | ```NEMA_shaft_dia(type)``` | Shaft diameter |
-| ```NEMA_shaft_length(type)``` | Shaft length above the face |
+| ```NEMA_shaft_length(type)``` | Shaft length above the face, if a list then a leadscrew: length, lead, starts |
 | ```NEMA_width(type)``` | Width of the square face |
 
 ### Functions
@@ -2621,7 +2867,7 @@ NEMA stepper motor model.
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```NEMA(type)``` | Draw specified NEMA stepper motor |
+| ```NEMA(type, shaft_angle = 0)``` | Draw specified NEMA stepper motor |
 | ```NEMA_outline(type)``` | 2D outline |
 | ```NEMA_screw_positions(type, n = 4)``` | Positions children at the screw holes |
 | ```NEMA_screws(type, screw, n = 4, screw_length = 8, earth = undef)``` | Place screws and optional earth tag |
@@ -2631,7 +2877,7 @@ NEMA stepper motor model.
 ### Vitamins
 | Qty | Module call | BOM entry |
 | ---:|:--- |:---|
-|  24 | ```screw(M3_pan_screw, 8)``` |  Screw M3 pan x 8mm |
+|  24 | ```screw(M3_pan_screw, 8)``` |  Screw M3 pan x  8mm |
 |   1 | ```NEMA(NEMA14)``` |  Stepper motor NEMA14 x 36mm |
 |   1 | ```NEMA(NEMA16)``` |  Stepper motor NEMA16 x 19.2mm |
 |   1 | ```NEMA(NEMA17S)``` |  Stepper motor NEMA17 x 34mm |
@@ -3425,7 +3671,7 @@ Star washers can be omitted by setting ```star_washers``` to false.
 |   3 | ```insert(F1BM2p5)``` |  Heatfit insert M2.5 |
 |   3 | ```insert(F1BM3)``` |  Heatfit insert M3 |
 |   3 | ```insert(F1BM4)``` |  Heatfit insert M4 |
-|   3 | ```screw(M2_cap_screw, 8)``` |  Screw M2 cap x 8mm |
+|   3 | ```screw(M2_cap_screw, 8)``` |  Screw M2 cap x  8mm |
 |   3 | ```screw(M2p5_pan_screw, 10)``` |  Screw M2.5 pan x 10mm |
 |   3 | ```screw(M3_dome_screw, 10)``` |  Screw M3 dome x 10mm |
 |   3 | ```screw(M4_dome_screw, 12)``` |  Screw M4 dome x 12mm |
@@ -3645,7 +3891,7 @@ Star washers can be omitted by setting ```star_washers``` to false.
 |   3 | ```insert(F1BM2p5)``` |  Heatfit insert M2.5 |
 |   3 | ```insert(F1BM3)``` |  Heatfit insert M3 |
 |   3 | ```insert(F1BM4)``` |  Heatfit insert M4 |
-|   3 | ```screw(M2_cap_screw, 8)``` |  Screw M2 cap x 8mm |
+|   3 | ```screw(M2_cap_screw, 8)``` |  Screw M2 cap x  8mm |
 |   3 | ```screw(M2p5_pan_screw, 10)``` |  Screw M2.5 pan x 10mm |
 |   3 | ```screw(M3_dome_screw, 10)``` |  Screw M3 dome x 10mm |
 |   3 | ```screw(M4_dome_screw, 16)``` |  Screw M4 dome x 16mm |
@@ -3789,7 +4035,7 @@ inserts don't grip well in rubber.
 | ---:|:--- |:---|
 |   1 | ```insert(F1BM3)``` |  Heatfit insert M3 |
 |   1 | ```nut(M4_nut, nyloc = true)``` |  Nut M4 x 3.2mm nyloc |
-|   1 | ```screw(M3_cap_screw, 8)``` |  Screw M3 cap x 8mm |
+|   1 | ```screw(M3_cap_screw, 8)``` |  Screw M3 cap x  8mm |
 |   1 | ```screw(M4_cap_screw, 16)``` |  Screw M4 cap x 16mm |
 |   1 | ```washer(M3_washer)``` |  Washer  M3 x 7mm x 0.5mm |
 |   2 | ```washer(M4_washer)``` |  Washer  M4 x 9mm x 0.8mm |
@@ -4030,7 +4276,7 @@ Knob with embedded hex head screw.
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```screw_knob(screw)``` | Generate the STL foe a knob to fit the specified hex screw |
+| ```screw_knob(screw)``` | Generate the STL for a knob to fit the specified hex screw |
 | ```screw_knob_assembly(screw, length)``` | Assembly with the screw in place |
 
 ![screw_knob](tests/png/screw_knob.png)
@@ -4204,7 +4450,7 @@ be fully customised by passing a list of properties.
 | Qty | Module call | BOM entry |
 | ---:|:--- |:---|
 |   2 | ```insert(F1BM3)``` |  Heatfit insert M3 |
-|   2 | ```screw(M3_pan_screw, 8)``` |  Screw M3 pan x 8mm |
+|   2 | ```screw(M3_pan_screw, 8)``` |  Screw M3 pan x  8mm |
 |   2 | ```washer(M3_penny_washer)``` |  Washer penny  M3 x 12mm x 0.8mm |
 |   2 | ```star_washer(M3_washer)``` |  Washer star M3 x 0.5mm |
 
@@ -4368,6 +4614,8 @@ Maths utilities for manipulating vectors and matrices.
 ### Functions
 | Function | Description |
 |:--- |:--- |
+| ```angle_between(v1, v2)``` | Return the angle between two vectors |
+| ```euler(R)``` | Convert a rotation matrix to a Euler rotation vector. |
 | ```identity(n, x = 1)``` | Construct an arbitrary size identity matrix |
 | ```reverse(v)``` | Reverse a vector |
 | ```rotate(a, v)``` | Generate a 4x4 rotation matrix, ```a``` can be a vector of three angles or a single angle around ```z```, or around axis ```v``` |
@@ -4378,6 +4626,7 @@ Maths utilities for manipulating vectors and matrices.
 | ```transpose(m)``` | Transpose an arbitrary size matrix |
 | ```unit(v)``` | Convert ```v``` to a unit vector |
 | ```vec3(v)``` | Return a 3 vector with the first three elements of ```v``` |
+| ```vec4(v)``` | Return a 4 vector with the first three elements of ```v``` |
 
 ![maths](tests/png/maths.png)
 
@@ -4544,9 +4793,12 @@ An additional twist around the path can be specified. If the path is closed this
 | ```after(path1, path2)``` | Translate ```path2``` so its start meets the end of ```path1``` and then concatenate |
 | ```arc_points(r, a = [90, 0, 180], al = 90)``` | Generate the points of a circular arc |
 | ```before(path1, path2)``` | Translate ```path1``` so its end meets the start of ```path2``` and then concatenate |
-| ```circle_points(r = 1, z = 0)``` | Generate the points of a circle, setting z makes a single turn spiral |
+| ```cap(facets, segment = 0, end)``` | Create the mesh for an end cap |
+| ```circle_points(r = 1, z = 0, dir = -1)``` | Generate the points of a circle, setting z makes a single turn spiral |
+| ```helical_twist_per_segment(r, pitch, sides)``` | Calculate the twist around Z that rotate_from_to() introduces |
 | ```path_length(path, i = 0, length = 0)``` | Calculated the length along a path |
 | ```rectangle_points(w, h)``` | Generate the points of a rectangle |
+| ```skin_faces(points, npoints, facets, loop, offset = 0)``` | Create the mesh for the swept volume without end caps |
 | ```sweep(path, profile, loop = false, twist = 0)``` | Generate the point list and face list of the swept volume |
 
 ### Modules
@@ -4557,6 +4809,50 @@ An additional twist around the path can be specified. If the path is closed this
 ![sweep](tests/png/sweep.png)
 
 
+<a href="#top">Top</a>
+
+---
+<a name="Thread"></a>
+## Thread
+Utilities for making threads with sweep. They can be used to model screws, nuts, studding, leadscrews, etc, and also to make printed threads.
+
+The ends can be tapered, flat or chamfered by setting the ```top``` and ```bot``` parameters to -1 for tapered, 0 for a flat cut and positive to
+specify a chamfer angle.
+
+Threads are by default solid, so the male version is wrapped around a cylinder and the female inside a tube. This can be suppressed to just get the helix, for
+example to make a printed pot with a screw top lid.
+
+Threads with a typical 60 degree angle appear too bright with OpenSCAD's primitive lighting model as they face towards the lights more than the top and sides of
+a cylinder. To get around this a colour can be passed to thread that is used to colour the cylinder and then toned down to colour the helix.
+
+Making the ends requires a CGAL intersection, which make threads relatively slow. For this reason they are generally disabled when using the GUI but can
+be enabled by setting ```$show_threads``` to ```true```. When the tests are run, by default, threads are enabled only for things that feature them like screws.
+This behaviour can be changed by setting a ```SHOW_THREADS``` environment variable to ```false``` to disable all threads and ```true``` to enable all threads.
+The same variable also affects the generation of assembly diagrams.
+
+Threads obey the $fn, $fa, $fs variables.
+
+
+[utils/thread.scad](utils/thread.scad) Implementation.
+
+[tests/thread.scad](tests/thread.scad) Code for this example.
+
+### Functions
+| Function | Description |
+|:--- |:--- |
+| ```metric_coarse_pitch(d)``` | Convert metric diameter to pitch |
+| ```thread_profile(h, crest, angle, overlap = 0.1)``` | Create thread profile path |
+
+### Modules
+| Module | Description |
+|:--- |:--- |
+| ```female_metric_thread(d, pitch, length, center = true, top = -1, bot = -1, colour = undef)``` | Create female thread with metric profile |
+| ```male_metric_thread(d, pitch, length, center = true, top = -1, bot = -1, solid = true, colour = undef)``` | Create male thread with metric profile |
+| ```thread(dia, pitch, length, profile, center = true, top = -1, bot = -1, starts = 1, solid = true, female = false, colour = undef)``` | Create male or femail thread, ends can be tapered, chamfered or square |
+
+![thread](tests/png/thread.png)
+
+
 <a href="#top">Top</a>
 
 ---
@@ -4626,7 +4922,7 @@ heirachical BOMs are also generated for real projects.
 | ---:|:--- |:---|
 |   1 | ```insert(F1BM3)``` |  Heatfit insert M3 |
 |   1 | ```widget(3)``` |  Rivit like thing for 3mm sheets |
-|   1 | ```screw(M3_cap_screw, 8)``` |  Screw M3 cap x 8mm |
+|   1 | ```screw(M3_cap_screw, 8)``` |  Screw M3 cap x  8mm |
 |   1 | ```sheet(PMMA3, 20, 20, 1)``` |  Sheet acrylic 20mm x 20mm x 3mm |
 |   1 | ```washer(M3_washer)``` |  Washer  M3 x 7mm x 0.5mm |
 |   1 | ```star_washer(M3_washer)``` |  Washer star M3 x 0.5mm |
@@ -4834,11 +5130,12 @@ Small holes can get away without it, but they print better with truncated teardr
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```semi_teardrop(h, r, d = undef, center = true)``` | A semi teardrop in the positive Y domain |
-| ```teardrop(h, r, center = true, truncate = true)``` | For making horizontal holes that don't need support material, set ```truncate = false``` to make traditional RepRap teardrops that don't even need bridging |
-| ```teardrop_plus(h, r, center = true, truncate = true)``` | Slightly bigger teardrop to allow for the 3D printing staircase effect |
-| ```tearslot(h, r, w, center = true)``` | A horizontal slot that doesn't need support material |
-| ```vertical_tearslot(h, r, l, center = true)``` | A vertical slot that doesn't need support material |
+| ```semi_teardrop(h, r, d = undef, center = true, chamfer = 0)``` | A semi teardrop in the positive Y domain |
+| ```teardrop(h, r, center = true, truncate = true, chamfer = 0)``` | For making horizontal holes that don't need support material, set ```truncate = false``` to make traditional RepRap teardrops that don't even need bridging |
+| ```teardrop_chamfer(h, center, chamfer)``` | Helper module for adding chamfer to a teardrop |
+| ```teardrop_plus(h, r, center = true, truncate = true, chamfer = 0)``` | Slightly bigger teardrop to allow for the 3D printing staircase effect |
+| ```tearslot(h, r, w, center = true, chamfer = 0)``` | A horizontal slot that doesn't need support material |
+| ```vertical_tearslot(h, r, l, center = true, chamfer = 0)``` | A vertical slot that doesn't need support material |
 
 ![teardrops](tests/png/teardrops.png)
 

scripts/exports.py

@@ -85,48 +85,49 @@ def make_parts(target, part_type, parts = None):
     #
     lib_dir = os.environ['OPENSCADPATH'] + '/NopSCADlib/printed'
     module_suffix = '_dxf' if part_type == 'svg' else '_' + part_type
-    for dir in [source_dir, lib_dir]:
-        for filename in os.listdir(dir):
-            if filename[-5:] == ".scad":
-                #
-                # find any modules ending in _<part_type>
-                #
-                with open(dir + "/" + filename, "r") as f:
-                    for line in f.readlines():
-                        words = line.split()
-                        if(len(words) and words[0] == "module"):
-                            module = words[1].split('(')[0]
-                            if module.endswith(module_suffix):
-                                base_name = module[:-4]
-                                part = base_name + '.' + part_type
-                                if part in targets:
-                                    #
-                                    # make a file to use the module
-                                    #
-                                    part_maker_name = part_type + ".scad"
-                                    with open(part_maker_name, "w") as f:
-                                        f.write("use <%s/%s>\n" % (dir, filename))
-                                        f.write("%s();\n" % module);
-                                    #
-                                    # Run openscad on the created file
-                                    #
-                                    part_file = target_dir + "/" + part
-                                    dname = deps_name(deps_dir, filename)
-                                    changed = check_deps(part_file, dname)
-                                    changed = times.check_have_time(changed, part)
-                                    if part_type == 'stl' and not changed and not part in bounds_map:
-                                        changed = "No bounds"
-                                    if changed:
-                                        print(changed)
-                                        t = time.time()
-                                        openscad.run("-D$bom=1", "-d", dname, "-o", part_file, part_maker_name)
-                                        times.add_time(part, t)
-                                        if part_type == 'stl':
-                                            bounds = c14n_stl.canonicalise(part_file)
-                                            bounds_map[part] = bounds
+    for dir in [source_dir, source_dir + '/printed', lib_dir]:
+        if os.path.isdir(dir):
+            for filename in os.listdir(dir):
+                if filename[-5:] == ".scad":
+                    #
+                    # find any modules ending in _<part_type>
+                    #
+                    with open(dir + "/" + filename, "r") as f:
+                        for line in f.readlines():
+                            words = line.split()
+                            if(len(words) and words[0] == "module"):
+                                module = words[1].split('(')[0]
+                                if module.endswith(module_suffix):
+                                    base_name = module[:-4]
+                                    part = base_name + '.' + part_type
+                                    if part in targets:
+                                        #
+                                        # make a file to use the module
+                                        #
+                                        part_maker_name = part_type + ".scad"
+                                        with open(part_maker_name, "w") as f:
+                                            f.write("use <%s/%s>\n" % (dir, filename))
+                                            f.write("%s();\n" % module);
+                                        #
+                                        # Run openscad on the created file
+                                        #
+                                        part_file = target_dir + "/" + part
+                                        dname = deps_name(deps_dir, filename)
+                                        changed = check_deps(part_file, dname)
+                                        changed = times.check_have_time(changed, part)
+                                        if part_type == 'stl' and not changed and not part in bounds_map:
+                                            changed = "No bounds"
+                                        if changed:
+                                            print(changed)
+                                            t = time.time()
+                                            openscad.run("-D$bom=1", "-d", dname, "-o", part_file, part_maker_name)
+                                            times.add_time(part, t)
+                                            if part_type == 'stl':
+                                                bounds = c14n_stl.canonicalise(part_file)
+                                                bounds_map[part] = bounds
 
-                                    targets.remove(part)
-                                    os.remove(part_maker_name)
+                                        targets.remove(part)
+                                        os.remove(part_maker_name)
     #
     # Write new bounds file
     #

scripts/openscad.py

@@ -24,7 +24,7 @@ from __future__ import print_function
 
 import subprocess, sys
 
-def _run(args, silent):
+def run_list(args, silent = False):
     cmd = ["openscad"] + args
     if not silent:
         for arg in cmd:
@@ -39,7 +39,7 @@ def _run(args, silent):
         sys.exit(rc)
 
 def run(*args):
-    _run(list(args), False)
+    run_list(list(args), False)
 
 def run_silent(*args):
-    _run(list(args), True);
+    run_list(list(args), True);

scripts/options.py

@@ -0,0 +1,49 @@
+#
+# NopSCADlib Copyright Chris Palmer 2020
+# nop.head@gmail.com
+# hydraraptor.blogspot.com
+#
+# This file is part of NopSCADlib.
+#
+# NopSCADlib 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.
+#
+# NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with NopSCADlib.
+# If not, see <https://www.gnu.org/licenses/>.
+#
+
+# Set command line options from enviroment variables and check if they have changed
+
+import json, os, deps
+
+def check_options(dir = '.'):
+    global options, options_mtime
+    options = { "show_threads": str(os.getenv("SHOW_THREADS")) }
+    options_fname = dir + '/options.json'
+    try:
+        with open(options_fname) as json_file:
+            last_options = json.load(json_file)
+    except:
+        last_options = {}
+    if last_options != options:
+        with open(options_fname, 'w') as outfile:
+            json.dump(options, outfile, indent = 4)
+    options_mtime = deps.mtime(options_fname)
+
+def have_changed(changed, target):
+    if not changed and deps.mtime(target) < options_mtime:
+        return "command line options changed"
+    return changed
+
+def list():
+    result = []
+    for name in options.keys():
+        value = options[name]
+        if value != 'None':
+            result.append('-D$' + name + '=' + value)
+    return result

scripts/tests.py

@@ -27,6 +27,7 @@ import openscad
 import subprocess
 import bom
 import times
+import options
 import time
 import json
 import shutil
@@ -96,6 +97,7 @@ def tests(tests):
     index = {}
     bodies = {}
     times.read_times()
+    options.check_options(deps_dir)
     #
     # Make cover pic if does not exist as very slow. Delete it to force an update.
     #
@@ -190,11 +192,12 @@ def tests(tests):
             oldest = png_name if mtime(png_name) < mtime(bom_name) else bom_name
             changed = check_deps(oldest, dname)
             changed = times.check_have_time(changed, scad_name)
+            changed = options.have_changed(changed, oldest)
             if changed:
                 print(changed)
                 t = time.time()
                 tmp_name = 'tmp.png'
-                openscad.run("-D", "$bom=2", colour_scheme, "--projection=p", "--imgsize=%d,%d" % (w, h), "--camera=0,0,0,70,0,315,500", "--autocenter", "--viewall", "-d", dname, "-o", tmp_name, scad_name);
+                openscad.run_list(options.list() + ["-D$bom=2", colour_scheme, "--projection=p", "--imgsize=%d,%d" % (w, h), "--camera=0,0,0,70,0,315,500", "--autocenter", "--viewall", "-d", dname, "-o", tmp_name, scad_name]);
                 times.add_time(scad_name, t)
                 do_cmd(["magick", tmp_name, "-trim", "-resize", "1000x600", "-bordercolor", background, "-border", "10", tmp_name])
                 update_image(tmp_name, png_name)

scripts/views.py

@@ -28,6 +28,7 @@ import openscad
 from tests import do_cmd, update_image, colour_scheme, background
 import time
 import times
+import options
 from deps import *
 import os
 import json
@@ -102,6 +103,7 @@ def views(target, do_assemblies = None):
         os.makedirs(deps_dir)
 
     times.read_times(target_dir)
+    options.check_options(deps_dir)
     bounds_fname = top_dir + 'stls/bounds.json'
     with open(bounds_fname) as json_file:
         bounds_map = json.load(json_file)
@@ -122,65 +124,67 @@ def views(target, do_assemblies = None):
     #
     main_blurb = None
     lib_dir = os.environ['OPENSCADPATH'] + '/NopSCADlib/printed'
-    for dir in [source_dir, lib_dir]:
-        for filename in os.listdir(dir):
-            if filename.endswith('.scad'):
-                #
-                # find any modules with names ending in _assembly
-                #
-                with open(dir + "/" + filename, "r") as f:
-                    lines = f.readlines()
-                line_no = 0
-                for line in lines:
-                    words = line.split()
-                    if len(words) and words[0] == "module":
-                        module = words[1].split('(')[0]
-                        if is_assembly(module):
-                            if module in assemblies:
-                                #
-                                # Scrape the assembly instructions
-                                #
-                                for ass in flat_bom:
-                                    if ass["name"] == module:
-                                        if not "blurb" in ass:
-                                            ass["blurb"] = blurb.scrape_module_blurb(lines[:line_no])
-                                        break
-                                if not do_assemblies or module in do_assemblies:
+    for dir in [source_dir, source_dir + '/printed', lib_dir]:
+        if os.path.isdir(dir):
+            for filename in os.listdir(dir):
+                if filename.endswith('.scad'):
+                    #
+                    # find any modules with names ending in _assembly
+                    #
+                    with open(dir + "/" + filename, "r") as f:
+                        lines = f.readlines()
+                    line_no = 0
+                    for line in lines:
+                        words = line.split()
+                        if len(words) and words[0] == "module":
+                            module = words[1].split('(')[0]
+                            if is_assembly(module):
+                                if module in assemblies:
                                     #
-                                    # make a file to use the module
+                                    # Scrape the assembly instructions
                                     #
-                                    png_maker_name = 'png.scad'
-                                    with open(png_maker_name, "w") as f:
-                                        f.write("use <%s/%s>\n" % (dir, filename))
-                                        f.write("%s();\n" % module);
-                                    #
-                                    # Run openscad on th created file
-                                    #
-                                    dname = deps_name(deps_dir, filename)
-                                    for explode in [0, 1]:
-                                        png_name = target_dir + '/' + module + '.png'
-                                        if not explode:
-                                            png_name = png_name.replace('_assembly', '_assembled')
-                                        changed = check_deps(png_name, dname)
-                                        changed = times.check_have_time(changed, png_name)
-                                        tmp_name = 'tmp.png'
-                                        if changed:
-                                            print(changed)
-                                            t = time.time()
-                                            openscad.run("-D$pose=1", "-D$explode=%d" % explode, colour_scheme, "--projection=p", "--imgsize=4096,4096", "--autocenter", "--viewall", "-d", dname, "-o", tmp_name, png_maker_name);
-                                            times.add_time(png_name, t)
-                                            do_cmd(["magick", tmp_name, "-trim", "-resize", "1004x1004", "-bordercolor", background, "-border", "10", tmp_name])
-                                            update_image(tmp_name, png_name)
-                                        tn_name = png_name.replace('.png', '_tn.png')
-                                        if mtime(png_name) > mtime(tn_name):
-                                            do_cmd(("magick "+ png_name + " -trim -resize 280x280 -background " + background + " -gravity Center -extent 280x280 -bordercolor " + background + " -border 10 " + tmp_name).split())
-                                            update_image(tmp_name, tn_name)
-                                    os.remove(png_maker_name)
-                                done_assemblies.append(module)
-                            else:
-                                if module == 'main_assembly':
-                                    main_blurb = blurb.scrape_module_blurb(lines[:line_no])
-                    line_no += 1
+                                    for ass in flat_bom:
+                                        if ass["name"] == module:
+                                            if not "blurb" in ass:
+                                                ass["blurb"] = blurb.scrape_module_blurb(lines[:line_no])
+                                            break
+                                    if not do_assemblies or module in do_assemblies:
+                                        #
+                                        # make a file to use the module
+                                        #
+                                        png_maker_name = 'png.scad'
+                                        with open(png_maker_name, "w") as f:
+                                            f.write("use <%s/%s>\n" % (dir, filename))
+                                            f.write("%s();\n" % module);
+                                        #
+                                        # Run openscad on the created file
+                                        #
+                                        dname = deps_name(deps_dir, filename)
+                                        for explode in [0, 1]:
+                                            png_name = target_dir + '/' + module + '.png'
+                                            if not explode:
+                                                png_name = png_name.replace('_assembly', '_assembled')
+                                            changed = check_deps(png_name, dname)
+                                            changed = times.check_have_time(changed, png_name)
+                                            changed = options.have_changed(changed, png_name)
+                                            tmp_name = 'tmp.png'
+                                            if changed:
+                                                print(changed)
+                                                t = time.time()
+                                                openscad.run_list(options.list() + ["-D$pose=1", "-D$explode=%d" % explode, colour_scheme, "--projection=p", "--imgsize=4096,4096", "--autocenter", "--viewall", "-d", dname, "-o", tmp_name, png_maker_name]);
+                                                times.add_time(png_name, t)
+                                                do_cmd(["magick", tmp_name, "-trim", "-resize", "1004x1004", "-bordercolor", background, "-border", "10", tmp_name])
+                                                update_image(tmp_name, png_name)
+                                            tn_name = png_name.replace('.png', '_tn.png')
+                                            if mtime(png_name) > mtime(tn_name):
+                                                do_cmd(("magick "+ png_name + " -trim -resize 280x280 -background " + background + " -gravity Center -extent 280x280 -bordercolor " + background + " -border 10 " + tmp_name).split())
+                                                update_image(tmp_name, tn_name)
+                                        os.remove(png_maker_name)
+                                    done_assemblies.append(module)
+                                else:
+                                    if module == 'main_assembly':
+                                        main_blurb = blurb.scrape_module_blurb(lines[:line_no])
+                        line_no += 1
     times.print_times()
     #
     # Build the document

tests/belts.scad

@@ -67,7 +67,7 @@ module belt_test() {
     translate([-25, 0])
         layout([for(b = belts) belt_width(b)], 10)
             rotate([0, 90, 0])
-                belt(belts[$i], [[0, 0, 20], [0, 1, 20]]);
+                belt(belts[$i], [[0, 0, 20], [0, 1, 20]], belt_colour = $i%2==0 ? grey90 : grey20, tooth_colour = $i%2==0 ? grey70 : grey50);
 }
 
 if($preview)

tests/d_connectors.scad

@@ -35,4 +35,5 @@ module d_connectors()
                 }
 
 if($preview)
-    d_connectors();
+    let($show_threads = true)
+        d_connectors();

tests/extrusions.scad

@@ -0,0 +1,30 @@
+//
+// NopSCADlib Copyright Chris Palmer 2020
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib 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.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+//
+include <../core.scad>
+use <../utils/layout.scad>
+
+include <../vitamins/extrusions.scad>
+
+module extrusions()
+    layout([for(e = extrusions) extrusion_width(e)], 10)
+        extrusion(extrusions[$i], 80);
+
+if ($preview)
+    extrusions();
+

tests/inserts.scad

@@ -37,4 +37,5 @@ module inserts() {
 }
 
 if($preview)
-    inserts();
+    let($show_threads = true)
+        inserts();

tests/kp_pillow_blocks.scad

@@ -0,0 +1,34 @@
+//
+// NopSCADlib Copyright Chris Palmer 2018
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib 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.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+//
+include <../core.scad>
+use <../utils/layout.scad>
+
+include <../vitamins/kp_pillow_blocks.scad>
+include <../vitamins/nuts.scad>
+
+module kp_pillow_blocks() {
+    screws = [M4_cap_screw, M5_cap_screw, M5_cap_screw];
+    nuts = [M4_sliding_t_nut, M5_sliding_t_nut, M5_nut];
+    layout([for(k = kp_pillow_blocks) 2 * kp_size(k)[1]])
+        kp_pillow_block_assembly(kp_pillow_blocks[$i], screw_type = screws[$i], nut_type = nuts[$i]);
+}
+
+if($preview)
+    kp_pillow_blocks();
+

tests/leadnuts.scad

@@ -27,4 +27,5 @@ module leadnuts()
         leadnut(leadnuts[$i]);
 
 if($preview)
-    leadnuts();
+    let($show_threads = true)
+        leadnuts();

tests/linear_bearings.scad

@@ -22,8 +22,12 @@ use <../utils/layout.scad>
 include <../vitamins/linear_bearings.scad>
 
 module linear_bearings()
-    layout([for(b = linear_bearings) 2 * bearing_radius(b)])
+    layout([for(b = linear_bearings) 2 * bearing_radius(b)]) {
         linear_bearing(linear_bearings[$i]);
 
+        translate([0, 30])
+            linear_bearing(long_linear_bearings[$i]);
+    }
+
 if($preview)
     linear_bearings();

tests/maths.scad

@@ -56,7 +56,7 @@ module maths() {
     //
     z = [0, 0, 1];
     v = cross(u, z);
-    a = acos(u * z);
+    a = angle_between(u, z);
 
 
     l = 20;
@@ -64,6 +64,11 @@ module maths() {
         translate_z(l)
             vflip()
                 arrow(l);
+
+    //
+    // Test Euler
+    //
+    assert(euler(rotate(r)) == r, "euler() failed");
 }
 
 rotate(45)

tests/nuts.scad

@@ -22,13 +22,12 @@ use <../utils/layout.scad>
 include <../vitamins/screws.scad>
 
 module nuts() {
-    for(nyloc = [false, true])
-        translate([0, nyloc ? 20 : 0])
-            layout([for(n = nuts) 2 * nut_radius(n)], 5)
-                nut(nuts[$i], nyloc);
+    layout([for(n = nuts) 2 * nut_radius(n)], 5) let(n = nuts[$i]) {
+        for(nyloc = [false, true])
+            translate([0, nyloc ? 20 : 0])
+                nut(n, nyloc);
 
-    translate([0, 40])
-        layout([for(n = nuts) 2 * nut_radius(n)], 5) let(n = nuts[$i]) {
+        translate([0, 40]) {
             if(n == M3_nut)
                 nut(n, brass = true);
 
@@ -45,7 +44,28 @@ module nuts() {
             if(n == M8_nut)
                 #nut_trap(M8_cap_screw, n, h = 30);
         }
+
+        translate([0, 60]) {
+            if(n == M3_nut)
+                sliding_t_nut(M3_sliding_t_nut);
+
+            if(n == M4_nut)
+                sliding_t_nut(M4_sliding_t_nut);
+
+            if(n == M5_nut)
+                sliding_t_nut(M5_sliding_t_nut);
+        }
+
+        translate([0, 80]) {
+            if(n == M3_nut)
+                sliding_t_nut(M3_hammer_nut);
+
+            if(n == M4_nut)
+                sliding_t_nut(M4_hammer_nut);
+       }
+    }
 }
 
 if($preview)
-    nuts();
+    let($show_threads = true)
+        nuts();

tests/opengrab.scad

@@ -29,4 +29,5 @@ module opengrab_test() {
 }
 
 if($preview)
-    opengrab_test();
+    let($show_threads = true)
+        opengrab_test();

tests/pcb_mount.scad

@@ -16,7 +16,7 @@
 // You should have received a copy of the GNU General Public License along with NopSCADlib.
 // If not, see <https://www.gnu.org/licenses/>.
 //
-include <../lib.scad>
+include <../core.scad>
 use <../printed/pcb_mount.scad>
 
 PI_IO = ["PI_IO", "PI_IO V2",       35.56, 25.4, 1.6, 0,    0,   0, "green", true, [],

tests/pillars.scad

@@ -26,4 +26,5 @@ module pillars()
         pillar(pillars[$i]);
 
 if($preview)
-    pillars();
+    let($show_threads = true)
+        pillars();

tests/rails.scad

@@ -34,7 +34,7 @@ module rails()
             nut = screw_nut(screw);
             washer = screw_washer(screw);
 
-            rail_assembly(rail, length, rail_travel(rail, length) / 2);
+            rail_assembly(rail, length, rail_travel(rail, length) / 2, $i<2 ? grey20 : "green", $i<2 ? grey20 : "red");
 
             rail_screws(rail, length, sheet + nut_thickness(nut, true) + washer_thickness(washer));
 

tests/rockers.scad

@@ -21,9 +21,13 @@ use <../utils/layout.scad>
 
 include <../vitamins/rockers.scad>
 
-module rockers()
-    layout([for(r = rockers) rocker_flange_w(r)], 5)
+module rockers() {
+    layout([for(r = rockers) rocker_flange_w(r)], 5) {
         rocker(rockers[$i]);
+        translate([0, 25])
+            rocker(rockers[$i], $i==0 ? "red" : "green");
+    }
+}
 
 if($preview)
     rockers();

tests/rod.scad

@@ -24,13 +24,23 @@ include <../vitamins/linear_bearings.scad>
 use <../vitamins/rod.scad>
 
 module rods()
-    layout([for(b = linear_bearings) 2 * bearing_radius(b)]) {
+    layout([for(b = linear_bearings) 2 * bearing_radius(b)]) let(d = bearing_rod_dia(linear_bearings[$i])){
 
-        rod(bearing_rod_dia(linear_bearings[$i]), 80);
+        rod(d, 80);
 
-        translate([0, 20])
-            studding(bearing_rod_dia(linear_bearings[$i]), 80);
+        translate([0, 30])
+            studding(d, 80);
+
+        if(d >= 6)
+            translate([0, 60]) {
+                starts = d > 6 ? 4 : 1;
+                pitch = d > 14 ? 4
+                               : d > 10 ? 3 : 2;
+                let($show_threads = true)
+                    leadscrew(d, 80, starts * pitch, starts);
+            }
     }
 
 if($preview)
-    rods();
+    let($show_threads = true)
+        rods();

tests/screws.scad

@@ -25,13 +25,15 @@ for(y = [0 : len(screw_lists) -1])
     for(x = [0 : len(screw_lists[y]) -1]) {
         screw = screw_lists[y][x];
         if(screw) {
-             length = screw_max_thread(screw)
-                    ? screw_longer_than(screw_max_thread(screw) + 5)
-                    : screw_head_type(screw) == hs_grub ? 6 : 30;
+             length = screw_head_type(screw) == hs_grub ? 6
+                    : screw_radius(screw) <= 1.5 ? 10
+                    : screw_max_thread(screw) ? screw_longer_than(screw_max_thread(screw) + 5)
+                    : 30;
             translate([x * 20, y * 20])
                 screw(screw, length);
         }
     }
 
 if($preview)
-    screws();
+    let($show_threads = true)
+        screws();

tests/scs_bearing_blocks.scad

@@ -0,0 +1,35 @@
+//
+// NopSCADlib Copyright Chris Palmer 2020
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib 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.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+//
+include <../core.scad>
+use <../utils/layout.scad>
+
+include <../vitamins/scs_bearing_blocks.scad>
+
+module scs_bearing_blocks()
+    layout([for(s = scs_bearing_blocks) 2 * scs_size(s)[0]]) {
+        part_thickness = 5;
+        scs_bearing_block_assembly(scs_bearing_blocks[$i], part_thickness);
+
+        if($i > 0) // skip $i==0, since no SCS6LUU long variant to match SCS6UU
+            translate([0, 60])
+                scs_bearing_block_assembly(scs_bearing_blocks_long[$i - 1], part_thickness);
+    }
+
+if($preview)
+    scs_bearing_blocks();

tests/sk_brackets.scad

@@ -0,0 +1,33 @@
+//
+// NopSCADlib Copyright Chris Palmer 2018
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib 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.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+//
+include <../core.scad>
+use <../utils/layout.scad>
+
+include <../vitamins/sk_brackets.scad>
+
+module sk_brackets() {
+    screws = [M5_cap_screw, M5_cap_screw, M4_cap_screw, M5_cap_screw];
+    nuts = [undef, M5_nut, M4_sliding_t_nut, M5_sliding_t_nut];
+    layout([for(s = sk_brackets) 1.5 * sk_size(s)[1]])
+        sk_bracket_assembly(sk_brackets[$i], screw_type = screws[$i], nut_type = nuts[$i]);
+}
+
+if($preview)
+    let($show_threads = true)
+        sk_brackets();

tests/spools.scad

@@ -23,9 +23,9 @@ use <../utils/layout.scad>
 include <../vitamins/spools.scad>
 
 module spools()
-    layout([for(s = spools) spool_height(s)], 100)
+    layout([for(s = spools) spool_height(s)], 100) let(s = spools[$i])
         rotate([90, 0, 90])
-            spool(spools[$i]);
+            spool(s, filament_depth =  spool_depth(s) / 2, filament_colour = [pp1_colour, pp2_colour, pp3_colour, pp4_colour][$i % 4], filament_d = $i ? 3 : 1.75);
 
 if($preview)
     spools();

tests/sweep.scad

@@ -44,7 +44,7 @@ knot = [ for(i=[0:.2:359])
            (19*cos(3*i) + 40)*sin(2*i),
             19*sin(3*i) ] ];
 
-sweep(knot, L_points, loop = true, twist = 0);
+sweep(knot, L_points, loop = true);
 
 p = transform_points([[0,0,0], [20,0,5], [10,30,4], [0,0,0], [0,0,20]], scale(10));
 n = 100;

tests/teardrops.scad

@@ -22,25 +22,47 @@ include <../core.scad>
 module teardrops() {
     color(pp1_colour)
         rotate([90, 0, -45])
-            linear_extrude(height = 3)
-                difference() {
-                    square(40);
+            difference() {
+                linear_extrude(height = 3) {
+                    difference() {
+                        square([80, 40]);
+
+                        translate([10, 10])
+                            teardrop(h = 0, r = 3);
+
+                        translate([10, 20])
+                            teardrop_plus(h = 0, r = 3);
+
+                        translate([20, 30])
+                            tearslot(h = 0, r = 3, w = 10);
+
+                        translate([30, 15])
+                            vertical_tearslot(h = 0, r =3, l = 10);
+
+                        translate([20, 10])
+                            semi_teardrop(h = 0, r = 3);
+                    }
+                }
+                translate([40, 0, 1.5]) {
+                    h = 3 + eps;
+                    chamfer = 0.5;
 
                     translate([10, 10])
-                        teardrop(h = 0, r = 3);
+                        teardrop(h = h, r = 3, chamfer = chamfer);
 
                     translate([10, 20])
-                        teardrop_plus(h = 0, r = 3);
+                        teardrop_plus(h = h, r = 3, chamfer = chamfer);
 
                     translate([20, 30])
-                        tearslot(h = 0, r = 3, w = 10);
+                        tearslot(h = h, r = 3, w = 10, chamfer = chamfer);
 
                     translate([30, 15])
-                        vertical_tearslot(h = 0, r =3, l = 10);
+                        vertical_tearslot(h = h, r =3, l = 10, chamfer = chamfer);
 
                     translate([20, 10])
-                        semi_teardrop(h = 0, r = 3);
+                        semi_teardrop(h = h, r = 3, chamfer = chamfer);
                 }
+            }
 }
 
 teardrops();

tests/thread.scad

@@ -0,0 +1,52 @@
+//
+// NopSCADlib Copyright Chris Palmer 2020
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib 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.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+//
+include <../core.scad>
+use <../utils/thread.scad>
+
+pitch = 2;
+starts = 4;
+
+profile = thread_profile(pitch / 2, pitch * 0.366, 30);
+
+module threads()
+    for(female = [false, true]) translate([0, female ? -20 : 0]) {
+    length = female ? 8  : 40;
+    dia = female ? 8 : 8 - pitch;
+    colour = female ? brass : silver;
+
+    thread(dia, starts * pitch, length, profile, starts = starts, top = 45, bot = 45, female = female, colour = colour);
+
+    color(colour)
+        translate([20, 0])
+            thread(dia, starts * pitch, length, profile, starts = starts, top = 0, bot = 0, female = female);
+
+    translate([40, 0])
+        thread(dia, starts * pitch, length, profile, starts = starts, top = -1, bot = -1, female = female, colour = colour);
+
+    color(colour)
+        translate([60, 0])
+            thread(dia, 2 * pitch, length, profile, starts = 2, top = -1, bot = -1, female = female);
+
+    color(colour)
+        translate([80, 0])
+            thread(dia, pitch, length, profile, starts = 1, top = -1, bot = -1, female = female);
+}
+
+let($show_threads = true)
+    threads();

tests/toggles.scad

@@ -27,4 +27,5 @@ module toggles()
          toggle(toggles[$i], 3);
 
 if($preview)
-    toggles();
+    let($show_threads = true)
+        toggles();

utils/core/global.scad

@@ -43,7 +43,7 @@ module ellipse(xr, yr) scale([1, yr / xr]) circle4n(xr);
 
 module extrude_if(h, center = true)                 //! Extrudes 2D object to 3D when ```h``` is nonzero, otherwise leaves it 2D
     if(h)
-        linear_extrude(height = h, center = center) // 3D
+        linear_extrude(height = h, center = center, convexity = 2) // 3D
             children();
     else
         children();                                 // 2D

utils/core/teardrops.scad

@@ -21,45 +21,106 @@
 //! For making horizontal holes that don't need support material.
 //! Small holes can get away without it, but they print better with truncated teardrops.
 //
-module teardrop(h, r, center = true, truncate = true) //! For making horizontal holes that don't need support material, set ```truncate = false``` to make traditional RepRap teardrops that don't even need bridging
-    render(convexity = 5)
-        extrude_if(h, center)
-           hull() {
-                circle4n(r);
-
-                if(truncate)
-                    translate([0, r / 2])
-                        square([2 * r * (sqrt(2) - 1), r], center = true);
-                else
-                    polygon([[0, 0], [eps, 0], [0, r * sqrt(2)]]);
-            }
-
-module semi_teardrop(h, r, d = undef, center = true) //! A semi teardrop in the positive Y domain
-    render(convexity = 5)
-        extrude_if(h, center)
-            intersection() {
-                R = is_undef(d) ? r : d / 2;
-                teardrop(r = R, h = 0);
-
-                sq = R + 1;
-                translate([-sq, 0])
-                    square([2 * sq, sq]);
-            }
-
-module teardrop_plus(h, r, center = true, truncate = true) //! Slightly bigger teardrop to allow for the 3D printing staircase effect
-    teardrop(h, r + layer_height / 4, center, truncate);
-
-module tearslot(h, r, w, center = true) //! A horizontal slot that doesn't need support material
-    extrude_if(h, center)
+module teardrop(h, r, center = true, truncate = true, chamfer = 0) { //! For making horizontal holes that don't need support material, set ```truncate = false``` to make traditional RepRap teardrops that don't even need bridging
+    module teardrop_2d(r, truncate) {
         hull() {
-            translate([-w/2,0,0]) teardrop(r = r, h = 0);
-            translate([ w/2,0,0]) teardrop(r = r, h = 0);
+            circle4n(r);
+            if(truncate)
+                translate([0, r / 2])
+                    square([2 * r * (sqrt(2) - 1), r], center = true);
+            else
+                polygon([[0, 0], [eps, 0], [0, r * sqrt(2)]]);
         }
+    }
+
+    render(convexity = 5)
+        extrude_if(h, center)
+            teardrop_2d(r, truncate);
+
+    teardrop_chamfer(h, center, chamfer) {
+        linear_extrude(eps, center = true)
+            teardrop_2d(r + chamfer / 2, truncate);
+        translate_z(-chamfer / 2)
+            linear_extrude(eps, center = true)
+                teardrop_2d(r, truncate);
+    }
+}
+
+module semi_teardrop(h, r, d = undef, center = true, chamfer = 0) { //! A semi teardrop in the positive Y domain
+    module semi_teardrop_2d(r, d) {
+        intersection() {
+            R = is_undef(d) ? r : d / 2;
+            teardrop(r = R, h = 0);
+
+            sq = R + 1;
+            translate([-sq, 0])
+                square([2 * sq, sq]);
+        }
+    }
+
+    render(convexity = 5)
+        extrude_if(h, center)
+            semi_teardrop_2d(r, d);
+
+    teardrop_chamfer(h, center, chamfer) {
+        linear_extrude(eps, center = true)
+            semi_teardrop_2d(r + chamfer / 2, d);
+        translate_z(-chamfer / 2)
+            linear_extrude(eps, center = true)
+                semi_teardrop_2d(r, d);
+    }
+}
+
+module teardrop_plus(h, r, center = true, truncate = true, chamfer = 0) //! Slightly bigger teardrop to allow for the 3D printing staircase effect
+    teardrop(h, r + layer_height / 4, center, truncate, chamfer);
+
+module tearslot(h, r, w, center = true, chamfer = 0) { //! A horizontal slot that doesn't need support material
+    module tearslot_2d(r, w) {
+        hull() {
+            translate([-w / 2, 0]) teardrop(r = r, h = 0);
+            translate([w / 2, 0]) teardrop(r = r, h = 0);
+        }
+    }
 
-module vertical_tearslot(h, r, l, center = true) //! A vertical slot that doesn't need support material
     extrude_if(h, center)
+        tearslot_2d(r, w);
+
+    teardrop_chamfer(h, center, chamfer) {
+        linear_extrude(eps, center = true)
+            tearslot_2d(r + chamfer / 2, w);
+        translate_z(-chamfer / 2)
+            linear_extrude(eps, center = true)
+                tearslot_2d(r, w);
+    }
+}
+
+module vertical_tearslot(h, r, l, center = true, chamfer = 0) { //! A vertical slot that doesn't need support material
+    module vertical_tearslot_2d(r, l) {
         hull() {
             translate([0,  l / 2]) teardrop(0, r, true);
-            translate([0, -l / 2])
-                circle4n(r);
+            translate([0, -l / 2]) circle4n(r);
         }
+    }
+
+    extrude_if(h, center)
+        vertical_tearslot_2d(r, l);
+
+    teardrop_chamfer(h, center, chamfer) {
+        linear_extrude(eps, center = true)
+            vertical_tearslot_2d(r + chamfer / 2, l);
+        translate_z(-chamfer / 2)
+            linear_extrude(eps, center = true)
+                vertical_tearslot_2d(r, l);
+    }
+}
+
+module teardrop_chamfer(h, center, chamfer) { //! Helper module for adding chamfer to a teardrop
+    if(h && chamfer)
+        translate_z(center ? 0 : h / 2)
+            for(m = [0, 1])
+                mirror([0, 0, m])
+                    translate_z((h - eps ) / 2)
+                        hull()
+                            children();
+}
+

utils/maths.scad

@@ -39,9 +39,9 @@ function rotate(a, v) = //! Generate a 4x4 rotation matrix, ```a``` can be a vec
                       sy = sin(av[1]),
                       sz = sin(av[2]))
                           [
-                              [ cy * cz, cz * sx * sy - cx * sz, cx * cz * sy + sx * sz, 0],
-                              [ cy * sz, cx * cz + sx * sy * sz,-cz * sx + cx * sy * sz, 0],
-                              [-sy,      cy * sx,                cx * cy,                0],
+                              [ cy * cz, sx * sy * cz - cx * sz, cx * sy * cz + sx * sz, 0],
+                              [ cy * sz, sx * sy * sz + cx * cz, cx * sy * sz - sx * cz, 0],
+                              [-sy,      sx * cy,                cx * cy,                0],
                               [ 0,       0,                      0,                      1]
                           ]
                 : let(s = sin(a),
@@ -65,6 +65,7 @@ function scale(v) = let(s = is_list(v) ? v : [v, v, v]) //!  Generate a 4x4 matr
                         ];
 
 function vec3(v) = [v.x, v.y, v.z]; //! Return a 3 vector with the first three elements of ```v```
+function vec4(v) = [v.x, v.y, v.z, 1]; //! Return a 4 vector with the first three elements of ```v```
 function transform(v, m) = vec3(m * [v.x, v.y, v.z, 1]); //! Apply 4x4 transform to a 3 vector by extending it and cropping it again
 function transform_points(path, m) = [for(p = path) transform(p, m)]; //! Apply transform to a path
 function unit(v) = let(n = norm(v)) n ? v / n : v; //! Convert ```v``` to a unit vector
@@ -74,3 +75,11 @@ function transpose(m) = [ for(j = [0 : len(m[0]) - 1]) [ for(i = [0 : len(m) - 1
 function identity(n, x = 1) = [for(i = [0 : n - 1]) [for(j = [0 : n - 1]) i == j ? x : 0] ]; //! Construct an arbitrary size identity matrix
 
 function reverse(v) = let(n = len(v) - 1) n < 0 ? [] : [for(i = [0 : n]) v[n - i]]; //! Reverse a vector
+
+function angle_between(v1, v2) = acos(v1 * v2 / (norm(v1) * norm(v2))); //! Return the angle between two vectors
+
+// https://www.gregslabaugh.net/publications/euler.pdf
+function euler(R) = let(ay = asin(-R[2][0]), cy = cos(ay)) //! Convert a rotation matrix to a Euler rotation vector.
+    cy ? [ atan2(R[2][1] / cy, R[2][2] / cy), ay, atan2(R[1][0] / cy, R[0][0] / cy) ]
+       : R[2][0] < 0 ? [atan2( R[0][1],  R[0][2]),  180, 0]
+                     : [atan2(-R[0][1], -R[0][2]), -180, 0];

utils/sweep.scad

@@ -62,6 +62,7 @@ function rotate_from_to(a, b) =
 function calculate_twist(A, B) = let(D = transpose3(B) * A) atan2(D[1][0], D[0][0]);
 //
 // Compute a 4x3 matrix to orientate a frame of the sweep given the position and a 3x3 rotation matrix.
+// Note that the rotation matrix is transposed to allow post multiplication.
 //
 function orientate(p, r) =
     let(x = r[0], y = r[1], z = r[2])
@@ -79,12 +80,21 @@ function rot3_z(a) =
         [ [ c, -s,  0],
           [ s,  c,  0],
           [ 0,  0,  1] ];
-
 //
 // Calculate the unit tangent at a vertex given the indices before and after. One of these can be the same as i in the case
-// of the start and end of a non closed path.
+// of the start and end of a non closed path. Note that the edges are converted to unit vectors so that their relative lengths
+// don't affect the direction of the tangent.
 //
-function tangent(path, before, i, after) = unit(unit(path[after] - path[i]) - unit(path[before] - path[i]));
+function tangent(path, before, i, after) = unit(unit(path[i] - path[before]) + unit(path[after] - path[i]));
+//
+// Calculate the twist per segment caused by rotate_from_to() instead of a simple Euler rotation around Z.
+//
+function helical_twist_per_segment(r, pitch, sides) = //! Calculate the twist around Z that rotate_from_to() introduces
+    let(step_angle = 360 / sides,
+        lt = 2 * r * sin(step_angle),               // length of tangent between two facets
+        slope = atan(2 * pitch / sides / lt)        // slope of tangents
+       ) step_angle * sin(slope);                   // angle tangent should rotate around z projected onto axis rotate_from_to() uses
+
 //
 // Generate all the surface points of the swept volume.
 //
@@ -111,24 +121,28 @@ function skin_points(profile, path, loop, twist = 0) =
             each profile4 * orientate(path[i], rotations[i] * rot3_z(za))
     ];
 
-function cap(facets, segment = 0) = [for(i = [0 : facets - 1]) segment ? facets * segment + i : facets - 1 - i];
+function cap(facets, segment = 0, end) = //! Create the mesh for an end cap
+    let(reverse = is_undef(end) ? segment : end)
+        [for(i = [0 : facets - 1]) facets * segment + (reverse ? i : facets - 1 - i)];
 
 function quad(p, a, b, c, d) = norm(p[a] - p[c]) > norm(p[b] - p[d]) ? [[b, c, d], [b, d, a]] : [[a, b, c], [a, c, d]];
 
-function skin_faces(points, segs, facets, loop) = [for(i = [0 : facets - 1], s = [0 : segs - (loop ? 1 : 2)])
-   each quad(points,
-        s * facets + i,
-        s * facets + (i + 1) % facets,
-       ((s + 1) % segs) * facets + (i + 1) % facets,
-       ((s + 1) % segs) * facets + i)];
+function skin_faces(points, npoints, facets, loop, offset = 0) = //! Create the mesh for the swept volume without end caps
+    [for(i = [0 : facets - 1], s = [0 : npoints - (loop ? 1 : 2)])
+       let(j = s + offset, k = loop ? (j + 1) % npoints : j + 1)
+       each quad(points,
+            j * facets + i,
+            j * facets + (i + 1) % facets,
+            k * facets + (i + 1) % facets,
+            k * facets + i)];
 
 function sweep(path, profile, loop = false, twist = 0) = //! Generate the point list and face list of the swept volume
     let(
-        segments = len(path),
+        npoints = len(path),
         facets = len(profile),
         points = skin_points(profile, path, loop, twist),
-        skin_faces = skin_faces(points, segments, facets, loop),
-        faces = loop ? skin_faces : concat([cap(facets)], skin_faces, [cap(facets, segments - 1)])
+        skin_faces = skin_faces(points, npoints, facets, loop),
+        faces = loop ? skin_faces : concat([cap(facets)], skin_faces, [cap(facets, npoints - 1)])
         ) [points, faces];
 
 module sweep(path, profile, loop = false, twist = 0) { //! Draw a polyhedron that is the swept volume
@@ -141,9 +155,9 @@ function path_length(path, i = 0, length = 0) = //! Calculated the length along
     i >= len(path) - 1 ? length
                        : path_length(path, i + 1, length + norm(path[i + 1] - path[i]));
 
-function circle_points(r = 1, z = 0) = //! Generate the points of a circle, setting z makes a single turn spiral
+function circle_points(r = 1, z = 0, dir = -1) = //! Generate the points of a circle, setting z makes a single turn spiral
     let(sides = r2sides(r))
-        [for(i = [0 : sides - 1]) let(a = i * 360 / sides) [r * sin(a), r * cos(a), z * a / 360]];
+        [for(i = [0 : sides - 1]) let(a = dir * i * 360 / sides) [r * cos(a), r * sin(a), z * i / sides]];
 
 function rectangle_points(w, h) = [[-w/2, -h/2, 0], [-w/2, h/2, 0], [w/2, h/2, 0], [w/2, -h/2, 0]]; //! Generate the points of a rectangle
 

utils/thread.scad

@@ -0,0 +1,217 @@
+//
+// NopSCADlib Copyright Chris Palmer 2019
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib 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.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+//
+
+//
+//! Utilities for making threads with sweep. They can be used to model screws, nuts, studding, leadscrews, etc, and also to make printed threads.
+//!
+//! The ends can be tapered, flat or chamfered by setting the ```top``` and ```bot``` parameters to -1 for tapered, 0 for a flat cut and positive to
+//! specify a chamfer angle.
+//!
+//! Threads are by default solid, so the male version is wrapped around a cylinder and the female inside a tube. This can be suppressed to just get the helix, for
+//! example to make a printed pot with a screw top lid.
+//!
+//! Threads with a typical 60 degree angle appear too bright with OpenSCAD's primitive lighting model as they face towards the lights more than the top and sides of
+//! a cylinder. To get around this a colour can be passed to thread that is used to colour the cylinder and then toned down to colour the helix.
+//!
+//! Making the ends requires a CGAL intersection, which make threads relatively slow. For this reason they are generally disabled when using the GUI but can
+//! be enabled by setting ```$show_threads``` to ```true```. When the tests are run, by default, threads are enabled only for things that feature them like screws.
+//! This behaviour can be changed by setting a ```SHOW_THREADS``` environment variable to ```false``` to disable all threads and ```true``` to enable all threads.
+//! The same variable also affects the generation of assembly diagrams.
+//!
+//! Threads obey the $fn, $fa, $fs variables.
+//
+include <../core.scad>
+use <sweep.scad>
+use <maths.scad>
+use <tube.scad>
+
+thread_colour_factor = 0.8; // 60 degree threads appear too bright due to the angle facing the light sources
+
+function thread_profile(h, crest, angle, overlap = 0.1) = //! Create thread profile path
+    let(base = crest + 2 * (h + overlap) * tan(angle / 2))
+        [[-base / 2, -overlap, 0], [-crest / 2, h, 0], [crest / 2, h, 0], [base / 2, -overlap, 0]];
+
+module thread(dia, pitch, length, profile, center = true, top = -1, bot = -1, starts = 1, solid = true, female = false, colour = undef) { //! Create male or femail thread, ends can be tapered, chamfered or square
+    //
+    // Apply colour if defined
+    //
+    module colour(factor) if(is_undef(colour)) children(); else color(colour * factor) children();
+    //
+    // Compress the profile to compensate for it being tilted by the helix angle
+    //
+    scale = cos(atan(pitch / (PI * dia)));
+    sprofile = [for(p = profile) [p.x * scale, p.y, p.z]];
+    //
+    // Extract some properties from the profile, perhaps they should be stored in it.
+    //
+    h = max([for(p = sprofile) p.y]);
+    maxx = max([for(p = sprofile) p.x]);
+    minx = min([for(p = sprofile) p.x]);
+    crest_xmax = max([for(p = sprofile) if(p.x != maxx) p.x]);
+    crest_xmin = min([for(p = sprofile) if(p.x != minx) p.x]);
+    //
+    // If the ends don't taper we need an extra half turn past the ends to be cropped horizontally.
+    //
+    extra_top = top < 0 ? 0 : -minx / pitch;
+    extra_bot = bot < 0 ? 0 :  maxx / pitch;
+    turns = length / pitch + extra_top + extra_bot;
+    //
+    // Generate the helix path, possibly with tapered ends
+    //
+    dir = female ? 1 : -1;
+    r = dia / 2;
+    sides = r2sides4n(r);
+    step_angle = 360 / sides;
+    segs = ceil(turns * sides);
+    leadin = ceil(sides / starts);
+    final = floor(turns * sides) - leadin;
+    path = [for(i = [0 : segs],
+                R = i < leadin && bot < 0 ? r + dir * (h - h * i / leadin)
+                  : i > final  && top < 0 ? r + dir * h * (i - final) / leadin : r,
+                a = i * step_angle - 360 * extra_bot)
+                    [R * cos(a), R * sin(a), a * pitch / 360]];
+    //
+    // Generate the skin vertices
+    //
+    facets = len(profile);
+    twist  = helical_twist_per_segment(r, pitch, sides);
+    //
+    // For female threads we need to invert the profile
+    //
+    iprofile = female ? reverse([for(p = sprofile) [p.x, -p.y, 0]]) : sprofile;
+    //
+    // If the bottom is tapered then the twist will be greater, so pre-twist the profile to get the straight bit at the correct angle
+    //
+    rprofile = bot < 0 ? transform_points(iprofile, rotate(-dir * (helical_twist_per_segment(r - h, pitch, sides) - twist) * sides / PI))
+                       : iprofile;
+    points = skin_points(rprofile, path, false, twist * segs);
+    //
+    // To form the ends correctly we need to use intersection but it is very slow with the full thread so we just
+    // intersect the start and the end and sweep the rest outside of the intersection.
+    //
+    top_chamfer_h = (top > 0 ? h * tan(top) : 0);
+    bot_chamfer_h = (bot > 0 ? h * tan(bot) : 0);
+    top_overlap = max( maxx, top_chamfer_h - crest_xmin) / pitch;
+    bot_overlap = max(-minx, bot_chamfer_h + crest_xmax) / pitch;
+    start =      ceil(sides * (bot_overlap + extra_bot));
+    end = segs - ceil(sides * (top_overlap + extra_top));
+
+    start_skin_faces  = skin_faces(points, start + 1,            facets, false);
+    middle_skin_faces = skin_faces(points, end - start + 1,      facets, false, start);
+    end_skin_faces    = skin_faces(points, segs - end + 1,       facets, false, end);
+
+    start_faces  = concat([cap(facets)              ], start_skin_faces,  [cap(facets, start)]);
+    middle_faces = concat([cap(facets, start, false)], middle_skin_faces, [cap(facets, end)]);
+    end_faces    = concat([cap(facets, end,   false)], end_skin_faces,    [cap(facets, segs)]);
+
+    overlap = - profile[0].y;
+    translate_z((center ? -length / 2 : 0)) {
+        ends_faces = concat(start_faces, end_faces);
+        for(i = [0 : starts - 1])
+            colour(thread_colour_factor)
+                rotate(360 * i / starts + (female ? 180 / starts : 0)) {
+                    render() intersection() {
+                        polyhedron(points, ends_faces);
+
+                        len = length - 2 * eps;
+                        rotate_extrude()
+                            if(female) {
+                                difference() {
+                                    translate([0, eps])
+                                        square([r + h + overlap, len]);
+
+                                    if(top_chamfer_h)
+                                        polygon([[0, length], [r, length], [r - h, length - top_chamfer_h], [0, length - top_chamfer_h]]);
+
+                                    if(bot_chamfer_h)
+                                        polygon([[0, 0], [r, 0], [r - h, bot_chamfer_h], [0, bot_chamfer_h]]);
+                               }
+                            }
+                            else
+                                difference() {
+                                    hull() {
+                                        translate([0, eps])
+                                            square([r, len]);
+
+                                        translate([0, bot_chamfer_h])
+                                            square([r + h + overlap, len - top_chamfer_h - bot_chamfer_h]);
+                                    }
+                                    if(!solid)
+                                        square([r - overlap, length]);
+                                }
+                    }
+
+                    polyhedron(points, middle_faces);
+                }
+
+        if(solid)
+            colour(1)
+                rotate(90)
+                    if(female)
+                        tube(or = r + (top < 0 || bot < 0 ? h : 0) + 2 * overlap, ir = r, h = length, center = false);
+                    else
+                        cylinder(d = dia, h = length);
+    }
+}
+
+module male_metric_thread(d, pitch, length, center = true, top = -1, bot = -1, solid = true, colour = undef) { //! Create male thread with metric profile
+    H = pitch * sqrt(3) / 2;
+    h = 5 * H / 8;
+    minor_d = d - 2 * h;
+    thread(minor_d, pitch, length, thread_profile(h, pitch / 8, 60), center, top, bot, solid = solid, colour = colour);
+}
+
+module female_metric_thread(d, pitch, length, center = true, top = -1, bot = -1, colour = undef) { //! Create female thread with metric profile
+    H = pitch * sqrt(3) / 2;
+    h = 5 * H / 8;
+    thread(d, pitch, length, thread_profile(h, pitch / 4, 60), center, top, bot, solid = false, female = true, colour = colour);
+}
+
+function metric_coarse_pitch(d) //! Convert metric diameter to pitch
+    = d == 1.6 ? 0.35  // M1.6
+               : [0.4, // M2
+                  0.45,// M2.5
+                  0.5, // M3
+                  0.6, // M3.5
+                  0.7, // M4
+                  0,
+                  0.8, // M5
+                  0,
+                  1.0, // M6
+                  0,
+                  0,
+                  0,
+                  1.25, // M8
+                  0,
+                  0,
+                  0,
+                  1.5,  // M10
+                  0,
+                  0,
+                  0,
+                  1.75, // M12
+                  0,
+                  0,
+                  0,
+                  0,    // M14
+                  0,
+                  0,
+                  0,
+                  2.0,  // M16
+                 ][d * 2 - 4];

vitamins/ball_bearings.scad

@@ -18,7 +18,9 @@
 //
 BB624 = ["624", 4, 13, 5, "blue"];      // 624 ball bearing for idlers
 BB608 = ["608", 8, 22, 7, "OrangeRed"]; // 608 bearings for wades
+BB6200 = ["6200", 10, 30, 9, "black"];  // 6200 bearings for KP pillow blocks
+BB6201 = ["6201", 12, 32, 10, "black"]; // 6201 bearings for KP pillow blocks
 
-ball_bearings = [BB624, BB608];
+ball_bearings = [BB624, BB608, BB6200, BB6201];
 
 use <ball_bearing.scad>

vitamins/belt.scad

@@ -41,9 +41,7 @@ function no_point(str) = chr([for(c = str) if(c == ".") ord("p") else ord(c)]);
 // We model the belt path at the pitch radius of the pulleys and the pitch line of the belt to get an accurate length.
 // The belt is then drawn by offseting each side from the pitch line.
 //
-module belt(type, points, gap = 0, gap_pt = undef) { //! Draw a belt path given a set of points and pitch radii where the pulleys are. Closed loop unless a gap is specified
-    belt_colour = grey20;
-    tooth_colour = grey50;
+module belt(type, points, gap = 0, gap_pt = undef, belt_colour = grey20, tooth_colour = grey50) { //! Draw a belt path given a set of points and pitch radii where the pulleys are. Closed loop unless a gap is specified
     width = belt_width(type);
     pitch = belt_pitch(type);
     thickness = belt_thickness(type);

vitamins/d_connector.scad

@@ -21,6 +21,7 @@
 //! D-connectors. Can be any number of ways, male or female, solder buckets, PCB mount or IDC, with or without pillars.
 //
 include <../core.scad>
+use <../utils/thread.scad>
 
 d_pillar_color                   = grey90;
 d_plug_shell_color               = grey80;
@@ -51,16 +52,24 @@ module d_pillar() { //! Draw a pillar for a D-connector
     height = 4.5;
     screw = 2.5;
     screw_length = 8;
-    color(d_pillar_color)  {
-        translate_z(-screw_length)
-            cylinder(d = screw, h = screw_length + 1);
+    pitch = metric_coarse_pitch(screw);
 
+    translate_z(-screw_length)
+        if(show_threads)
+            male_metric_thread(screw, pitch, screw_length, false, top = 0, colour = d_pillar_color);
+        else
+            color(d_pillar_color)
+                cylinder(d = screw, h = screw_length + 1);
+
+    color(d_pillar_color) {
         linear_extrude(height = height)
             difference() {
                 circle(r = rad, $fn = 6);
                 circle(d = screw);
             }
-    }
+        }
+    if(show_threads)
+        female_metric_thread(screw, pitch, height, false, colour = d_pillar_color);
 }
 
 module d_plug(type, socket = false, pcb = false, idc = false) { //! Draw specified D plug, which can be IDC, PCB or plain solder bucket

vitamins/extrusion.scad

@@ -0,0 +1,128 @@
+//
+// NopSCADlib Copyright Chris Palmer 2020
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib 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.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+
+//
+//! Aluminium  extrusion.
+//
+include <../core.scad>
+
+function extrusion_width(type)          = type[1];   //! Width of extrusion
+function extrusion_height(type)         = type[2];   //! Height of extrusion
+function extrusion_center_hole(type)    = type[3];   //! Diameter of center hole
+function extrusion_corner_hole(type)    = type[4];   //! Diameter of corner hole
+function extrusion_center_square(type)  = type[5];   //! Size of center square
+function extrusion_channel_width(type)  = type[6];   //! Channel width
+function extrusion_channel_width_internal(type)  = type[7];   //! Internal channel width
+function extrusion_tab_thickness(type)  = type[8];   //! Tab thickness
+function extrusion_spar_thickness(type) = type[9];   //! Spar thickness
+function extrusion_fillet(type)         = type[10];  //! Radius of corner fillet
+
+module extrusion_cross_section(type, cornerHole) {
+
+    module extrusion_corner(type, cornerHole) {
+        width = extrusion_width(type);
+        tabThickness = extrusion_tab_thickness(type);
+        sparThickness = extrusion_spar_thickness(type);
+        centerSquare = extrusion_center_square(type);
+        channelWidth = extrusion_channel_width(type);
+        fillet = extrusion_fillet(type);
+        cornerSize = (width-channelWidth)/2;
+        cornerSquare = (width-extrusion_channel_width_internal(type))/2;
+        cornerHoleDiameter =extrusion_corner_hole(type);
+
+        translate([-width/2,-width/2]) {
+            difference() {
+                union() {
+                    translate([fillet,0])
+                        square([cornerSize-fillet,tabThickness]);
+                    translate([0,fillet])
+                        square([tabThickness,cornerSize-fillet]);
+                    translate([fillet,fillet])
+                        circle(fillet);
+                    translate([fillet,fillet])
+                        square([cornerSquare-fillet,cornerSquare-fillet]);
+                }
+                if(cornerHole)
+                    translate([cornerSquare/2,cornerSquare/2])
+                        circle(d=cornerHoleDiameter);
+            }
+        }
+        rotate(-135) translate([centerSquare/2,-sparThickness/2]) square([sqrt(2)*(width-centerSquare-cornerSquare)/2,sparThickness]);
+    }
+
+    module extrusion_center_section(type) {
+        width = extrusion_width(type);
+        tabThickness = extrusion_tab_thickness(type);
+        sparThickness = extrusion_spar_thickness(type);
+        centerSquare = extrusion_center_square(type);
+        channelWidth = extrusion_channel_width(type);
+
+        translate([0,width/2])
+            for(angle=[225,315])
+                rotate(angle)
+                    translate([centerSquare/2,-sparThickness/2])
+                        square([sqrt(2)*(width-centerSquare)/2,sparThickness]);
+        translate([0,-width/2])
+            for(angle=[45,135])
+                rotate(angle)
+                    translate([centerSquare/2,-sparThickness/2])
+                        square([sqrt(2)*(width-centerSquare)/2,sparThickness]);
+
+        centerHeight = width-channelWidth;
+        translate([-width/2,-centerHeight/2])
+            square([tabThickness,centerHeight]);
+        translate([width/2-tabThickness,-centerHeight/2])
+            square([tabThickness,centerHeight]);
+    }
+
+
+    centerSquare = extrusion_center_square(type);
+
+    width = extrusion_width(type);
+    height = extrusion_height(type);
+    count = (height-width)/width;
+
+    for(i=[0:count])
+        translate([0,i*width+(width-height)/2])
+            difference() {
+                square([centerSquare,centerSquare],center=true);
+                circle(d=extrusion_center_hole(type));
+            }
+    translate([0,(width-height)/2])
+        for(angle=[0,90])
+            rotate(angle)
+                extrusion_corner(type, cornerHole);
+    translate([0,-(width-height)/2])
+        for(angle=[180,270])
+            rotate(angle)
+                extrusion_corner(type, cornerHole);
+    if(count>=1)
+        for(i=[1:count])
+            translate([0,i*width-height/2])
+                extrusion_center_section(type);
+}
+
+module extrusion(type, length, cornerHole = false) { //! Draw the specified extrusion
+
+    vitamin(str("extrusion(", type[0], ", ", length, "): Extrusion ", type[0], " x ", length, "mm"));
+
+    color(grey90)
+        linear_extrude(height = length)
+            extrusion_cross_section(type, cornerHole);
+}
+

vitamins/extrusions.scad

@@ -0,0 +1,35 @@
+//
+// NopSCADlib Copyright Chris Palmer 2020
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib 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.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+//
+//
+// Extrusion
+//
+//                   W   H    d1   d2   s  cw   cwi    t  st  f
+E2020  = [ "E2020", 20, 20,  4.2,   0,  8,  6, 12.0,   2,  2, 1 ];
+E2040  = [ "E2040", 20, 40,  4.2,   0,  8,  6, 12.0,   2,  2, 1 ];
+E2060  = [ "E2060", 20, 60,  4.2,   0,  8,  6, 12.0,   2,  2, 1 ];
+E2080  = [ "E2080", 20, 80,  4.2,   0,  8,  6, 12.0,   2,  2, 1 ];
+E3030  = [ "E3030", 30, 30,  6.8, 4.2, 12,  8, 16.5,   2,  2, 1 ];
+E3060  = [ "E3060", 30, 60,  6.8, 4.2, 12,  8, 16.5,   2,  2, 1 ];
+E4040  = [ "E4040", 40, 40, 10.5, 6.0, 15, 10, 20.0, 5.5,  3, 1 ];
+E4080  = [ "E4080", 40, 80, 10.5, 6.0, 15, 10, 20.0, 5.5,  3, 1 ];
+
+extrusions = [E2020,E2040,E2060,E2080,E3030,E3060,E4040,E4080];
+
+use <extrusion.scad>
+