Merge branch 'martinbudden-teardrop_angle'

1. Better default parameters
2. Changed plain_idler_offset to work in x and y, to facilitate larger idler pulleys

core.scad

@@ -18,7 +18,7 @@
 //
 
 //
-// Include this file to use the miniumum library plus screws, nuts and washers
+// Include this file to use the minimum library plus screws, nuts and washers
 //
 include <utils/core/core.scad>
 //

docs/usage.md

@@ -1,7 +1,7 @@
 # NopSCADlib usage
 
 ## Requirements
-1. OpenSCAD 2019.05 or later, download it from here: https://www.openscad.org/downloads.html
+1. OpenSCAD 2021.01 or later, download it from here: https://www.openscad.org/downloads.html
 1. Python 2.7+ or 3.6+ from https://www.python.org/downloads/
 1. ImageMagick 7 www.imagemagick.org
 
@@ -22,37 +22,37 @@ The 7 SEGMENT.TTF font from the docs directory is needed for simulating 7 segmen
 
 ## Installation
 
-OpenSCAD has to be setup to find libraries by setting the ```OPENSCADPATH``` environment variable to where you want to file your libraries and NopSCADlib needs to be installed
-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,
+OpenSCAD has to be setup to find libraries by setting the `OPENSCADPATH` environment variable to where you want to file your libraries and NopSCADlib needs to be installed
+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, ```PATH``` on Windows and ```path``` on Linux and Mac.
+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.
+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.
 
-Running ```tests``` from the command line will run all the tests in the ```tests``` directory and build the ```readme.md``` catalog for GitHub and render it to ```readme.html```
+Running `tests` from the command line will run all the tests in the `tests` directory and build the `readme.md` catalog for GitHub and render it to `readme.html`
 for local preview.
 
 ## Directory structure
 
 | Path | Contents |
 |:-----|:------|
-| ```NopSCADlib``` | Top level scad files, e.g. ```lib.scad``` |
-| ```NopSCADlib/doc``` | Documentation like this that is not automatically generated |
-| ```NopSCADlib/examples``` | Example projects |
-| ```NopSCADlib/gallery``` | Pictures of items that have been made with the library |
-| ```NopSCADlib/printed``` | Scad files for making reusable printed parts |
-| ```NopSCADlib/scripts``` | Python scripts |
-| ```NopSCADlib/tests``` | A stand alone test for each type of vitamin and most of the utilities |
-| ```NopSCADlib/utils```   | Utility scad files |
-| ```NopSCADlib/utils/core``` | Core utilities used by nearly everything |
-| ```NopSCADlib/vitamins``` | Generally a pair of .scad files for each type of vitamin. The plural version contains object definitions to be included and it uses the singular version. |
+| `NopSCADlib` | Top level scad files, e.g. `lib.scad` |
+| `NopSCADlib/doc` | Documentation like this that is not automatically generated |
+| `NopSCADlib/examples` | Example projects |
+| `NopSCADlib/gallery` | Pictures of items that have been made with the library |
+| `NopSCADlib/printed` | Scad files for making reusable printed parts |
+| `NopSCADlib/scripts` | Python scripts |
+| `NopSCADlib/tests` | A stand alone test for each type of vitamin and most of the utilities |
+| `NopSCADlib/utils`   | Utility scad files |
+| `NopSCADlib/utils/core` | Core utilities used by nearly everything |
+| `NopSCADlib/vitamins` | Generally a pair of .scad files for each type of vitamin. The plural version contains object definitions to be included and it uses the singular version. |
 
 
 ## Making a project
 
 Each project has its own directory and that is used to derive the project's name.
-There should also be a subdirectory called ```scad``` with a scad file in it that contains the main assembly.
+There should also be a subdirectory called `scad` with a scad file in it that contains the main assembly.
 A skeleton project looks like this: -
 
     //! Project description in Markdown format before the first include.
@@ -72,30 +72,30 @@ A skeleton project looks like this: -
 
 Other scad files can be added to the scad directory and included or used as required.
 
-* Subassemblies can be added in the same format as ```main_assembly()```, i.e. a module called ```something_assembly()```, taking no parameters and calling ```assembly("something")```
+* Subassemblies can be added in the same format as `main_assembly()`, i.e. a module called `something_assembly()`, taking no parameters and calling `assembly("something")`
  with the rest of its contents passed as children.
-It needs to be called directly or indirectly from ```main_assembly()``` to appear in the view and on the BOM.
-Assembly instructions should be added directly before the module definition in comments marked with ```//!```.
+It needs to be called directly or indirectly from `main_assembly()` to appear in the view and on the BOM.
+Assembly instructions should be added directly before the module definition in comments marked with `//!`.
 
-* Any printed parts should be made by a module called ```something_stl()```, taking no parameters and calling ```stl("something")``` so they appear on the BOM when called from
-an assembly. Printed parts are usually ```color```ed and ```render```ed at the point they are used in the assembly.
+* Any printed parts should be made by a module called `something_stl()`, taking no parameters and calling `stl("something")` so they appear on the BOM when called from
+an assembly. Printed parts are usually `color`ed and `render`ed at the point they are used in the assembly.
 
-* Any 2D routed parts should be made by a module called ```something_dxf()```, taking no parameters and calling ```dxf("something")``` so they appear on the BOM when called from an
-assembly. They are generally made from a ```sheet_2D()``` with holes subtracted from it. That will also put the sheet material on the BOM.
-They are then expanded to 3D using ```render_2D_sheet()``` when they are placed in an assembly.
+* Any 2D routed parts should be made by a module called `something_dxf()`, taking no parameters and calling `dxf("something")` so they appear on the BOM when called from an
+assembly. They are generally made from a `sheet_2D()` with holes subtracted from it. That will also put the sheet material on the BOM.
+They are then expanded to 3D using `render_2D_sheet()` when they are placed in an assembly.
 
-When ```make_all``` is run from the top level directory of the project it will create the following sub-directories and populate them:-
+When `make_all` is run from the top level directory of the project it will create the following sub-directories and populate them:-
 
 | Directory | Contents |
 |:----------|:---------|
 | assemblies | For each assembly: an assembled view and an exploded assembly view, in large and small formats |
-| bom | A flat BOM in ```bom.txt``` for the whole project, flat BOMs in text format for each assembly and a hierarchical BOM in JSON format: ```bom.json```.|
+| bom | A flat BOM in `bom.txt` for the whole project, flat BOMs in text format for each assembly and a hierarchical BOM in JSON format: `bom.json`.|
 | deps | Dependency files for each scad file in the project, so that subsequent builds can be incremental |
 | dxfs | DXF files for all the CNC routed parts in the project and small PNG images of them |
 | stls | STL files for all the printed parts in the project and small PNG images of them |
 
-It will also make a Markdown assembly manual called ```readme.md``` suitable for GitHub, a version rendered to HTML for viewing locally called ```readme.html``` and a second
-HTML version called ```printme.html```. This has page breaks instead of horizontal rules between sections and can be converted to PDF using Chrome to make a stand alone manual.
+It will also make a Markdown assembly manual called `readme.md` suitable for GitHub, a version rendered to HTML for viewing locally called `readme.html` and a second
+HTML version called `printme.html`. This has page breaks instead of horizontal rules between sections and can be converted to PDF using Chrome to make a stand alone manual.
 
 Each time OpenSCAD is run to produce STL files, DXF files or assembly views, the time it takes is recorded and compared with the previous time.
 At the end the times are printed with the delta from the last run and coloured red or green if they have got significantly faster or slower.
@@ -112,28 +112,38 @@ All the vitamins and utilities are included if you include [NopSCADlib/lib.scad]
 Printed parts are not included and need to be used or included explicitly, their documentation states which files need to be included rather than used.
 
 This is the easiest way to use the library and is reasonably efficient because the only files included are the object list definitions, all the functions and modules are used, so
-get shared if other files in the project include ```lib.scad``` as well, or if you have multiple projects open in the same instance of OpenSCAD.
+get shared if other files in the project include `lib.scad` as well, or if you have multiple projects open in the same instance of OpenSCAD.
 
 One downside is that any change to the library will mean all the project files need regenerating.
 A more optimised approach for large projects is to include [NopSCADlib/core.scad](../core.scad) instead.
 That only has the a small set of utilities and the global settings in [global_defs.scad](../global_defs.scad) plus screws, nuts and washers that are required by a lot of other vitamins.
 Any other vitamins used need to be included explicitly. One can copy the includes or use a line from [NopSCADlib/lib.scad](../lib.scad).
 
+### Project Description
+
+A description of the project can be placed in comments in Markdown format before the first include file.
+By default this is followed by a picture of the main assembly unless the description contains any pictures.
+
+The description can be divided into two or three sections using //! ***, which is a Markdown horizontal rule in a comment.
+If there is a second section it is placed after the table of contents and a third section will be placed after the parts list.
+
+If an actual horizontal rule is desired the alternative Markdown markup //! --- can be used.
+
 ### Parametric parts.
 
 Modules that generate parts and assemblies need to take no parameters so that they can be called from the framework to make the STL files and assembly views, etc.
 Sometimes parts or asemblies need to be parametric, for example fan guards take the fan as a parameter.
-To work around this the ```fan_guard()``` module calls the ```stl()``` module with a variable name which has a suffix of the fan width, e.g. "fan_guard_60".
+To work around this the `fan_guard()` module calls the `stl()` module with a variable name which has a suffix of the fan width, e.g. "fan_guard_60".
 This ensures that if there are different sized fans in the same project the STL files have unique names.
-It is then up to the user to add a wrapper to their project called ```fan_guard_60_stl()``` that calls ```fan_guard()``` with a 60mm fan: -
+It is then up to the user to add a wrapper to their project called `fan_guard_60_stl()` that calls `fan_guard()` with a 60mm fan: -
 
     module fan_guard_60_stl() fan_guard(fan60x15);
 
-Calling ```fan_guard(fan60x15)``` draws a fan guard for a 60mm fan and puts ```fan_guard_60.stl``` on the BOM. The framework then looks for a module ```fan_guard_60_stl()``` to
+Calling `fan_guard(fan60x15)` draws a fan guard for a 60mm fan and puts `fan_guard_60.stl` on the BOM. The framework then looks for a module `fan_guard_60_stl()` to
 generate it.
 
 This is OK if the fan will always be 60mm but what if the project is parametric and the fan size can vary?
-To cater for that ```fan_guard()``` can be passed a ```name``` parameter to name the STL.
+To cater for that `fan_guard()` can be passed a `name` parameter to name the STL.
 For example a 3D printer might have a bed cooling fan and different sized machines might have different size fans.
 
     bed_fan = fan80x38;
@@ -144,7 +154,7 @@ In this case the STL file has a constant name related to its use, regardless of
 
 ### Assembly boundaries
 
-The ```assembly()``` module is used to mark assemblies that correspond to a step of construction.
+The `assembly()` module is used to mark assemblies that correspond to a step of construction.
 Each assembly named in this way gets a page in the build manual with a list of the parts and sub-assemblies that it uses, an exploded view,
 some build instructions and then the assembled view.
 This doesn't always correspond with how one would want to structure the code.
@@ -162,7 +172,7 @@ This is achieved by having a pair of modules: -
     //! Place inserts in the bottom of the posts and push them home with a soldering iron with a conical bit heated to 200°C.
     //
     module handle_assembly() pose([225, 0, 150], [0, 0, 14]) //! Printed part with inserts in place
-    assembly("handle") {
+    assembly("handle", ngb = true) {
         translate_z(handle_height())
             stl_colour(pp1_colour) vflip() handle_stl();
 
@@ -172,7 +182,7 @@ This is achieved by having a pair of modules: -
     }
 
     module handle_fastened_assembly(thickness) { //! Assembly with fasteners in place
-        screw_length = screw_longer_than(thickness + insert_length(insert) + 2 * washer_thickness(screw_washer(screw)));
+        screw_length = screw_length(screw, thickness, 2, true, longer = true);
 
         handle_assembly();
 
@@ -182,26 +192,29 @@ This is achieved by having a pair of modules: -
                     screw_and_washer(screw, screw_length, true);
     }
 
-Notice how the first module ```handle_assembly()``` uses ```assembly()``` and has a build instruction. It isn't used directly in a project though, ```handle_fastened_assembly()``` is
+Notice how the first module `handle_assembly()` uses `assembly()` and has a build instruction. It isn't used directly in a project though, `handle_fastened_assembly()` is
 what is actually called from the parent assembly.
-Because it doesn't have a call to ```assembly()```, the fasteners are added to the parent but the STL and the inserts become a sub-assembly.
+Because it doesn't have a call to `assembly()`, the fasteners are added to the parent but the STL and the inserts become a sub-assembly.
 
 When the parent assembly is shown exploded the handle's screws will be exploded but the inserts won't. They only explode when the sub-assembly is shown exloded.
 
-Note also the ```pose([225, 0, 150], [0, 0, 14])``` call before the ```assembly()``` call. This allows the sub-assembly to be posed differently in its build step but doesn't
+Note also the `pose([225, 0, 150], [0, 0, 14])` call before the `assembly()` call. This allows the sub-assembly to be posed differently in its build step but doesn't
 affect its orientation in the parent assembly. The pose parameters are the rotation and the translation taken from the GUI.
 
+Setting `ngb = true` in the `assembly()` prevents the handle assembly appearing as a columun in the top level BOM in the build instructions.
+Instead its parts are merged into the parent BOM so the correct quantites are listed.
+
 ### Exploded diagrams
 
-A lot of vitamins explode themselves when ```$explode=1```. This is done with module ```explode()``` that can be passed a Z offset, or a 3D vector that gives the displacement
-and it draws a line from the origial position to the exploded position. The line can be offset from the origin of the component by specifying an offset vector.
+A lot of vitamins explode themselves when `$explode=1`. This is done with module `explode()` that can be passed a Z offset, or a 3D vector that gives the displacement
+and it draws a line from the original position to the exploded position. The line can be offset from the origin of the component by specifying an offset vector.
 
-Often user assemblies need to add ```explode()``` in various places to explode printed parts, for example.
+Often user assemblies need to add `explode()` in various places to explode printed parts, for example.
 
 ### Creating vitamins
 
 Most vitamins are parametric and use a named list of properties to describe them is a pseudo OO style.
-These lists are passed to every function or module related to the vitamin as the first parameter called ```type```.
+These lists are passed to every function or module related to the vitamin as the first parameter called `type`.
 They need to be included in the user code, so that the list names are visible. The functions and modules however only need to be used, not included.
 
 This leads to a pair of files for each vitamin. One with a plural name that defines the objects and then uses the file with a singular name
@@ -216,50 +229,66 @@ These functions take a particular form, so they can be scraped out and added to
 
     function spring_od(type)     = type[1]; //! Outside diameter
 
-Other functions and modules with ```//!``` comments will be added to the documentation as functions and modules.
+Other functions and modules with `//!` comments will be added to the documentation as functions and modules.
 Functions and modules without these special comments are considered private and do not appear in the documentation.
 
-A vitamin announces itself to the BOM by calling the ```vitamin()``` module with a string description composed of two parts separated by a colon.
+A vitamin announces itself to the BOM by calling the `vitamin()` module with a string description composed of two parts separated by a colon.
 The first part is a string representation of the module instantiation.
 This is used in the documentation to show how to instantiate every part available.
-To facilitate this the first element in the type list is the name of the list as a string and is simply accessed as ```type[0]```.
+To facilitate this the first element in the type list is the name of the list as a string and is simply accessed as `type[0]`.
 
 The part of the description after the colon is free format text that appears on the BOM. Since vitamins are listed alphabetically starting the description with the broad
 category of the part and leaving the more refined description to the end generates tidier parts lists.
-For example ```Screw M3 pan x 30mm``` ensures all the screws appear together and are ordered by their diameter before length, although ```M3 x 30mm pan screw``` would be
+For example `Screw M3 pan x 30mm` ensures all the screws appear together and are ordered by their diameter before length, although `M3 x 30mm pan screw` would be
 more natural.
 
 Vitamins are only ever previewed, so they are optimised to draw quickly in F5 and don't need to worry about being manifold.
 In OpenCSG 3D difference and intersection are relatively slow and the negative volumes interfere with nearby objects when they are composed into assemblies. For this reason as much
-as possible is done by unioning primitives and extruded 2D shapes. Any 3D differences or intersections are wrapped in ```render()``` so that CGAL will compute a polyhedron
+as possible is done by unioning primitives and extruded 2D shapes. Any 3D differences or intersections are wrapped in `render()` so that CGAL will compute a polyhedron
 that is cached and reused. This will be very slow the first time it renders but very fast afterwards.
 
 ### Panels and Platters
 
-The ```stls``` and ```dxfs``` scripts produce a file for each part but often it is desirable to print or route collections of parts laid out together.
-This can be done by adding scad files to folders called ```platters``` for STL files and ```panels``` for DXF files.
-These can aggregate and lay out parts by including ```NopSCADlib/core.scad``` and using modules ```use_stl(name)``` and ```use_dxf(name)```.
+The `stls` and `dxfs` scripts produce a file for each part but often it is desirable to print or route collections of parts laid out together.
+This can be done by adding scad files to folders called `platters` for STL files and `panels` for DXF files.
+These can aggregate and lay out parts by including `NopSCADlib/core.scad` and using modules `use_stl(name)` and `use_dxf(name)`.
 These modules import the already generated singular STL and DXF files, so they are relatively fast. The name does not include the suffix.
 The scad files typically also need to include other files from the project to get the dimensions of the parts to calculate their positions.
 
-The composite part files have the same name as the scad file that generates them, with the suffix changed to ```.stl``` or ```.dxf```.
+The composite part files have the same name as the scad file that generates them, with the suffix changed to `.stl` or `.dxf`.
 
-The generated files are placed in ```stls/printed``` and ```dxfs/routed```.
-Any parts that are not covered by the platters / panels are copied into the ```printed``` / ```routed``` directories, so that they contain everything to be made.
+The generated files are placed in `stls/printed` and `dxfs/routed`.
+Any parts that are not covered by the platters / panels are copied into the `printed` / `routed` directories, so that they contain everything to be made.
 
 ### Multiple configurations
 
 Some parametric designs might have several configurations, for example a 3D printer with different size options. If several configurations need to be supported at the
  same time multiple sets of BOMS, STLS and DXFs need to be generated in separate diectories. NopSCADlib supports this by having multiple configuration files named
-```config_<target_name>.scad```. All the scripts take an optional first parameter that selects one of these config files by specifying ```target_name```.
+`config_<target_name>.scad`. All the scripts take an optional first parameter that selects one of these config files by specifying `target_name`.
 
-The target config file is selected by generating ```target.scad``` that includes ```config_<target_name>.scad```.
-The rest of the project includes ```target.scad``` to use the configuration.
-Additionally all the generated file directories (assemblies, bom, stls, dxfs, etc.) are placed in a sub-directory called ```<target_name>```.
+The target config file is selected by generating `target.scad` that includes `config_<target_name>.scad`.
+The rest of the project includes `target.scad` to use the configuration.
+Additionally all the generated file directories (assemblies, bom, stls, dxfs, etc.) are placed in a sub-directory called `<target_name>`.
+
+The build system will look for a `<target_name>_assembly` module and use it as the top level module instead of `main_assembly` if it it exists.
+That allows the project description to be target specific if the top level modules are in different scad files.
+The top level assembly instructions and assembly contents could also be different if appropriate.
+
+If the top level module is just a shell wrapper that simply includes one other assembly, with no additional parts, then it is removed from the build instructions and
+the assembly it calls becomes the top level. This allows a different project description for each target but only one set of top level instructions without repeating them.
+
+### Costed BOMs
+
+A costed bill of materials can be made by opening the generated file `bom/bom.csv` in a spreadsheet program using a single quote as the string delimiter and comma as the field separator.
+That gets a list of part descriptions and quantities to which prices can be added to get the total cost and perhaps a URL of where to buy each part.
+
+If a Python file called `parts.py` is found then `bom.py` will attempt to call functions for each part to get a price and URL.
+Any functions not found are printed, so you can see the format expected.
+The function are passed the quantity to allow them to calculate volume discounts, etc.
 
 ### Other libraries
 
 The build scripts need to be able to locate the source files where the modules to generate the STL files and assemblies reside. They will search all the scad files
-in the project plus any ```printed``` directories outside the project. This covers the printed parts in NopSCADlib but also allows other libraries of printed parts.
+in the project plus any `printed` directories outside the project. This covers the printed parts in NopSCADlib but also allows other libraries of printed parts.
 
 Other libraries of vitamins and utilities can be used provided they follow the same convensions of NopSCADlib. The build scripts don't need to search those.

examples/MainsBreakOutBox/bom/bom.csv

@@ -0,0 +1,16 @@
+'Ferrule for 1.5mm^2 wire - not shown',  3
+'Wire blue 30/0.25mm strands, length 150mm - not shown',  2
+'Wire brown 30/0.25mm strands, length 150mm - not shown',  2
+'Wire green & yellow 30/0.25mm strands, length 150mm - not shown',  2
+'IEC inlet for ATX',  1
+'Heatfit insert M3',  2
+'4mm shielded jack socket blue',  2
+'4mm shielded jack socket brown',  1
+'4mm shielded jack socket green',  2
+'Mains socket 13A',  1
+'Nut M3 x 2.4mm nyloc',  6
+'Screw M3 cs cap x 12mm',  2
+'Screw M3 cs cap x 20mm',  2
+'Screw M3 dome x 10mm',  4
+'Heatshrink sleeving ID 3.2mm x 15mm - not shown',  8
+'Washer  M3 x 7mm x 0.5mm', 10

examples/MainsBreakOutBox/bom/bom.json

@@ -2,6 +2,8 @@
     {
         "name": "base_assembly",
         "big": null,
+        "ngb": false,
+        "zoomed": 0,
         "count": 1,
         "assemblies": {},
         "vitamins": {
@@ -20,6 +22,8 @@
     {
         "name": "feet_assembly",
         "big": null,
+        "ngb": false,
+        "zoomed": 0,
         "count": 1,
         "assemblies": {
             "base_assembly": 1
@@ -46,6 +50,8 @@
     {
         "name": "mains_in_assembly",
         "big": null,
+        "ngb": false,
+        "zoomed": 0,
         "count": 1,
         "assemblies": {
             "feet_assembly": 1
@@ -82,6 +88,8 @@
     {
         "name": "main_assembly",
         "big": null,
+        "ngb": false,
+        "zoomed": 0,
         "count": 1,
         "assemblies": {
             "mains_in_assembly": 1

examples/MainsBreakOutBox/platters/all.scad

@@ -0,0 +1,11 @@
+include <NopSCADlib/core.scad>
+
+*use_stl("socket_box"); // Importing the STL gives a CGAL error although NetFabb finds nothing wrong with it.
+
+use <../scad/bob_main.scad>
+
+render() socket_box_stl();
+
+for(i = [0 : 3])
+    translate([i * 25 - 1.5 * 25, -70])
+        use_stl("foot");

examples/MainsBreakOutBox/readme.md

@@ -15,6 +15,7 @@ Earth leakage can be measured Canadian CSA style by disconnected the neutral lin
 
 ![Main Assembly](assemblies/main_assembled.png)
 
+<span></span>
 
 ---
 ## Table of Contents
@@ -24,6 +25,7 @@ Earth leakage can be measured Canadian CSA style by disconnected the neutral lin
 1. [Mains In Assembly](#mains_in_assembly)
 1. [Main Assembly](#main_assembly)
 
+<span></span>
 [Top](#TOP)
 
 ---
@@ -54,6 +56,7 @@ Earth leakage can be measured Canadian CSA style by disconnected the neutral lin
 | &nbsp;&nbsp;1&nbsp; | &nbsp;&nbsp;.&nbsp; | &nbsp;&nbsp;.&nbsp; | &nbsp;&nbsp;.&nbsp; |  &nbsp;&nbsp;1&nbsp; | &nbsp;&nbsp;socket_box.stl |
 | &nbsp;&nbsp;1&nbsp; | &nbsp;&nbsp;4&nbsp; | &nbsp;&nbsp;.&nbsp; | &nbsp;&nbsp;.&nbsp; | &nbsp;&nbsp;5&nbsp; | &nbsp;&nbsp;Total 3D printed parts count |
 
+<span></span>
 [Top](#TOP)
 
 ---
@@ -81,6 +84,7 @@ Earth leakage can be measured Canadian CSA style by disconnected the neutral lin
 
 ![base_assembled](assemblies/base_assembled.png)
 
+<span></span>
 [Top](#TOP)
 
 ---
@@ -117,6 +121,7 @@ Earth leakage can be measured Canadian CSA style by disconnected the neutral lin
 
 ![feet_assembled](assemblies/feet_assembled.png)
 
+<span></span>
 [Top](#TOP)
 
 ---
@@ -156,6 +161,7 @@ Earth leakage can be measured Canadian CSA style by disconnected the neutral lin
 
 ![mains_in_assembled](assemblies/mains_in_assembled.png)
 
+<span></span>
 [Top](#TOP)
 
 ---
@@ -199,4 +205,5 @@ Earth leakage can be measured Canadian CSA style by disconnected the neutral lin
 
 ![main_assembled](assemblies/main_assembled.png)
 
+<span></span>
 [Top](#TOP)

examples/MainsBreakOutBox/scad/bob_main.scad

@@ -31,7 +31,8 @@
 //! while its earth is disconnected. Don't be tempted to float the earth of an oscilloscope this way, use a mains isolation transformer to power the DUT instead.
 //! Earth leakage can be measured Canadian CSA style by disconnected the neutral link from the left socket and linking the central neutral to the live.
 //
-$extrusion_width = 0.5;
+$extrusion_width = 0.4;
+$layer_height = 0.2;
 $pp1_colour = "dimgrey";
 $pp2_colour = [0.9, 0.9, 0.9];
 
@@ -52,7 +53,7 @@ iec = IEC_inlet_atx;
 socket = Contactum;
 
 
-foot = [20, 8, 3, 1, M3_dome_screw, 10];
+foot = Foot(d = 20, h = 8, t = 3, r = 1, screw = M3_dome_screw);
 
 module foot_stl() foot(foot);
 

examples/MainsBreakOutBox/stls/deps/all.txt

@@ -0,0 +1,5 @@
+socket_box.stl
+foot.stl
+foot.stl
+foot.stl
+foot.stl

gallery/readme.md

@@ -1,40 +1,35 @@
 # A gallery of projects made with NopSCADlib
-<a name="TOP"></a>
 ## ArduinoThermostat
 Arduino thermostat to control a beer fridge to use it as an environmental chamber.
 
 ![](ArduinoThermostat.png)
 
-
-<a name="TOP"></a>
 ## EnviroPlus
 Environmental monitor using Enviro+ sensor board and a Raspberry Pi Zero.
 
 ![](EnviroPlus.png)
 
-
-<a name="TOP"></a>
 ## FilamentDryBox
 A small fan oven with a spool holder to keep the filament warm and dry.
 
 ![](FilamentDryBox.png)
 
-
-<a name="TOP"></a>
 ## HydraBot
 Current state of HydraRaptor after being modified for laser engraving.
 
 ![](HydraBot.png)
 
 
-<a name="TOP"></a>
 ## IOT 50V PSU
 WiFi controllable PSU
 
 ![](IOT_50V_PSU.png)
 
+## IOT LOAD
+WiFi controllable programmable load
+
+![](IOT_LOAD.png)
 
-<a name="TOP"></a>
 ## Lab ATX PSU
 Bench power supply built around an ATX PSU.
 
@@ -43,19 +38,15 @@ Bench power supply built around an ATX PSU.
 * The green LED shows the power good signal.
 * Dummy loads keep the outputs in range.
 
-
-
 ![](Lab_ATX_PSU.png)
 
 
-<a name="TOP"></a>
+
 ## Laser Load
 15kV dummy load for testing CO2 laser PSUs
 
 ![](Laser_load.png)
 
-
-<a name="TOP"></a>
 ## MainsBreakOutBox
 13A socket break out box with 4mm jacks to measure voltage and / or load current and earth leakage current.
 
@@ -72,36 +63,39 @@ Earth leakage can be measured Canadian CSA style by disconnected the neutral lin
 
 ![](MainsBreakOutBox.png)
 
-
-<a name="TOP"></a>
 ## Mains Box
 Mains isolated and variable supply with metering.
 
-
-
 ![](Mains_Box.png)
 
 
-<a name="TOP"></a>
+
+## PSU Cover
+A base and shroud to make PSU safe to sit on a desk
+
+![](PSU_cover.png)
+
+## PotBox
+Potentiometer box with course and fine controls and three 4mm binding posts
+
+![](PotBox.png)
+
 ## SunBot
 A solar tracker to keep a solar panel pointing at the sun.
 
 ![](SunBot.png)
 
-
-<a name="TOP"></a>
 ## Turntable
 WiFi enabled remote control turntable for photography
 
 ![](Turntable.png)
 
+Was actually made from DiBond but shown made with carbon fibre here.
 
-<a name="TOP"></a>
 ## Variac
 Motorised variac with WiFi control, see [hydraraptor.blogspot.com/2018/04/esp8266-spi-spy](https://hydraraptor.blogspot.com/2018/04/esp8266-spi-spy.html)
 
-
-
 ![](Variac.png)
 
 
+

global_defs.scad

@@ -24,22 +24,23 @@
 //  bom defaults to 0
 //  Setting $bom on the command line or in the main file before including lib.scad overrides it everywhere.
 //  Setting $bom after including lib overrides bom in the libs but not in the local file.
-//  Setting $_bom in the local file overrides it in the local file but not in the libs.
 //
-//function is_undef(x) = x == undef;
+rr_green = [0, 146/255, 0];                                               // RepRap logo colour
+crimson  = [220/255, 20/255, 60/255];
 
-$_bom           = is_undef($bom)             ? 0      : $bom;             // 0 no bom, 1 assemblies and stls, 2 vitamins as well
-$exploded       = is_undef($explode)         ? 0      : $explode;         // 1 for exploded view
-layer_height    = is_undef($layer_height)    ? 0.25   : $layer_height;    // layer heigth when printing
+layer_height    = is_undef($layer_height)    ? 0.25   : $layer_height;    // layer height when printing
 extrusion_width = is_undef($extrusion_width) ? 0.5    : $extrusion_width; // filament width when printing
 nozzle          = is_undef($nozzle)          ? 0.45   : $nozzle;          // 3D printer nozzle
-cnc_bit_r       = is_undef($cnc_bit_r)       ? 1.2    : $cnc_bit_r;       // miniumum tool radius when milling 2D objects
-pp1_colour      = is_undef($pp1_colour)      ? [0, 146/255, 0] : $pp1_colour; // printed part colour 1, RepRap logo colour
-pp2_colour      = is_undef($pp2_colour)      ? "red"  : $pp2_colour;      // printed part colour 2
-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
+cnc_bit_r       = is_undef($cnc_bit_r)       ? 1.2    : $cnc_bit_r;       // minimum tool radius when milling 2D objects
 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
+show_plugs      = is_undef($show_plugs)      ? false  : $show_plugs;      // plugs on headers
+teardrop_angle  = is_undef($teardrop_angle)  ? 45     : $teardrop_angle;  // teardrop angle
+pp1_colour      = is_undef($pp1_colour)      ? rr_green     : $pp1_colour;// printed part colour 1, RepRap logo colour
+pp2_colour      = is_undef($pp2_colour)      ? crimson      : $pp2_colour;// printed part colour 2
+pp3_colour      = is_undef($pp3_colour)      ? "SteelBlue"  : $pp3_colour;// printed part colour 3
+pp4_colour      = is_undef($pp4_colour)      ? "darkorange" : $pp4_colour;// printed part colour 4
+
 
 // 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)
@@ -50,19 +51,14 @@ eps = 1/128;     // small fudge factor to stop CSG barfing on coincident faces.
 $fa = 6;
 $fs = extrusion_width / 2;
 
-function round_to_layer(z) = ceil(z / layer_height) * layer_height;
+function round_to_layer(z) = ceil(z / layer_height) * layer_height;         //! Round up to a multiple of layer_height.
+
 // Some additional named colours
-grey20                          = [0.2, 0.2, 0.2];
-grey30                          = [0.3, 0.3, 0.3];
-grey40                          = [0.4, 0.4, 0.4];
-grey50                          = [0.5, 0.5, 0.5];
-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];
-gold                            = [255/255, 215/255, 0/255];
-brass                           = [255/255, 220/255, 100/255];
-silver                          = [0.75, 0.75, 0.75];
+function grey(n) = [0.01, 0.01, 0.01] * n;                                  //! Generate a shade of grey to pass to color().
+silver           = [0.75, 0.75, 0.75];
+gold             = [255, 215,   0] / 255;
+brass            = [255, 220, 100] / 255;
+copper           = [230, 140,  51] / 255;
 
 /*
  * Enums
@@ -78,11 +74,6 @@ hs_grub   = 4;     // pulley set screw
 hs_cs_cap = 5;
 hs_dome   = 6;
 //
-// Hot end descriptions
-//
-jhead   = 1;
-e3d     = 2;
-//
 // Face enumeration
 //
 f_bottom = 0;

lib.scad

@@ -26,32 +26,37 @@ include <vitamins/psus.scad>
 include <vitamins/pcbs.scad>
 
 include <vitamins/batteries.scad>
+include <vitamins/bearing_blocks.scad>
 include <vitamins/blowers.scad>
+include <vitamins/bldc_motors.scad>
+include <vitamins/box_sections.scad>
 include <vitamins/bulldogs.scad>
 include <vitamins/buttons.scad>
+include <vitamins/cameras.scad>
 include <vitamins/components.scad>
 include <vitamins/displays.scad>
 include <vitamins/extrusions.scad>
 include <vitamins/extrusion_brackets.scad>
 include <vitamins/geared_steppers.scad>
-include <vitamins/green_terminals.scad>
 include <vitamins/hot_ends.scad>
 include <vitamins/inserts.scad>
-include <vitamins/kp_pillow_blocks.scad>
 include <vitamins/ldrs.scad>
 include <vitamins/leadnuts.scad>
 include <vitamins/led_meter.scad>
 include <vitamins/light_strips.scad>
+include <vitamins/magnets.scad>
 include <vitamins/mains_sockets.scad>
 include <vitamins/modules.scad>
 include <vitamins/panel_meters.scad>
 include <vitamins/pillars.scad>
+include <vitamins/pillow_blocks.scad>
 include <vitamins/pin_headers.scad>
 include <vitamins/pulleys.scad>
 include <vitamins/ring_terminals.scad>
 include <vitamins/rails.scad>
 include <vitamins/rod.scad>
-include <vitamins/scs_bearing_blocks.scad>
+include <vitamins/servo_motors.scad>
+include <vitamins/shaft_couplings.scad>
 include <vitamins/sheets.scad>
 include <vitamins/sk_brackets.scad>
 include <vitamins/spools.scad>
@@ -83,9 +88,11 @@ use <utils/rounded_cylinder.scad>
 use <utils/dogbones.scad>
 use <utils/tube.scad>
 use <utils/quadrant.scad>
+use <utils/gears.scad>
 use <utils/hanging_hole.scad>
 use <utils/fillet.scad>
 use <utils/rounded_polygon.scad>
+use <utils/rounded_triangle.scad>
 use <utils/layout.scad>
 use <utils/round.scad>
 use <utils/offset.scad>

libtest.scad

@@ -17,22 +17,48 @@
 // If not, see <https://www.gnu.org/licenses/>.
 //
 
+//!# NopSCADlib
+//! An ever expanding library of parts modelled in OpenSCAD useful for 3D printers and enclosures for electronics, etc.
+//!
+//! It contains lots of vitamins (the RepRap term for non-printed parts), some general purpose printed parts and some utilities.
+//! There are also Python scripts to generate Bills of Materials (BOMs),
+//! STL files for all the printed parts, DXF files for CNC routed parts in a project and a manual containing assembly
+//! instructions and exploded views by scraping markdown embedded in OpenSCAD comments, [see scripts](scripts/readme.md).
+//!
+//! A simple example project can be found [here](examples/MainsBreakOutBox/readme.md).
+//!
+//! For more examples of what it can make see the [gallery](gallery/readme.md).
+//!
+//! The license is GNU General Public License v3.0, see [COPYING](COPYING).
+//!
+//! See [usage](docs/usage.md) for requirements, installation instructions and a usage guide.
+//!
+//! A list of changes classified as breaking, additions or fixes is maintained in [CHANGELOG.md](CHANGELOG.md).
+//!
+//! <img src="libtest.png" width="100%"/>
 //
 // This file shows all the parts in the library.
 //
 include <lib.scad>
 
+use <tests/7_segments.scad>
 use <tests/ball_bearings.scad>
 use <tests/batteries.scad>
+use <tests/bearing_blocks.scad>
 use <tests/belts.scad>
+use <tests/BLDC_motors.scad>
 use <tests/blowers.scad>
+use <tests/box_sections.scad>
 use <tests/bulldogs.scad>
 use <tests/buttons.scad>
 use <tests/cable_strips.scad>
+use <tests/cameras.scad>
+use <tests/camera_housing.scad>
 use <tests/circlips.scad>
 use <tests/components.scad>
 use <tests/d_connectors.scad>
 use <tests/displays.scad>
+use <tests/drag_chain.scad>
 use <tests/extrusions.scad>
 use <tests/extrusion_brackets.scad>
 use <tests/fans.scad>
@@ -42,13 +68,13 @@ use <tests/hot_ends.scad>
 use <tests/IECs.scad>
 use <tests/inserts.scad>
 use <tests/jack.scad>
-use <tests/KP_pillow_blocks.scad>
 use <tests/leadnuts.scad>
 use <tests/LDRs.scad>
 use <tests/LEDs.scad>
 use <tests/light_strips.scad>
 use <tests/linear_bearings.scad>
 use <tests/LED_meters.scad>
+use <tests/magnets.scad>
 use <tests/microswitches.scad>
 use <tests/modules.scad>
 use <tests/nuts.scad>
@@ -57,6 +83,9 @@ use <tests/opengrab.scad>
 use <tests/panel_meters.scad>
 use <tests/PCBs.scad>
 use <tests/pillars.scad>
+use <tests/pillow_blocks.scad>
+use <tests/potentiometers.scad>
+use <tests/press_fit.scad>
 use <tests/PSUs.scad>
 use <tests/pulleys.scad>
 use <tests/rails.scad>
@@ -64,15 +93,16 @@ use <tests/ring_terminals.scad>
 use <tests/rockers.scad>
 use <tests/rod.scad>
 use <tests/screws.scad>
-use <tests/SCS_bearing_blocks.scad>
 use <tests/sealing_strip.scad>
+use <tests/servo_motors.scad>
+use <tests/shaft_couplings.scad>
 use <tests/sheets.scad>
 use <tests/SK_brackets.scad>
 use <tests/spades.scad>
 use <tests/springs.scad>
 use <tests/SSRs.scad>
 use <tests/stepper_motors.scad>
-use <tests/swiss_clips.scad>
+use <tests/Swiss_clips.scad>
 use <tests/toggles.scad>
 use <tests/transformers.scad>
 use <tests/tubings.scad>
@@ -93,8 +123,11 @@ use <tests/fixing_block.scad>
 use <tests/flat_hinge.scad>
 use <tests/foot.scad>
 use <tests/handle.scad>
+use <tests/knob.scad>
 use <tests/PCB_mount.scad>
+use <tests/pocket_handle.scad>
 use <tests/printed_box.scad>
+use <tests/printed_pulleys.scad>
 use <tests/ribbon_clamp.scad>
 use <tests/screw_knob.scad>
 use <tests/socket_box.scad>
@@ -115,17 +148,20 @@ cable_grommets_y = 0;
 translate([x5, cable_grommets_y])
     cable_grommets();
 
-translate([x5, cable_grommets_y + 50])
-    feet();
+translate([x5 + 50, cable_grommets_y])
+    ribbon_clamps();
 
-translate([x5, cable_grommets_y + 75])
+translate([x5 + 95, cable_grommets_y])
+    press_fits();
+
+translate([x5, cable_grommets_y + 60])
     fixing_blocks();
 
-translate([x5, cable_grommets_y + 100])
+translate([x5, cable_grommets_y + 90])
     corner_blocks();
 
 translate([x5, cable_grommets_y + 150])
-    ribbon_clamps();
+    feet();
 
 translate([x5 + 70, cable_grommets_y + 150])
     screw_knobs();
@@ -138,25 +174,33 @@ translate([x5, cable_grommets_y + 470]) {
         flat_hinges();
 }
 
-translate([x5, cable_grommets_y + 370])
+translate([x5, cable_grommets_y + 380])
     no_explode() socket_boxes();
 
-translate([x5 + 60, cable_grommets_y + 200])
+translate([640, cable_grommets_y + 200])
+    printed_pulley_test();
+
+translate([x5, cable_grommets_y + 200])
+    knobs();
+
+translate([x5 + 60, cable_grommets_y + 250])
     strap_handles();
 
-translate([x5, cable_grommets_y + 250])
+translate([x5, cable_grommets_y + 300])
     handle();
 
 translate([950, 600])
     box_test();
 
-translate([890, 750])
+translate([900, 750])
+    pocket_handles();
+
+translate([900, 850])
     printed_boxes();
 
-translate([850, 1330])
+translate([850, 1330 + 85])
     bbox_test();
 
-
 inserts_y = 0;
 nuts_y = inserts_y + 20;
 washers_y = nuts_y + 120;
@@ -168,13 +212,14 @@ sealing_strip_y = springs_y + 20;
 tubings_y = sealing_strip_y + 20;
 pillars_y = tubings_y + 20;
 ball_bearings_y = pillars_y + 40;
-pulleys_y = ball_bearings_y +40;
-hot_ends_y = pulleys_y + 60;
-linear_bearings_y = hot_ends_y + 50;
-sheets_y = linear_bearings_y + 100;
-pcbs_y = sheets_y + 40;
-displays_y = pcbs_y + 170;
-fans_y = displays_y + 80;
+pulleys_y = ball_bearings_y + 40;
+leadnuts_y = pulleys_y + 60;
+linear_bearings_y = leadnuts_y + 50;
+steppers_y = linear_bearings_y + 110;
+sheets_y = steppers_y + 55;
+pcbs_y = sheets_y + 60;
+displays_y = pcbs_y + 140;
+fans_y = displays_y + 110;
 transformers_y = fans_y + 120;
 psus_y = transformers_y + 190;
 
@@ -217,13 +262,16 @@ translate([x0, ball_bearings_y])
 translate([x0, pulleys_y])
     pulleys();
 
+translate([x0, leadnuts_y])
+    leadnuts();
+
 translate([x0, linear_bearings_y]) {
     linear_bearings();
     rods();
 }
 
-translate([x0 + 10, hot_ends_y])
-    hot_ends();
+translate([x0, steppers_y])
+    stepper_motors();
 
 translate([x0, sheets_y])
     sheets();
@@ -241,7 +289,7 @@ translate([x0, fans_y]) {
         fan_guards();
 }
 
-translate([x0, transformers_y])
+translate([760, fans_y])
     variacs();
 
 translate([x0, psus_y]) {
@@ -253,7 +301,6 @@ translate([x0, psus_y]) {
 zipties_y = 0;
 bulldogs_y = zipties_y + 30;
 swiss_clips_y = bulldogs_y + 35;
-leadnuts_y = swiss_clips_y + 50;
 
 translate([x1, zipties_y])
     zipties();
@@ -264,14 +311,11 @@ translate([x1, bulldogs_y])
 translate([x1, swiss_clips_y])
     swiss_clips();
 
-translate([x1, leadnuts_y])
-    leadnuts();
-
-
 leds_y = 0;
 carriers_y = leds_y + 40;
-spades_y = carriers_y + 40;
-buttons_y = spades_y + 40;
+magnets_y = carriers_y + 40;
+spades_y = magnets_y + 20;
+buttons_y = spades_y + 20;
 jacks_y = buttons_y + 40;
 microswitches_y = jacks_y + 40;
 rockers_y = microswitches_y + 40;
@@ -287,6 +331,9 @@ translate([x2 + 35, leds_y])
 translate([x2 + 8, carriers_y])
     carriers();
 
+translate([x2, magnets_y])
+    magnets();
+
 translate([x2 + 20, carriers_y])
     led_meters();
 
@@ -320,23 +367,29 @@ iecs_y = d_connectors_y + 80;
 modules_y = iecs_y + 60;
 ssrs_y = modules_y + 80;
 blowers_y = ssrs_y + 60;
-batteries_y = blowers_y + 100;
-steppers_y = batteries_y + 70;
-panel_meters_y = steppers_y + 70;
+hot_ends_y = blowers_y + 100;
+batteries_y = hot_ends_y + 55;
+panel_meters_y = batteries_y + 70;
 extrusions_y = panel_meters_y + 80;
 
 translate([x3, veroboard_y])
     veroboard_test();
 
-translate([x3 + 70, veroboard_y + 30])
+translate([x3 + 60, veroboard_y + 20])
     geared_steppers();
 
-translate([x3 + 140, veroboard_y + 20])
+translate([x3 + 160, ssrs_y])
     pcb_mounts();
 
+translate([x3 + 170, veroboard_y + 16])
+    cameras();
+
 translate([x3, d_connectors_y])
     d_connectors();
 
+translate([x3 + 170, d_connectors_y - 10])
+    camera_housings();
+
 translate([x3, iecs_y])
     iecs();
 
@@ -361,8 +414,8 @@ translate([x3, blowers_y])
 translate([x3, batteries_y])
     batteries();
 
-translate([x2, steppers_y])  // interloper
-    stepper_motors();
+translate([x3 + 10, hot_ends_y])
+    hot_ends();
 
 translate([x2, panel_meters_y])
     panel_meters();
@@ -370,7 +423,7 @@ translate([x2, panel_meters_y])
 translate([x2, extrusions_y])
     extrusions();
 
-translate([x3, transformers_y])
+translate([400, transformers_y])
     transformers();
 
 
@@ -378,20 +431,30 @@ belts_y = 0;
 rails_y = belts_y + 200;
 extrusion_brackets_y = rails_y + 250;
 sk_brackets_y = extrusion_brackets_y + 80;
-kp_pillow_blocks_y = sk_brackets_y + 50;
+kp_pillow_blocks_y = sk_brackets_y + 60;
 scs_bearing_blocks_y = kp_pillow_blocks_y + 60;
+box_sections_y = batteries_y;
+BLDC_y = scs_bearing_blocks_y + 120;
+pot_y = BLDC_y + 40;
+cable_strip_y = pot_y + 50;
 
-translate([x4 + 150, belts_y + 58]) {
+translate([0, transformers_y])
+    servo_motors();
+
+translate([x4 + 200, belts_y + 58]) {
     belt_test();
 
     translate([0, 60])
         opengrab_test();
 }
 
+translate([x4 + 175, belts_y, -20])
+    drag_chains();
+
 translate([x4, rails_y + 130])
     rails();
 
-translate([800, fans_y + 50])
+translate([x4, cable_strip_y])
     cable_strips();
 
 translate([x4, kp_pillow_blocks_y])
@@ -403,9 +466,20 @@ translate([x4, sk_brackets_y])
 translate([x4, extrusion_brackets_y])
     extrusion_brackets();
 
+translate([x1, swiss_clips_y + 50])
+    shaft_couplings();
+
 translate([x4, scs_bearing_blocks_y])
     scs_bearing_blocks();
 
+translate([x4, BLDC_y])
+    bldc_motors();
+
+translate([x4, pot_y])
+    potentiometers();
+
+translate([x2, box_sections_y])
+    box_sections();
 
 translate([x6, 125])
     light_strips();

printed/box.scad

@@ -23,7 +23,7 @@
 //! together. The box panels can be customised to have holes and parts mounted on them by overriding the
 //! definitions of `box_base()`, `box_front()`, etc.
 //!
-//! `box.scad` should be ```use```d and `box_assembly.scad` ```include```d.
+//! `box.scad` should be `use`d and `box_assembly.scad` `include`d.
 //!
 //! A box is defined with a list that specifies the inside dimensions, top, bottom and side sheet materials, the
 //! screw type and printed part wall thickness. This diagram shows how the various dimensions are labelled:
@@ -33,24 +33,29 @@
 //
 include <../utils/core/core.scad>
 use <../vitamins/sheet.scad>
+use <../vitamins/insert.scad>
 use <../vitamins/screw.scad>
 use <../vitamins/washer.scad>
-use <../vitamins/insert.scad>
 use <../utils/quadrant.scad>
+use <../utils/round.scad>
 
 bezel_clearance = 0.2;
 sheet_end_clearance = 1;
 sheet_slot_clearance = 0.2;
 
-function box_screw(type)     = type[0]; //! Screw type to be used at the corners
-function box_wall(type)      = type[1]; //! Wall thickness of 3D parts
-function box_sheets(type)    = type[2]; //! Sheet type used for the sides
-function box_top_sheet(type) = type[3]; //! Sheet type for the top
-function box_base_sheet(type)= type[4]; //! Sheet type for the bottom
-function box_feet(type)      = type[5]; //! True to enable feet on the bottom bezel
-function box_width(type)     = type[6]; //! Internal width
-function box_depth(type)     = type[7]; //! Internal depth
-function box_height(type)    = type[8]; //! Internal height
+function box_screw(type)       = type[0]; //! Screw type to be used at the corners
+function box_shelf_screw(type) = type[1]; //! Screw type to hold a shelf
+function box_wall(type)        = type[2]; //! Wall thickness of 3D parts
+function box_sheets(type)      = type[3]; //! Sheet type used for the sides
+function box_top_sheet(type)   = type[4]; //! Sheet type for the top
+function box_base_sheet(type)  = type[5]; //! Sheet type for the bottom
+function box_feet(type)        = type[6]; //! True to enable feet on the bottom bezel
+function box_width(type)       = type[7]; //! Internal width
+function box_depth(type)       = type[8]; //! Internal depth
+function box_height(type)      = type[9]; //! Internal height
+
+function box(screw, wall, sheets, top_sheet, base_sheet, size, feet = false, shelf_screw = undef) = //! Construct a property list for a box.
+ concat([screw, is_undef(shelf_screw) ? screw : shelf_screw, wall, sheets, top_sheet, base_sheet, feet], size);
 
 function box_bezel_clearance(type) = bezel_clearance;
 
@@ -59,6 +64,7 @@ function box_profile_overlap(type) = 3 + sheet_end_clearance / 2;
 
 function box_washer(type) = screw_washer(box_screw(type));
 function box_insert(type) = screw_insert(box_screw(type));
+function box_shelf_insert(type) = screw_insert(box_shelf_screw(type));
 
 function box_hole_inset(type) = washer_radius(box_washer(type)) + 1;
 function box_insert_r(type) = insert_hole_radius(box_insert(type));
@@ -71,9 +77,9 @@ function box_corner_overlap(type) = box_wall(type);
 function box_corner_rad(type) = box_sheet_slot(type) - sheet_slot_clearance / 2 + box_corner_gap(type) + box_corner_overlap(type);
 function box_sheet_r(type) = box_corner_rad(type) - box_sheet_slot(type) - box_corner_overlap(type);
 
-function box_screw_length(type, top) = screw_longer_than(2 * washer_thickness(box_washer(type))
-                                                    + sheet_thickness(top ? box_top_sheet(type) : box_base_sheet(type))
-                                                    + box_corner_gap(type) + box_profile_overlap(type) + box_insert_l(type) - 1);
+function box_screw_length(type, top) =
+    let(s = top ? box_top_sheet(type) : box_base_sheet(type))
+        screw_length(box_screw(type), sheet_thickness(s) + box_corner_gap(type) + box_profile_overlap(type) - 1, washers = 2, insert = true, longer = true);
 
 function box_wall_clearance(type) = box_sheet_slot(type) / 2 - sheet_thickness(box_sheets(type)) / 2;
 function box_margin(type) = box_profile_overlap(type) + box_corner_gap(type); //! How much the bezel intrudes on the specified height
@@ -87,32 +93,42 @@ function box_bezel_height(type, bottom) = //! Bezel height for top or bottom
 
 grill_hole = 5;
 grill_gap = 1.9;
-module grill(width, height, r = 1000, poly = false, h = 0) { //! A staggered array of 5mm holes to make grills in sheets. Can be constrained to be circular. Set ```poly``` ```true``` for printing, ```false``` for milling.
+
+function box_grill_hole_r() = grill_hole / 2;
+
+module grill_hole_positions(width, height, r = 1000) {
     nx = floor(width / (grill_hole + grill_gap));
     xpitch = width / nx;
     ny = floor(height / ((grill_hole + grill_gap) * cos(30)));
     ypitch = height / ny;
 
+    for(y = [0 : ny - 1], x = [0 : nx - 1 - (y % 2)]) {
+        $x = -width / 2 + (x + 0.5 + (y % 2) / 2) * xpitch;
+        $y = -height / 2 + (y + 0.5) * ypitch;
+        if(sqrt(sqr($x) + sqr($y)) + grill_hole / 2 <= r)
+            translate([$x, $y])
+                children();
+    }
+}
+
+module grill(width, height, r = 1000, poly = false, h = 0) { //! A staggered array of 5mm holes to make grills in sheets. Can be constrained to be circular. Set `poly` `true` for printing, `false` for milling.
     extrude_if(h)
-        for(y = [0 : ny - 1], x = [0 : nx - 1 - (y % 2)]) {
-            x = -width / 2 + (x + 0.5 + (y % 2) / 2) * xpitch;
-            y = -height / 2 + (y + 0.5) * ypitch;
-            if(sqrt(sqr(x) + sqr(y)) + grill_hole / 2 <= r)
-                translate([x, y])
-                    if(poly)
-                        poly_circle(r = grill_hole / 2);
-                    else
-                        circle(d = grill_hole);
-        }
+        if(poly)
+            grill_hole_positions(width, height, r)
+                poly_circle(r = grill_hole / 2);
+        else
+            grill_hole_positions(width, height, r)
+                circle(d = grill_hole);
 }
 
 module box_corner_profile_2D(type) { //! The 2D shape of the corner profile.
     t = box_sheet_slot(type);
+    inset = box_corner_gap(type) + box_profile_overlap(type);
     difference() {
         union() {
             quadrant(box_hole_inset(type) + box_boss_r(type), box_boss_r(type));     // inside corner
 
-            translate([box_corner_gap(type) + box_profile_overlap(type), box_corner_gap(type) + box_profile_overlap(type)])
+            translate([inset, inset])
                 rotate(180)
                     quadrant(box_profile_overlap(type) + box_corner_rad(type), box_corner_rad(type)); // outside corner
         }
@@ -125,17 +141,17 @@ module box_corner_profile_2D(type) { //! The 2D shape of the corner profile.
 }
 
 module box_corner_profile(type) { //! Generates the corner profile STL for 3D printing.
-    stl("box_corner_profile");
-
     length = box_height(type) - 2 * box_margin(type);
-    difference() {
-        linear_extrude(length, center = true, convexity = 5)
-            box_corner_profile_2D(type);
 
-        for(z = [-1, 1])
-            translate([box_hole_inset(type), box_hole_inset(type), z * length / 2])
-                insert_hole(box_insert(type), 5);
-    }
+    stl("box_corner_profile")
+        difference() {
+            linear_extrude(length, center = true, convexity = 5)
+                box_corner_profile_2D(type);
+
+            for(z = [-1, 1])
+                translate([box_hole_inset(type), box_hole_inset(type), z * length / 2])
+                    insert_hole(box_insert(type), 5);
+        }
 }
 
 module box_corner_profile_section(type, section, sections) { //! Generates interlocking sections of the corner profile to allow it to be taller than the printer
@@ -175,6 +191,15 @@ module box_corner_profile_section(type, section, sections) { //! Generates inter
     }
 }
 
+module box_corner_profile_sections(type, section, sections) { //! Generate four copies of a corner profile section
+    stl("box_corner_profile");
+    offset = box_boss_r(type) + 1;
+    for(i = [0 : 3])
+        rotate(i * 90)
+            translate([offset, offset])
+                box_corner_profile_section(type, section, sections);
+}
+
 module box_corner_quadrants(type, width, depth)
     for(corner = [0:3]) {
         x = [-1,1,1,-1][corner];
@@ -186,89 +211,98 @@ module box_corner_quadrants(type, width, depth)
     }
 
 module box_bezel(type, bottom) { //! Generates top and bottom bezel STLs
-    stl(bottom ? "bottom_bezel" : "top_bezel");
     feet = bottom && box_feet(type);
     t = box_sheet_slot(type);
     outset =  box_outset(type);
+    inset = box_inset(type);
     inner_r = box_sheet_r(type);
-    foot_height = box_corner_gap(type) + sheet_thickness(box_base_sheet(type)) + washer_thickness(box_washer(type)) + screw_head_height(box_screw(type)) + box_profile_overlap(type) + 2;
+    cgap = box_corner_gap(type);
+    foot_height = cgap + sheet_thickness(box_base_sheet(type)) + washer_thickness(box_washer(type)) + screw_head_height(box_screw(type)) + box_profile_overlap(type) + 2;
     foot_length = box_corner_rad(type) * 2;
     height = box_bezel_height(type, bottom);
     foot_extension = foot_height - height;
 
-    difference() {
-        translate_z(-box_profile_overlap(type)) difference() {
-            rounded_rectangle([box_width(type) + 2 * outset, box_depth(type) + 2 * outset, feet ? foot_height : height], box_corner_rad(type), false);
-            //
-            // Remove edges between the feet
-            //
-            if(feet)
-                hull() {
-                    translate_z(height + 0.5)
-                        cube([box_width(type) - 2 * foot_length, box_depth(type) + 2 * outset + 1, 1], center = true);
+    stl(bottom ? "bottom_bezel" : "top_bezel")
+        difference() {
+            w = box_width(type);
+            d = box_depth(type);
+            translate_z(-box_profile_overlap(type)) difference() {
+                tw = w + 2 * outset;
+                td = d + 2 * outset;
+                rounded_rectangle([tw, td, feet ? foot_height : height], box_corner_rad(type));
+                //
+                // Remove edges between the feet
+                //
+                if(feet)
+                    hull() {
+                        translate_z(height + 0.5)
+                            cube([w - 2 * foot_length, td + 1, 1], center = true);
 
-                    translate_z(foot_height + 1)
-                        cube([box_width(type) - 2 * (foot_length - foot_extension), box_depth(type) + 2 * outset + 1, 1], center = true);
-                }
-            if(feet)
-                hull() {
-                    translate_z(height + 0.5)
-                        cube([box_width(type) + 2 * outset + 1, box_depth(type) - 2 * foot_length, 1], center = true);
-
-                    translate_z(foot_height + 1)
-                        cube([box_width(type) + 2 * outset + 1, box_depth(type) - 2 * (foot_length - foot_extension), 1], center = true);
-                }
-        }
-        //
-        // slots for side panels
-        //
-        translate_z(-box_profile_overlap(type))
-            linear_extrude(2 * box_profile_overlap(type), center = true)
-                for(i = [-1, 1]) {
-                    translate([i * (box_width(type) / 2 + t / 2 - sheet_slot_clearance / 2), 0])
-                         square([t, box_depth(type) - 2 * box_corner_gap(type)], center = true);
-
-                    translate([0, i * (box_depth(type) / 2 + t / 2 - sheet_slot_clearance / 2)])
-                         square([box_width(type) - 2 * box_corner_gap(type), t], center = true);
-                }
-        //
-        // recess for top / bottom panel
-        //
-        translate_z(box_corner_gap(type))
-            rounded_rectangle([box_width(type) + bezel_clearance, box_depth(type) + bezel_clearance, height], inner_r + bezel_clearance / 2, false);
-        //
-        // leave plastic over the corner profiles
-        //
-        translate_z(-box_profile_overlap(type) - 1)
-            linear_extrude(box_profile_overlap(type) + box_corner_gap(type) + 2)
-                union() {
-                    difference() {
-                        square([box_width(type) - 2 * box_inset(type),
-                                box_depth(type) - 2 * box_inset(type)], center = true);
-
-                        box_corner_quadrants(type, box_width(type), box_depth(type));
+                        translate_z(foot_height + 1)
+                            cube([w - 2 * (foot_length - foot_extension), td + 1, 1], center = true);
                     }
-                    box_screw_hole_positions(type)
-                        poly_circle(screw_clearance_radius(box_screw(type)));
-                }
-     }
+                if(feet)
+                    hull() {
+                        translate_z(height + 0.5)
+                            cube([tw + 1, d - 2 * foot_length, 1], center = true);
+
+                        translate_z(foot_height + 1)
+                            cube([tw + 1, d - 2 * (foot_length - foot_extension), 1], center = true);
+                    }
+            }
+            //
+            // slots for side panels
+            //
+            translate_z(-box_profile_overlap(type))
+                linear_extrude(2 * box_profile_overlap(type), center = true)
+                    for(i = [-1, 1]) {
+                        translate([i * (w + t - sheet_slot_clearance) / 2, 0])
+                             square([t, d - 2 * cgap], center = true);
+
+                        translate([0, i * (d + t - sheet_slot_clearance) / 2])
+                             square([w - 2 * cgap, t], center = true);
+                    }
+            //
+            // recess for top / bottom panel
+            //
+            translate_z(cgap)
+                rounded_rectangle([w + bezel_clearance, d + bezel_clearance, height], inner_r + bezel_clearance / 2);
+            //
+            // leave plastic over the corner profiles
+            //
+            translate_z(-box_profile_overlap(type) - 1)
+                linear_extrude(box_profile_overlap(type) + cgap + 2)
+                    union() {
+                        difference() {
+                            square([w - 2 * inset,
+                                    d - 2 * inset], center = true);
+
+                            box_corner_quadrants(type, w, d);
+                        }
+                        box_screw_hole_positions(type)
+                            poly_circle(screw_clearance_radius(box_screw(type)));
+                    }
+         }
 }
 
 dowel_length = 20;
 dowel_wall = extrusion_width * 3;
 dowel_h_wall = layer_height * 6;
 
-
 module box_bezel_section(type, bottom, rows, cols, x, y) { //! Generates interlocking sections of the bezel to allow it to be bigger than the printer
-    w = (box_width(type) + 2 * box_outset(type)) / cols;
-    h = (box_depth(type) + 2 * box_outset(type)) / rows;
+    tw = box_width(type) + 2 * box_outset(type);
+    w = tw / cols;
+    th = box_depth(type) + 2 * box_outset(type);
+    h = th / rows;
     bw = box_outset(type) - bezel_clearance / 2;
     bw2 = box_outset(type) + box_inset(type);
 
     dw = bw - 2 * dowel_wall;
     dh = box_bezel_height(type, bottom) - dowel_h_wall;
 
-    dh2 = box_profile_overlap(type) + box_corner_gap(type) - dowel_h_wall;
+    profile_overlap = box_profile_overlap(type);
+
+    dh2 = profile_overlap + box_corner_gap(type) - dowel_h_wall;
 
     end_clearance = 0.5;
     module male() {
@@ -276,14 +310,14 @@ module box_bezel_section(type, bottom, rows, cols, x, y) { //! Generates interlo
             linear_extrude(dowel_length - 2 * end_clearance, center = true)
                 difference() {
                     union() {
-                        h = dh - layer_height;
+                        h1 = dh - layer_height;
                         h2 = dh2 - layer_height;
                         hull() {
-                            translate([bw / 2, h / 2])
-                                square([dw - 1, h], center = true);
+                            translate([bw / 2, h1 / 2])
+                                square([dw - 1, h1], center = true);
 
-                            translate([bw / 2, (h - 1) / 2])
-                                square([dw, h - 1], center = true);
+                            translate([bw / 2, (h1 - 1) / 2])
+                                square([dw, h1 - 1], center = true);
                         }
 
                         hull() {
@@ -295,7 +329,7 @@ module box_bezel_section(type, bottom, rows, cols, x, y) { //! Generates interlo
                         }
                     }
                     translate([bw2 / 2, 0])
-                        square([box_sheet_slot(type), 2 * box_profile_overlap(type)], center = true);
+                        square([box_sheet_slot(type), 2 * profile_overlap], center = true);
                 }
     }
 
@@ -336,7 +370,7 @@ module box_bezel_section(type, bottom, rows, cols, x, y) { //! Generates interlo
         render() difference() {
             union() {
                 clip(xmin = 0, xmax = w, ymin = 0, ymax = h)
-                    translate([box_width(type) / 2 + box_outset(type) - x * w, box_depth(type) / 2 + box_outset(type) - y * h, box_profile_overlap(type)])
+                    translate([tw / 2 - x * w, th / 2 - y * h, profile_overlap])
                         box_bezel(type, bottom);
 
                 if(x < cols - 1 && y == 0)
@@ -396,11 +430,14 @@ module box_bezel_section(type, bottom, rows, cols, x, y) { //! Generates interlo
     }
 }
 
-
-module box_screw_hole_positions(type)
+module box_screw_hole_positions(type) {
+    inset = box_hole_inset(type);
+    w = box_width(type) / 2 - inset;
+    d = box_depth(type) / 2 - inset;
     for(x = [-1, 1], y = [-1, 1])
-        translate([x * (box_width(type) / 2 - box_hole_inset(type)), y * (box_depth(type) / 2 - box_hole_inset(type))])
+        translate([x * w, y * d])
             children();
+}
 
 module box_base_blank(type) { //! Generates a 2D template for the base sheet
     dxf("box_base");
@@ -439,33 +476,140 @@ module box_shelf_blank(type, sheet = false) { //! Generates a 2D template for a
     }
 }
 
-module box_left_blank(type, sheet = false) { //! Generates a 2D template for the left sheet, ```sheet``` can be set to override the type
+module box_shelf_screw_positions(type, screw_positions, thickness = 0, wall = undef) { //! Place children at the shelf screw positions
+    w = is_undef(wall) ? box_wall(type) : wall;
+    insert = box_shelf_insert(type);
+    translate_z(-insert_boss_radius(insert, w))
+        for(p = screw_positions)
+            multmatrix(p)
+                translate_z(thickness)
+                    children();
+}
+
+module box_shelf_bracket(type, screw_positions, wall = undef) { //! Generates a shelf bracket, the first optional child is a 2D cutout and the second 3D cutouts
+    w = is_undef(wall) ? box_wall(type) : wall;
+    insert = box_shelf_insert(type);
+    lip = 2 * insert_boss_radius(insert, w);
+    width = insert_length(insert) + w;
+
+    module shape()
+        difference() {
+            square([box_width(type), box_depth(type)], center = true);
+
+            offset(bezel_clearance / 2)
+                box_corner_quadrants(type, box_width(type), box_depth(type));
+
+            if($children)
+                hflip()
+                    children();
+        }
+
+    module boss()
+        translate_z(-width + eps)
+            linear_extrude(width - 2 * eps)
+                hull() {
+                    circle4n(r = lip / 2 - eps);
+
+                    translate([-lip / 2, -lip / 2 + eps])
+                        square([lip, eps]);
+                }
+
+    stl("shelf_bracket")
+        difference() {
+            union() {
+                linear_extrude(w)
+                    difference() {
+                        shape()
+                            if($children)
+                                children(0);
+
+                        round(2) offset(-width)
+                            shape()
+                                if($children)
+                                    children(0);
+                    }
+
+                linear_extrude(lip)
+                    difference() {
+                        shape()
+                            if($children)
+                                children(0);
+
+                        offset(-w)
+                            shape()
+                                if($children)
+                                    children(0);
+                    }
+
+                hflip()
+                    box_shelf_screw_positions(type, screw_positions, 0, w)
+                        boss();
+            }
+            if($children > 1)
+                hflip()
+                    children(1);
+
+            hflip()
+                box_shelf_screw_positions(type, screw_positions, 0, w)
+                    insert_hole(insert, counterbore = 1, horizontal = true);
+        }
+}
+
+module box_shelf_bracket_section(type, rows, cols, x, y) { //! Generates sections of the shelf bracket to allow it to be bigger than the printer
+    tw = box_width(type);
+    w = tw / cols;
+    th = box_depth(type);
+    h = th / rows;
+
+    clip(xmin = 0, xmax = w, ymin = 0, ymax = h)
+        translate([tw / 2 - x * w, th / 2 - y * h])
+            children();
+}
+
+module box_left_blank(type, sheet = false) { //! Generates a 2D template for the left sheet, `sheet` can be set to override the type
     dxf("box_left");
 
     sheet_2D(subst_sheet(type, sheet), box_depth(type) - sheet_reduction(type), box_height(type) - sheet_reduction(type), 1);
 }
 
-module box_right_blank(type, sheet = false) { //! Generates a 2D template for the right sheet, ```sheet``` can be set to override the type
+module box_right_blank(type, sheet = false) { //! Generates a 2D template for the right sheet, `sheet` can be set to override the type
     dxf("box_right");
 
     sheet_2D(subst_sheet(type, sheet), box_depth(type) - sheet_reduction(type), box_height(type) - sheet_reduction(type), 1);
 }
 
-module box_front_blank(type, sheet = false) { //! Generates a 2D template for the front sheet, ```sheet``` can be set to override the type
+module box_front_blank(type, sheet = false) { //! Generates a 2D template for the front sheet, `sheet` can be set to override the type
     dxf("box_front");
 
     sheet_2D(subst_sheet(type, sheet), box_width(type) - sheet_reduction(type), box_height(type) - sheet_reduction(type), 1);
 }
 
-module box_back_blank(type, sheet = false) { //! Generates a 2D template for the back sheet, ```sheet``` can be set to override the type
+module box_back_blank(type, sheet = false) { //! Generates a 2D template for the back sheet, `sheet` can be set to override the type
     dxf("box_back");
 
     sheet_2D(subst_sheet(type, sheet), box_width(type) - sheet_reduction(type), box_height(type) - sheet_reduction(type), 1);
 }
 
-module box_base(type)  render_2D_sheet(box_base_sheet(type)) box_base_blank(type);  //! Default base, can be overridden to customise
-module box_top(type)   render_2D_sheet(box_top_sheet(type))  box_top_blank(type);   //! Default top, can be overridden to customise
-module box_back(type)  render_2D_sheet(box_sheets(type))     box_back_blank(type);  //! Default back, can be overridden to customise
-module box_front(type) render_2D_sheet(box_sheets(type))     box_front_blank(type); //! Default front, can be overridden to customise
-module box_left(type)  render_2D_sheet(box_sheets(type))     box_left_blank(type);  //! Default left side, can be overridden to customise
-module box_right(type) render_2D_sheet(box_sheets(type))     box_right_blank(type); //! Default right side, can be overridden to customise
+module box_base(type)   //! Default base, can be overridden to customise
+    render_2D_sheet(box_base_sheet(type))
+        box_base_blank(type);
+
+module box_top(type)    //! Default top, can be overridden to customise
+    render_2D_sheet(box_top_sheet(type))
+        box_top_blank(type);
+
+module box_back(type)   //! Default back, can be overridden to customise
+    render_2D_sheet(box_sheets(type))
+        box_back_blank(type);
+
+module box_front(type)  //! Default front, can be overridden to customise
+    render_2D_sheet(box_sheets(type))
+        box_front_blank(type);
+
+module box_left(type)   //! Default left side, can be overridden to customise
+    render_2D_sheet(box_sheets(type))
+        box_left_blank(type);
+
+module box_right(type) //! Default right side, can be overridden to customise
+    render_2D_sheet(box_sheets(type))
+        box_right_blank(type);

printed/box_assembly.scad

@@ -18,7 +18,7 @@
 //
 
 //
-// The assembly is ```include```d so the panel definitions can be overridden to add holes and components.
+// The assembly is `include`d so the panel definitions can be overridden to add holes and components.
 // The _box_module also needs to be wrapped in the file that uses it so it can be called without
 // parameters to make the assembly views. E.g. module box_assembly() _box_assembly(box);
 //
@@ -28,7 +28,7 @@ assembly("box") {
 
     t = sheet_thickness(box_sheets(type));
 
-    for(corner = [0 :  corners - 1]) {
+    for(corner = [0 : 1 : corners - 1]) {
         x = [-1,1,1,-1][corner];
         y = [-1,-1,1,1][corner];
         translate([x * (box_width(type) / 2 + 25 * exploded()), y * (box_depth(type) / 2 + 25 * exploded())])

printed/butt_box.scad

@@ -21,7 +21,7 @@
 //! A box made from CNC cut panels butted together using printed fixing blocks. Useful for making large
 //! boxes with minimal 3D printing.  More blocks are added as the box gets bigger.
 //!
-//! Needs to be ```include```d rather than ```use```d to allow the panel definitions to be overridden to add holes
+//! Needs to be `include`d rather than `use`d to allow the panel definitions to be overridden to add holes
 //! and mounted components.
 //!
 //! A list specifies the internal dimensions, screw type, top, bottom and side sheet types and the block
@@ -50,8 +50,11 @@ function bbox_name(type)       = type[8] ? type[8] : "bbox"; //! Optional name i
 function bbox_skip_blocks(type)= type[9] ? type[9] : [];  //! List of fixing blocks to skip, used to allow a hinged panel for example
 function star_washers(type)    = type[10] ? type[10] : is_undef(type[10]); //! Set to false to remove star washers.
 
+function bbox(screw, sheets, base_sheet, top_sheet, span, size, name = "bbox", skip_blocks = [], star_washers = true) = //! Construct the property list for a butt_box
+ [ screw, sheets, base_sheet, top_sheet, span, size.x, size.y, size.z, name, skip_blocks, star_washers ];
+
 function bbox_volume(type) = bbox_width(type) * bbox_depth(type) * bbox_height(type) / 1000000; //! Internal volume in litres
-function bbox_area(type) = let(w =  bbox_width(type), d = bbox_depth(type), h = bbox_height(type)) //! Internal surdface area in m^2
+function bbox_area(type) = let(w =  bbox_width(type), d = bbox_depth(type), h = bbox_height(type)) //! Internal surface area in m^2
     2 * (w * d + w * h + d * h) / 1000000;
 
 module bbox_shelf_blank(type) { //! 2D template for a shelf
@@ -107,12 +110,9 @@ function fixing_block_positions(type) = let(
 
 function side_holes(type) = [for(p = fixing_block_positions(type), q = fixing_block_holes(bbox_screw(type))) p * q];
 
-module drill_holes(type, t)
-    for(list = [corner_holes(type), side_holes(type)], p = list)
-        let(q = t * p)
-            if(abs(transform([0, 0, 0], q).z) < eps)
-                multmatrix(q)
-                    drill(screw_clearance_radius(bbox_screw(type)), 0);
+module bbox_drill_holes(type, t)
+    position_children(concat(corner_holes(type), side_holes(type)), t)
+        drill(screw_clearance_radius(bbox_screw(type)), 0);
 
 module bbox_base_blank(type) { //! 2D template for the base
     dxf(str(bbox_name(type), "_base"));
@@ -120,7 +120,7 @@ module bbox_base_blank(type) { //! 2D template for the base
     difference() {
         sheet_2D(bbox_base_sheet(type), bbox_width(type), bbox_depth(type), 1);
 
-        drill_holes(type, translate(bbox_height(type) / 2));
+        bbox_drill_holes(type, translate(bbox_height(type) / 2));
     }
 }
 
@@ -133,7 +133,7 @@ module bbox_top_blank(type) { //! 2D template for the top
         translate([0, t / 2])
             sheet_2D(bbox_top_sheet(type), bbox_width(type) + 2 * t, bbox_depth(type) + t);
 
-        drill_holes(type, translate(-bbox_height(type) / 2));
+        bbox_drill_holes(type, translate(-bbox_height(type) / 2));
     }
 }
 
@@ -151,7 +151,7 @@ module bbox_left_blank(type, sheet = false) { //! 2D template for the left side
         translate([-t / 2, -bb / 2])
             sheet_2D(subst_sheet(type, sheet), bbox_depth(type) + t, bbox_height(type) + bb);
 
-        drill_holes(type, rotate([0, 90, 90]) * translate([bbox_width(type) / 2, 0]));
+        bbox_drill_holes(type, rotate([0, 90, 90]) * translate([bbox_width(type) / 2, 0]));
     }
 }
 
@@ -165,7 +165,7 @@ module bbox_right_blank(type, sheet = false) { //! 2D template for the right sid
         translate([t / 2, -bb / 2])
             sheet_2D(subst_sheet(type, sheet), bbox_depth(type) + t, bbox_height(type) + bb);
 
-        drill_holes(type, rotate([0, 90, 90]) * translate([-bbox_width(type) / 2, 0]));
+        bbox_drill_holes(type, rotate([0, 90, 90]) * translate([-bbox_width(type) / 2, 0]));
     }
 }
 
@@ -180,7 +180,7 @@ module bbox_front_blank(type, sheet = false, width = 0) { //! 2D template for th
         translate([0, (bt - bb) / 2])
             sheet_2D(subst_sheet(type, sheet), max(bbox_width(type) + 2 * t, width), bbox_height(type) + bb + bt);
 
-        drill_holes(type, rotate([-90, 0, 0]) * translate([0, bbox_depth(type) / 2]));
+        bbox_drill_holes(type, rotate([-90, 0, 0]) * translate([0, bbox_depth(type) / 2]));
     }
 }
 
@@ -194,16 +194,33 @@ module bbox_back_blank(type, sheet = false) { //! 2D template for the back
         translate([0, -bb / 2])
             sheet_2D(subst_sheet(type, sheet), bbox_width(type), bbox_height(type) + bb);
 
-        drill_holes(type, rotate([-90, 0, 0]) * translate([0, -bbox_depth(type) / 2]));
+        bbox_drill_holes(type, rotate([-90, 0, 0]) * translate([0, -bbox_depth(type) / 2]));
     }
 }
 
-module bbox_base(type)  render_2D_sheet(bbox_base_sheet(type)) bbox_base_blank(type);   //! Default base, can be overridden to customise
-module bbox_top(type)   render_2D_sheet(bbox_top_sheet(type)) bbox_top_blank(type);     //! Default top, can be overridden to customise
-module bbox_back(type)  render_2D_sheet(bbox_sheets(type)) bbox_back_blank(type);       //! Default back, can be overridden to customise
-module bbox_front(type) render_2D_sheet(bbox_sheets(type)) bbox_front_blank(type);      //! Default front, can be overridden to customise
-module bbox_left(type)  render_2D_sheet(bbox_sheets(type)) bbox_left_blank(type);       //! Default left side, can be overridden to customise
-module bbox_right(type) render_2D_sheet(bbox_sheets(type)) bbox_right_blank(type);      //! Default right side, can be overridden to customise
+module bbox_base(type)  //! Default base, can be overridden to customise
+    render_2D_sheet(bbox_base_sheet(type))
+        bbox_base_blank(type);
+
+module bbox_top(type)   //! Default top, can be overridden to customise
+    render_2D_sheet(bbox_top_sheet(type))
+        bbox_top_blank(type);
+
+module bbox_back(type)  //! Default back, can be overridden to customise
+    render_2D_sheet(bbox_sheets(type))
+        bbox_back_blank(type);
+
+module bbox_front(type) //! Default front, can be overridden to customise
+    render_2D_sheet(bbox_sheets(type))
+        bbox_front_blank(type);
+
+module bbox_left(type)  //! Default left side, can be overridden to customise
+    render_2D_sheet(bbox_sheets(type))
+        bbox_left_blank(type);
+
+module bbox_right(type) //! Default right side, can be overridden to customise
+    render_2D_sheet(bbox_sheets(type))
+        bbox_right_blank(type);
 
 module _bbox_assembly(type, top = true, base = true, left = true, right = true, back = true, front = true) { //! The box assembly, wrap with a local copy without parameters
     width = bbox_width(type);

printed/cable_grommets.scad

@@ -49,84 +49,84 @@ module ribbon_grommet_hole(ways, h = 50, expand = true) { //! Generate a hole fo
 }
 
 module ribbon_grommet(ways, thickness) { //! Generate the STL for a printed ribbon grommet
-    stl(str("ribbon_grommet_", ways, "_", thickness));
 
     width = 2 * (wall + clearance) + thickness;
     slot_length = ribbon_clamp_slot(ways);
     length = slot_length + 2 * wall + 2 * overlap;
 
-    rotate([90, 0, 0])
-        union() {
-            for(side = [-1, 1])
-                translate_z(side * (width - wall) / 2)
-                    linear_extrude(wall, center = true, convexity = 5)
-                        difference() {
-                            hull() {
-                                translate([-length / 2, 0])
-                                    square([length, base]);
+    stl(str("ribbon_grommet_", ways, "_", thickness))
+        rotate([90, 0, 0])
+            union() {
+                for(side = [-1, 1])
+                    translate_z(side * (width - wall) / 2)
+                        linear_extrude(wall, center = true, convexity = 5)
+                            difference() {
+                                hull() {
+                                    translate([-length / 2, 0])
+                                        square([length, base]);
 
-                                for(end = [-1, 1])
-                                    translate([end * (length / 2 - rad), height - rad])
-                                        semi_circle(rad);
+                                    for(end = [-1, 1])
+                                        translate([end * (length / 2 - rad), height - rad])
+                                            semi_circle(rad);
+                                }
+                                translate([-slot_length / 2, base])
+                                    square([slot_length, slot_height]);
                             }
-                            translate([-slot_length / 2, base])
-                                square([slot_length, slot_height]);
-                        }
 
-            linear_extrude(width -1, center = true)
-                difference() {
-                    ribbon_grommet_hole(ways, expand = false, h = 0);
+                linear_extrude(width -1, center = true)
+                    difference() {
+                        ribbon_grommet_hole(ways, expand = false, h = 0);
 
-                    translate([-slot_length / 2, base])
-                        square([slot_length, slot_height]);
-                }
-        }
+                        translate([-slot_length / 2, base])
+                            square([slot_length, slot_height]);
+                    }
+            }
 }
 
 module round_grommet_top(diameter, thickness, od = undef) { //! Generate the STL for a round grommet top half
-    stl(str("round_grommet_top_", round(diameter * 10), "_", thickness));
     chamfer = layer_height;
     h = wall + thickness + wall;
     r1 = diameter / 2;
     r2 = od == undef ? corrected_radius(r1) + wall : od / 2;
     r3 = r2 + overlap;
     r0 = r1 + 1;
-    union() {
-        rotate_extrude()
-            polygon([
-                [r0, 0],
-                [r3 - chamfer, 0],
-                [r3, chamfer],
-                [r3, wall],
-                [r2, wall],
-                [r2, h - chamfer],
-                [r2 - chamfer, h],
-                [r0, h],
-            ]);
+    stl(str("round_grommet_top_", round(diameter * 10), "_", thickness))
+        union() {
+            rotate_extrude()
+                polygon([
+                    [r0, 0],
+                    [r3 - chamfer, 0],
+                    [r3, chamfer],
+                    [r3, wall],
+                    [r2, wall],
+                    [r2, h - chamfer],
+                    [r2 - chamfer, h],
+                    [r0, h],
+                ]);
 
-        render() difference() {
-            cylinder(r = r0 + eps, h = h);
+            render() difference() {
+                cylinder(r = r0 + eps, h = h);
 
-            poly_cylinder(r = r1, h = 100, center = true);
+                poly_cylinder(r = r1, h = 100, center = true);
+            }
         }
-    }
 }
 
 module round_grommet_bottom(diameter, od = undef) { //! Generate the STL for a round grommet bottom half
-    stl(str("round_grommet_bottom_", round(diameter * 10)));
     chamfer = layer_height;
     r1 = diameter / 2;
     r2 = od == undef ? corrected_radius(r1) + wall : od / 2;
     r3 = r2 + max(overlap, wall + chamfer);
-    rotate_extrude()
-        polygon([
-            [r2, chamfer],
-            [r2 + chamfer, 0],
-            [r3, 0],
-            [r3, wall - chamfer],
-            [r3 - chamfer, wall],
-            [r2, wall],
-        ]);
+    stl(str("round_grommet_bottom_", round(diameter * 10)))
+        rotate_extrude()
+            polygon([
+                [r2, chamfer],
+                [r2 + chamfer, 0],
+                [r3, 0],
+                [r3, wall - chamfer],
+                [r3 - chamfer, wall],
+                [r2, wall],
+            ]);
 }
 
 module round_grommet_hole(diameter, h = 100) //! Make a hole for a round grommet
@@ -161,30 +161,30 @@ module mouse_grommet_hole(r, h = 50, z = undef, expand = wall + clearance) //! M
 function mouse_grommet_offset(r) = r + wall;
 
 module mouse_grommet(r, thickness) { //! Make the STL for a mouse grommet
-    stl(str("mouse_grommet_", r * 10, "_", thickness));
 
     width = 2 * (wall + clearance) + thickness;
     length = 2 * r + 2 * wall + 2 * overlap;
 
-    rotate([90, 0, 0])
-        union() {
-            for(side = [-1, 1])
-                translate_z(side * (width - wall) / 2)
-                    linear_extrude(wall, center = true)
-                        difference() {
-                            mouse_grommet_hole(r, z = r + wall, h = 0, expand = wall + overlap);
+    stl(str("mouse_grommet_", r * 10, "_", thickness))
+        rotate([90, 0, 0])
+            union() {
+                for(side = [-1, 1])
+                    translate_z(side * (width - wall) / 2)
+                        linear_extrude(wall, center = true)
+                            difference() {
+                                mouse_grommet_hole(r, z = r + wall, h = 0, expand = wall + overlap);
+
+                            translate([0, wall])
+                                mouse_grommet_hole(r, h = 0, expand = 0);
+                        }
+                linear_extrude(width - 1, center = true)
+                    difference() {
+                        mouse_grommet_hole(r, h = 0, z = r + wall, expand = wall);
 
                         translate([0, wall])
                             mouse_grommet_hole(r, h = 0, expand = 0);
                     }
-            linear_extrude(width - 1, center = true)
-                difference() {
-                    mouse_grommet_hole(r, h = 0, z = r + wall, expand = wall);
-
-                    translate([0, wall])
-                        mouse_grommet_hole(r, h = 0, expand = 0);
-                }
-        }
+            }
 }
 
 module mouse_grommet_assembly(r, thickness)

printed/camera_housing.scad

@@ -0,0 +1,392 @@
+//
+// 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/>.
+//
+
+//
+//! Housings for PCB cameras.
+//
+include <../core.scad>
+include <../vitamins/cameras.scad>
+use <../vitamins/pcb.scad>
+use <../vitamins/insert.scad>
+
+wall = 1.75;
+min_wall = 2 * extrusion_width;
+clearance = 0.2;
+
+connector_size = [23, 6, 2.65]; // Worst case size of flat flex connector
+
+cam_back_clearance = round_to_layer(1.5);    // Clearance for components on the back of the pcb
+cam_back_overlap = 1;                        // How much the back overlaps the edge of the pcb
+cam_back_wall = min_wall;
+
+function cam_front_clearance(cam) = round_to_layer(camera_connector_size(cam).z + clearance);
+
+function cam_back_size(cam) = let(
+    pcb = camera_pcb(cam),
+    pcb_size = pcb_size(pcb),
+    nut = screw_nut(pcb_screw(pcb)),
+    holes = [for(h = pcb_holes(pcb)) pcb_coord(pcb, h).x],
+    pitch = max(holes) - min(holes),
+    length = pitch + 2 * (nut_radius(nut) + min_wall),
+    width = pcb_size.y + (length - pcb_size.x) * cos(30)
+    ) [length, width, wall + max(connector_size.z, cam_back_clearance + nut_trap_depth(nut))];
+
+
+function cam_front_size(cam) = cam_back_size(cam) + [ //! Outside dimensions of the case
+    2 * (wall + clearance),
+    2 * (wall + clearance),
+    pcb_thickness(camera_pcb(cam)) + cam_front_clearance(cam) + wall
+];
+
+hinge_screw = M2_cap_screw;
+hinge_nut = screw_nut(hinge_screw);
+hinge_screw_length = 12;
+
+hinge_r = nut_trap_radius(hinge_nut) + 3 * extrusion_width;
+hinge_h = wall + nut_trap_depth(hinge_nut);
+hinge_offset = hinge_r + 1;
+
+bracket_screw = M3_dome_screw;
+
+function cam_screw_length(cam) = let(
+    front = cam_front_size(cam),
+    screw = pcb_screw(camera_pcb(cam)),
+    nut = screw_nut(screw)
+    ) screw_length(screw, front.z - nut_trap_depth(nut), 1, nyloc = true);
+
+function hinge_z(cam) = cam_screw_length(cam) - hinge_r;
+
+module cam_holes(cam) {
+    pcb = camera_pcb(cam);
+    lens_y = camera_lens_offset(cam).y;
+    two_holes = !!len([for (h = pcb_holes(pcb)) if(abs(pcb_coord(pcb, h).y - lens_y) < 1) true]);
+    pcb_screw_positions(pcb)                                                    // screw holes
+        if($i > 1 || !two_holes)
+            children();
+}
+
+module rpi_camera_focus_ring_stl() { //! Focus ring the glue onto RPI lens
+
+    rad = 15 / 2;
+    hole_r1 = 2.5 / 2;
+    hole_r2 = 5 / 2;
+    thickness = 3;
+    flutes = 8;
+    angle = 180 / flutes;
+    x = rad / (sin(angle / 2) + cos(angle / 2));
+    r = x * sin(angle / 2);
+
+    stl("rpi_camera_focus_ring")
+        difference() {
+            linear_extrude(height = thickness, convexity = 5)
+                difference() {
+                    union() {
+                        circle(x);
+                        for(i = [0 : flutes - 1])
+                            rotate([0, 0, 2 * angle * i])
+                                translate([x, 0])
+                                    circle(r);
+                    }
+                    for(i = [0 : flutes - 1])
+                        rotate([0, 0, 2 * angle * i + angle])
+                            translate([x, 0])
+                                circle(r);
+                }
+            hull() {
+                poly_cylinder(r = hole_r1, h = 0.1, center = true);
+
+                translate([0, 0, thickness])
+                    poly_cylinder(r = hole_r2, h = 0.1, center = true);
+            }
+        }
+}
+
+module camera_back(cam) { //! Make the STL for a camera case back
+    pcb = camera_pcb(cam);
+    back = cam_back_size(cam);
+    screw = pcb_screw(pcb);
+    nut = screw_nut(screw);
+
+    stl(str("camera_back_", cam[0]))
+        translate_z(back.z)
+            hflip()
+                difference() {
+                    translate_z(back.z / 2)
+                        cube(back, center = true);
+
+                    translate([0, -cam_back_overlap])
+                        cube([pcb_length(pcb) - 2 * cam_back_overlap, pcb_width(pcb), 2 * cam_back_clearance], center = true);
+
+                    translate([0, -pcb_width(pcb) / 2])
+                        cube([connector_size.x + 2 * clearance, 2 * connector_size.y + 1, 2 * round_to_layer(connector_size.z + clearance)], center = true);
+
+                    translate_z(back.z)
+                        cam_holes(cam)
+                            hflip()
+                                nut_trap(screw, nut, supported = true);
+                }
+}
+
+module camera_front(cam, hinge = 0) { //! Make the STL for a camera case front
+    front = cam_front_size(cam);
+    back = cam_back_size(cam);
+    pcb = camera_pcb(cam);
+    pcb_size = pcb_size(pcb);
+    lens_offset = camera_lens_offset(cam);
+    screw = pcb_screw(pcb);
+
+    shelf = front.z - back.z;
+
+    connector_slot = connector_size + 2 * [clearance, 0, layer_height];
+    rad = wall;
+    led_hole_r = 1;
+    led_clearance = [5,   2, 1 * 2];
+    res_clearance = [3.5, 2, 1 * 2];
+
+    conn_pos = camera_connector_pos(cam);
+    conn = camera_connector_size(cam);
+    sensor_length = conn_pos.y + conn.y / 2 - lens_offset.y + clearance;
+
+    module hinge_pos()
+        if(!is_undef(hinge))
+            rotate(hinge * 90)
+                translate([0, (hinge ? front.x * hinge : front.y) / 2 + hinge_offset, hinge_r])
+                    children();
+
+    stl(str("camera_front_", cam[0]))
+        difference() {
+            union() {
+                hull()
+                    for(x = [-1, 1], y = [-1, 1])
+                        translate([x * (front.x / 2 - rad), y * (front.y / 2 - rad)])
+                            hull() {    // 3D truncated teardrop gives radiused edges without exceeding 45 degree overhang
+                                translate_z(front.z - 1)
+                                    cylinder(r = rad, h = 1);
+
+                                translate_z(rad)
+                                    sphere(rad);
+
+                                cylinder(r = rad * (sqrt(2) - 1), h = eps);
+                            }
+
+                hinge_pos()
+                    hull() {
+                        rotate([-90, 0, -90])
+                            teardrop(r = hinge_r, h = hinge_h, center = false);
+
+                        translate([0, -10, -hinge_r])
+                            cube([hinge_h, eps, 2 * hinge_r]);
+                    }
+            }
+
+            hinge_pos()
+                rotate([90, 0, 90])
+                    teardrop_plus(r = screw_clearance_radius(hinge_screw), h = 100, center = true);
+
+            translate_z(front.z / 2 + shelf - layer_height)                                 // recess for the back
+                cube([back.x + 2 * clearance, back.y + 2 * clearance, front.z], center = true);
+
+            translate_z(front.z / 2 + shelf - pcb_size.z)                                   // recess for PCB
+                cube([pcb_size.x + 2 * clearance, pcb_size.y + 2 * clearance, front.z], center = true);
+
+            translate_z(shelf)
+                hflip() {
+                    pcb_component_position(pcb, "smd_led")                                  // clearance for LED
+                        cube(led_clearance, center = true);
+
+                    pcb_component_position(pcb, "smd_res")                                  // clearance for resistor
+                        cube(res_clearance, center = true);
+                }
+
+            translate([conn_pos.x, lens_offset.y + sensor_length / 2, shelf - pcb_size.z])  // clearance for sensor connector
+                cube([conn.x + 2 * clearance, sensor_length, 2 * cam_front_clearance(cam)], center = true);
+
+            translate([0, -front.y / 2, shelf + front.z / 2])                               // slot for connector
+                cube([connector_slot.x, connector_slot.y, front.z], center = true);
+
+            translate_z(cam_back_clearance + layer_height)
+                cam_holes(cam)
+                    rotate(90)
+                        poly_cylinder(r = screw_clearance_radius(screw), h = 100, center = true);
+
+            translate_z(shelf - pcb_size.z)
+                hflip()
+                    camera_lens(cam, clearance);
+
+            hflip()
+                pcb_component_position(pcb, "smd_led")
+                    rotate(45)
+                        poly_cylinder(r = led_hole_r, h = 100, center = true);              // hole for led
+        }
+}
+
+function bracket_thickness(cam) = max(wall, min(3.5, hinge_z(cam) - hinge_r - 1));
+
+module camera_bracket_screw_positions(cam) { //! Position children at the bracket screw positions
+    r = washer_radius(screw_washer(bracket_screw)) + 0.5;
+    wide = bracket_thickness(cam) == wall;
+    pitch = wide ? cam_front_size(cam).x / 2 - r : hinge_h + 1 + r;
+
+    for(side = [-1, 1])
+        translate([side * pitch, 0])
+            children();
+}
+
+module camera_bracket_position(cam) //! Position children at the bracket position
+    translate([0,  cam_front_size(cam).y / 2 + hinge_offset])
+        children();
+
+module camera_bracket(cam) { //! Make the STL for the camera bracket
+    t = bracket_thickness(cam);
+    z = hinge_z(cam);
+
+    stl(str("camera_bracket_", cam[0])) union() {
+        translate([hinge_h / 2, 0])
+            difference() {
+                hull() {
+                    translate_z(eps / 2)
+                        cube([hinge_h, 2 * hinge_r, eps], center = true);
+
+                    translate_z(z)
+                        rotate([0, 90, 0])
+                            cylinder(r = hinge_r, h = hinge_h, center = true);
+                }
+                translate([hinge_h / 2, 0, z])
+                    rotate([90, 0, 90])
+                        nut_trap(hinge_screw, screw_nut(hinge_screw), horizontal = true);
+            }
+
+        linear_extrude(t)
+            difference() {
+                hull()
+                    camera_bracket_screw_positions(cam)
+                        circle(washer_radius(screw_washer(bracket_screw)) + 0.5);
+
+                camera_bracket_screw_positions(cam)
+                    poly_circle(screw_clearance_radius(bracket_screw));
+            }
+    }
+}
+
+module camera_assembly(cam, angle = 0) //! Camera case assembly
+assembly(str("camera_", cam[0]), ngb = true) {
+    front = cam_front_size(cam);
+    screw = pcb_screw(camera_pcb(cam));
+    nut = screw_nut(screw);
+    screw_length = cam_screw_length(cam);
+    hinge_z = hinge_z(cam);
+    hinge_pos = [0, front.y / 2  + hinge_offset, -hinge_r];
+
+    camera_bracket_position(cam) {
+        nut = screw_nut(hinge_screw);
+
+        stl_colour(pp1_colour) render()
+            camera_bracket(cam);
+
+        translate([-hinge_h, 0, hinge_z(cam)])
+            rotate([-90, 0, 90]) {
+                vflip()
+                    translate_z(2 * hinge_h - nut_trap_depth(nut))
+                        nut(nut, true);
+
+                screw_and_washer(hinge_screw, screw_longer_than(2 * hinge_h));
+            }
+    }
+
+    translate_z(hinge_z(cam) + hinge_r)
+        translate(hinge_pos)
+            rotate([-angle, 0, 0])
+                translate(-hinge_pos) {
+                    translate_z(cam_back_size(cam).z - front.z)
+                        camera(cam);
+
+                    stl_colour(pp1_colour) render()
+                        translate_z(-front.z)
+                            camera_back(cam);
+
+                    cam_holes(cam) {
+                        screw_and_washer(screw, screw_length);
+
+                        translate_z(-front.z + nut_trap_depth(nut))
+                            vflip()
+                                nut(nut, true);
+                    }
+
+                    *translate(camera_lens_offset(cam))
+                        translate_z(1.5)
+                            stl_colour(pp1_colour) render()
+                                rpi_camera_focus_ring_stl();
+
+                    stl_colour(pp2_colour) render()
+                        hflip()
+                            camera_front(cam, 0);
+                }
+}
+
+module camera_fastened_assembly(cam, thickness, angle = 0) {
+    camera_assembly(cam, angle);
+
+    camera_bracket_position(cam)
+        camera_bracket_screw_positions(cam) {
+            nut = screw_nut(bracket_screw);
+            t = bracket_thickness(cam);
+            screw_length = screw_length(bracket_screw, thickness + t, 2, nyloc = true);
+            vflip()
+                translate_z(thickness)
+                    screw_and_washer(bracket_screw, screw_length);
+
+            translate_z(t)
+                nut_and_washer(nut, true);
+        }
+}
+
+module camera_back_rpi_camera_stl()    camera_back(rpi_camera);
+module camera_back_rpi_camera_v1_stl() camera_back(rpi_camera_v1);
+module camera_back_rpi_camera_v2_stl() camera_back(rpi_camera_v2);
+
+module camera_front_rpi_camera_stl()    camera_front(rpi_camera);
+module camera_front_rpi_camera_v1_stl() camera_front(rpi_camera_v1);
+module camera_front_rpi_camera_v2_stl() camera_front(rpi_camera_v2);
+
+module camera_bracket_rpi_camera_stl()    camera_bracket(rpi_camera);
+module camera_bracket_rpi_camera_v1_stl() camera_bracket(rpi_camera_v1);
+module camera_bracket_rpi_camera_v2_stl() camera_bracket(rpi_camera_v2);
+
+module camera_rpi_camera_assembly()    camera_assembly(rpi_camera);
+module camera_rpi_camera_v1_assembly() camera_assembly(rpi_camera_v1);
+module camera_rpi_camera_v2_assembly() camera_assembly(rpi_camera_v2);
+
+module camera_housing(cam) {
+    front = cam_front_size(cam);
+
+    camera_front(cam, 0);
+
+    translate([front.x, 0])
+        camera_back(cam);
+
+    translate([-front.x / 2 - 2 - hinge_r, 0])
+        rotate(90)
+            camera_bracket(cam);
+}
+
+cam = rpi_camera_v2;
+if($preview)
+    camera_fastened_assembly(cam, 3);
+else
+    camera_housing(cam);

printed/carriers.scad

@@ -27,7 +27,6 @@ include <../utils/core/core.scad>
 function carrier_height() = 3; //! Height of PCB carrier
 
 module ESP12F_carrier_stl() { //! Generate the STL for an ESP12 carrier
-    stl("ESP12F_carrier");
     pins = 8;
     pitch1 = 2;
     pitch2 = 2.54;
@@ -43,29 +42,29 @@ module ESP12F_carrier_stl() { //! Generate the STL for an ESP12 carrier
     width1 = wpitch1 + hole + squeezed_wall * 2;
     width2 = wpitch2 + hole2 + squeezed_wall * 2;
 
-    difference() {
-        hull() {
-            translate_z(height - eps / 2)
-                cube([width1, length1, eps], center = true);
+    stl("ESP12F_carrier")
+        difference() {
+            hull() {
+                translate_z(height - eps / 2)
+                    cube([width1, length1, eps], center = true);
 
-            translate_z(eps / 2)
-                cube([width2, length2, eps], center = true);
+                translate_z(eps / 2)
+                    cube([width2, length2, eps], center = true);
+            }
+
+            for(side = [-1, 1])
+                for(i = [0 : pins - 1])
+                    hull() {
+                        translate([side * wpitch1 / 2, i * pitch1 - (pins - 1) * pitch1 / 2, height])
+                            cube([hole, hole, eps], center = true);
+
+                        translate([side * wpitch2 / 2, i * pitch2 - (pins - 1) * pitch2 / 2])
+                            cube([hole2, hole2, eps], center = true);
+                    }
         }
-
-        for(side = [-1, 1])
-            for(i = [0 : pins - 1])
-                hull() {
-                    translate([side * wpitch1 / 2, i * pitch1 - (pins - 1) * pitch1 / 2, height])
-                        cube([hole, hole, eps], center = true);
-
-                    translate([side * wpitch2 / 2, i * pitch2 - (pins - 1) * pitch2 / 2])
-                        cube([hole2, hole2, eps], center = true);
-                }
-    }
 }
 
 module TP4056_carrier_stl() { //! Generate the STL for an TP4056 carrier, two required
-    stl("TP4056_carrier");
     pitch = 2.54;
     outer_pitch = 13.9;
     inner_pitch = 7.54;
@@ -78,30 +77,30 @@ module TP4056_carrier_stl() { //! Generate the STL for an TP4056 carrier, two re
     width = hole + squeezed_wall * 2;
     spacing = inch(0.9);
 
-    difference() {
-        hull() {
-            translate_z(height - eps / 2)
-                cube([width, length1, eps], center = true);
+    stl("TP4056_carrier")
+        difference() {
+            hull() {
+                translate_z(height - eps / 2)
+                    cube([width, length1, eps], center = true);
 
-            translate_z(eps / 2)
-                cube([width, length2, eps], center = true);
+                translate_z(eps / 2)
+                    cube([width, length2, eps], center = true);
+            }
+
+            for(i = [0 : pins - 1])
+                let(x = [-outer_pitch / 2, - inner_pitch / 2, 0, 0, inner_pitch / 2, outer_pitch / 2][i])
+                    if(x)
+                        hull() {
+                            translate([0, x, height])
+                                cube([hole, hole, eps], center = true);
+
+                            translate([0, i * pitch - (pins - 1) * pitch / 2])
+                                cube([hole, hole, eps], center = true);
+                        }
         }
-
-        for(i = [0 : pins - 1])
-            let(x = [-outer_pitch / 2, - inner_pitch / 2, 0, 0, inner_pitch / 2, outer_pitch / 2][i])
-                if(x)
-                    hull() {
-                        translate([0, x, height])
-                            cube([hole, hole, eps], center = true);
-
-                        translate([0, i * pitch - (pins - 1) * pitch / 2])
-                            cube([hole, hole, eps], center = true);
-                    }
-    }
 }
 
 module MT3608_carrier_stl() { //! Generate the STL for an MT3608 carrier, two required
-    stl("MT3608_carrier");
     pcb_width = 17;
     w_pitch_top = 6.81;
     w_pitch_bot = inch(0.3);
@@ -113,21 +112,22 @@ module MT3608_carrier_stl() { //! Generate the STL for an MT3608 carrier, two re
     width = hole + 2 * wall;
     offset = (l_pitch_top - l_pitch_bot) / 2;
 
-    difference() {
-        hull() {
-            translate([offset, 0, height - eps / 2])
-                rounded_rectangle([width, pcb_width - 2, eps], 1);
-
-            translate_z(eps / 2)
-                rounded_rectangle([width, pcb_width - 2, eps], 1);
-        }
-        for(side = [-1, 1])
+    stl("MT3608_carrier")
+        difference() {
             hull() {
-                translate([offset, side * w_pitch_top / 2, height])
-                    cube([hole, hole, eps], center = true);
+                translate([offset, 0, height - eps / 2])
+                    rounded_rectangle([width, pcb_width - 2, eps], 1, true);
 
-                translate([0, side * w_pitch_bot / 2])
-                    cube([hole, hole, eps], center = true);
+                translate_z(eps / 2)
+                    rounded_rectangle([width, pcb_width - 2, eps], 1, true);
             }
-    }
+            for(side = [-1, 1])
+                hull() {
+                    translate([offset, side * w_pitch_top / 2, height])
+                        cube([hole, hole, eps], center = true);
+
+                    translate([0, side * w_pitch_bot / 2])
+                        cube([hole, hole, eps], center = true);
+                }
+        }
 }

printed/corner_block.scad

@@ -25,10 +25,10 @@
 //!
 //! Note that the block with its inserts is defined as a sub assembly, but its fasteners get added to the parent assembly.
 //!
-//! Specific fasteners can be omitted by setting a side's thickness to 0 and the block omitted by setting ```show_block``` to false.
+//! Specific fasteners can be omitted by setting a side's thickness to 0 and the block omitted by setting `show_block` to false.
 //! This allows the block and one set of fasteners to be on one assembly and the other fasteners on the mating assemblies.
 //!
-//! Star washers can be omitted by setting ```star_washers``` to false.
+//! Star washers can be omitted by setting `star_washers` to false.
 //
 include <../core.scad>
 use <../vitamins/insert.scad>
@@ -72,8 +72,6 @@ module corner_block_holes(screw = def_screw) //! Place children at all the holes
             children();
 
 module corner_block(screw = def_screw, name = false) { //! Generate the STL for a printed corner block
-    stl(name ? name : str("corner_block", "_M", screw_radius(screw) * 20));
-
     r = 1;
     cb_width = corner_block_width(screw);
     cb_height = cb_width;
@@ -81,43 +79,45 @@ module corner_block(screw = def_screw, name = false) { //! Generate the STL for
     insert = screw_insert(screw);
     corner_rad = insert_outer_d(insert) / 2 + wall;
     offset = corner_block_hole_offset(screw);
-    difference() {
-        hull()  {
-            translate([r, r])
-                rounded_cylinder(r = r, h = cb_height, r2 = r);
 
-            translate([r, cb_depth - r])
-                cylinder(r = r, h = cb_height - corner_rad);
+    stl(name ? name : str("corner_block", "_M", screw_radius(screw) * 20))
+        difference() {
+            hull()  {
+                translate([r, r])
+                    rounded_cylinder(r = r, h = cb_height, r2 = r);
 
-            translate([cb_width - r, r])
-                cylinder(r = r, h = cb_height - corner_rad);
+                translate([r, cb_depth - r])
+                    cylinder(r = r, h = cb_height - corner_rad);
 
-            translate([offset, offset, offset])
-                sphere(corner_rad);
+                translate([cb_width - r, r])
+                    cylinder(r = r, h = cb_height - corner_rad);
 
-            translate([offset, offset])
-                cylinder(r = corner_rad, h = offset);
+                translate([offset, offset, offset])
+                    sphere(corner_rad);
 
-            translate([offset, r, offset])
-                rotate([-90, 0, 180])
-                    rounded_cylinder(r = corner_rad, h = r, r2 = r);
+                translate([offset, offset])
+                    cylinder(r = corner_rad, h = offset);
 
-            translate([r, offset, offset])
-                rotate([0, 90, 180])
-                    rounded_cylinder(r = corner_rad, h = r, r2 = r);
+                translate([offset, r, offset])
+                    rotate([-90, 0, 180])
+                        rounded_cylinder(r = corner_rad, h = r, r2 = r);
+
+                translate([r, offset, offset])
+                    rotate([0, 90, 180])
+                        rounded_cylinder(r = corner_rad, h = r, r2 = r);
+            }
+            corner_block_v_hole(screw)
+                insert_hole(insert, overshoot);
+
+            corner_block_h_holes(screw)
+                insert_hole(insert, overshoot, true);
+
+            children();
         }
-        corner_block_v_hole(screw)
-            insert_hole(insert, overshoot);
-
-        corner_block_h_holes(screw)
-            insert_hole(insert, overshoot, true);
-
-        children();
-    }
 }
 
 module corner_block_assembly(screw = def_screw, name = false) //! The printed block with inserts
-assembly(str("corner_block_M", 20 * screw_radius(screw))) {
+assembly(str("corner_block_M", 20 * screw_radius(screw)), ngb = true) {
     insert = screw_insert(screw);
 
     stl_colour(name ? pp2_colour : pp1_colour)
@@ -133,12 +133,10 @@ assembly(str("corner_block_M", 20 * screw_radius(screw))) {
 module fastened_corner_block_assembly(thickness, screw = def_screw, thickness_below = undef, thickness_side2 = undef, name = false, show_block = true, star_washers = true) { //! Printed block with all fasteners
     thickness2 = !is_undef(thickness_below) ? thickness_below : thickness;
     thickness3 = !is_undef(thickness_side2) ? thickness_side2 : thickness;
-    washer = screw_washer(screw);
-    insert = screw_insert(screw);
-    function screw_length(t) = screw_shorter_than((star_washers ? 2 : 1) * washer_thickness(washer) + t + insert_length(insert) + overshoot);
-    screw_length = screw_length(thickness);
-    screw_length2 = screw_length(thickness2);
-    screw_length3 = screw_length(thickness3);
+    function screw_len(t) = screw_length(screw, t + overshoot, star_washers ? 2 : 1, true);
+    screw_length = screw_len(thickness);
+    screw_length2 = screw_len(thickness2);
+    screw_length3 = screw_len(thickness3);
 
     if(show_block)
         corner_block_assembly(screw, name) children();

printed/door_hinge.scad

@@ -45,7 +45,7 @@ function door_hinge_stat_screw() = stat_screw;              //! Screw use to fas
 function door_hinge_stat_width() = stat_width;              //! Width of the stationary part
 function door_hinge_stat_length() = stat_length;            //! Length of the stationary part
 
-module door_hinge_hole_positions(dir = 0) {                 //! Position chidren at the door hole positions
+module door_hinge_hole_positions(dir = 0) {                 //! Position children at the door hole positions
     hole_pitch = width - 10;
 
     for(side = [-1, 1])
@@ -54,44 +54,44 @@ module door_hinge_hole_positions(dir = 0) {                 //! Position chidren
 }
 
 module door_hinge(door_thickness) {                         //! Generates STL for the moving part of the hinge
-    stl(str("door_hinge_", door_thickness));
 
     hole_pitch = width - 10;
 
-    union() {
-        rotate([90, 0, 0])
-            linear_extrude(width, center = true)
+    stl(str("door_hinge_", door_thickness))
+        union() {
+            rotate([90, 0, 0])
+                linear_extrude(width, center = true)
+                    difference() {
+                        hull() {
+                            translate([dia / 2, thickness + door_thickness / 2])
+                                intersection() {
+                                    rotate(180)
+                                        teardrop(r = dia / 2, h = 0, truncate = false);
+
+                                    square([dia + 1, 2 * thickness + door_thickness], center = true);
+                                }
+
+                                square([1, thickness + door_thickness]);
+                        }
+                        translate([dia / 2, thickness + door_thickness / 2])
+                            teardrop_plus(r = screw_clearance_radius(pin_screw), h = 0);
+                    }
+            linear_extrude(thickness)
                 difference() {
                     hull() {
-                        translate([dia / 2, thickness + door_thickness / 2])
-                            intersection() {
-                                rotate(180)
-                                    teardrop(r = dia / 2, h = 0, truncate = false);
+                        translate([0, -width / 2])
+                            square([1, width]);
 
-                                square([dia + 1, 2 * thickness + door_thickness], center = true);
-                            }
-
-                            square([1, thickness + door_thickness]);
+                        for(side = [-1, 1])
+                            translate([-width + rad, side * (width / 2 - rad)])
+                                circle4n(rad);
                     }
-                    translate([dia / 2, thickness + door_thickness / 2])
-                        teardrop(r = screw_clearance_radius(pin_screw), h = 0);
+                    rotate(180)
+                        vflip()
+                            door_hinge_hole_positions()
+                                poly_circle(screw_clearance_radius(screw));
                 }
-        linear_extrude(thickness)
-            difference() {
-                hull() {
-                    translate([0, -width / 2])
-                        square([1, width]);
-
-                    for(side = [-1, 1])
-                        translate([-width + rad, side * (width / 2 - rad)])
-                            circle4n(rad);
-                }
-                rotate(180)
-                    vflip()
-                        door_hinge_hole_positions()
-                            poly_circle(screw_clearance_radius(screw));
-            }
-    }
+        }
 }
 
 module door_hinge_6_stl() door_hinge(6);
@@ -127,7 +127,7 @@ module door_hinge_stat_stl() { //! Generates the STL for the stationary part
                             square([dia, 1], center = true);
                     }
                     translate([0, dia / 2 + stat_clearance])
-                        teardrop(r = screw_clearance_radius(pin_screw), h = 0);
+                        teardrop_plus(r = screw_clearance_radius(pin_screw), h = 0);
                }
     }
 }
@@ -136,8 +136,7 @@ module door_hinge_assembly(top, door_thickness = 6) { //! The moving assembly th
     dir = top ? -1 : 1;
     pin_x = door_hinge_pin_x();
     pin_y = door_hinge_pin_y();
-    washer = screw_washer(screw);
-    screw_length = screw_shorter_than(thickness + door_thickness +  washer_thickness(washer));
+    screw_length = screw_length(screw, thickness + door_thickness, 1);
 
     translate([0, pin_y - (thickness + door_thickness / 2), dir * width / 2]) {
         rotate([90, 0, 180])
@@ -148,20 +147,20 @@ module door_hinge_assembly(top, door_thickness = 6) { //! The moving assembly th
                 screw_and_washer(screw, screw_length);
     }
 
-    translate([pin_x, pin_y, top ? 0 : -washer_thickness(screw_washer(pin_screw))])
-        washer(screw_washer(pin_screw));
+    washer = screw_washer(pin_screw);
+    wt = washer_thickness(washer);
+    translate([pin_x, pin_y, top ? 0 : -wt])
+        washer(washer);
 
-    translate([pin_x, pin_y, top ? washer_thickness(screw_washer(pin_screw)) + stat_width : width])
-        screw_and_washer(pin_screw, screw_longer_than(2 * washer_thickness(screw_washer(pin_screw)) + width + stat_width));
+    translate([pin_x, pin_y, top ? wt + stat_width : width])
+        screw_and_washer(pin_screw, screw_length(pin_screw, width + stat_width, 2, longer = true));
 }
 
 module door_hinge_static_assembly(top, sheet_thickness = 3) { //! The stationary assembly
     dir = top ? -1 : 1;
     pin_x = door_hinge_pin_x();
 
-    stat_washer = screw_washer(stat_screw);
-    stat_nut = screw_nut(stat_screw);
-    stat_screw_length = screw_longer_than(thickness + sheet_thickness + 2 * washer_thickness(stat_washer) + nut_thickness(stat_nut, true));
+    stat_screw_length = screw_length(stat_screw, thickness + sheet_thickness, 2, nyloc = true);
 
     translate([pin_x, 0, -dir * (stat_width / 2 + washer_thickness(screw_washer(pin_screw)))])
         rotate([90, 0, 0]) {
@@ -169,9 +168,10 @@ module door_hinge_static_assembly(top, sheet_thickness = 3) { //! The stationary
 
             door_hinge_stat_hole_positions() {
                 screw_and_washer(stat_screw, stat_screw_length);
+
                 translate_z(-thickness - sheet_thickness)
                     vflip()
-                        nut_and_washer(stat_nut, true);
+                        nut_and_washer(screw_nut(stat_screw), true);
             }
         }
 }

printed/door_latch.scad

@@ -38,30 +38,30 @@ function door_latch_offset() = width / 2 + 1; //! Offset of the axle from the do
 nut_trap_depth = round_to_layer(screw_head_height(screw)) + 4 * layer_height;
 
 module door_latch_stl() { //! Generates the STL for the printed part
-    stl("door_latch");
-
     ridge = 4;
-    difference() {
-        union() {
-            hull() {
-                rounded_rectangle([length, width, thickness - tan(30) * (width -  ridge) / 2], rad, center = false);
 
-                translate_z(thickness / 2)
-                    cube([length, ridge, thickness], center = true);
+    stl("door_latch")
+        difference() {
+            union() {
+                hull() {
+                    rounded_rectangle([length, width, thickness - tan(30) * (width -  ridge) / 2], rad);
+
+                    translate_z(thickness / 2)
+                        cube([length, ridge, thickness], center = true);
+                }
+
+                cylinder(d = width, h = height);
             }
-
-            cylinder(d = width, h = height);
+            hanging_hole(nut_trap_depth, screw_clearance_radius(screw))
+                circle(r = nut_trap_radius(screw_nut(screw)), $fn = 6);
         }
-        hanging_hole(nut_trap_depth, screw_clearance_radius(screw))
-            circle(r = nut_trap_radius(screw_nut(screw)), $fn = 6);
-    }
 }
 
-module door_latch_assembly(sheet_thickness = 3) { //! The assembly for a specified sheet thickess
+module door_latch_assembly(sheet_thickness = 3) { //! The assembly for a specified sheet thickness
     washer = screw_washer(screw);
     nut = screw_nut(screw);
 
-    screw_length = screw_longer_than(height - nut_trap_depth + sheet_thickness + 2 * washer_thickness(washer) + nut_thickness(nut, true));
+    screw_length = screw_length(screw, height - nut_trap_depth + sheet_thickness, 2, nyloc = true);
 
     translate([0, -height - washer_thickness(washer)])
         rotate([-90, 0, 0]) {

printed/drag_chain.scad

@@ -0,0 +1,349 @@
+//
+// 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/>.
+//
+
+//
+//! Parametric cable drag chain to limit the bend radius of a cable run.
+//!
+//! Each link has a maximum bend angle of 45&deg;, so the minimum radius is proportional to the link length.
+//!
+//! The travel property is how far it can move in each direction, i.e. half the maximum travel if the chain is mounted in the middle of the travel.
+//!
+//! The ends can have screw lugs with four screw positions to choose from, specified by a list of two arrays of four bools.
+//! If none are enabled then a child object is expected to customise the end and this gets unioned with the blank end.
+//! If both ends are customised then two children are expected.
+//! Each child is called twice, once with `$fasteners` set to 0 to augment the STL and again with `$fasteners` set to 1 to add
+//! to the assembly, for example to add inserts.
+//
+
+include <../core.scad>
+use <../utils/horiholes.scad>
+use <../utils/maths.scad>
+
+function drag_chain_name(type)        = type[0]; //! The name to allow more than one in a project
+function drag_chain_size(type)        = type[1]; //! The internal size and link length
+function drag_chain_travel(type)      = type[2]; //! X travel
+function drag_chain_wall(type)        = type[3]; //! Side wall thickness
+function drag_chain_bwall(type)       = type[4]; //! Bottom wall
+function drag_chain_twall(type)       = type[5]; //! Top wall
+function drag_chain_clearance(type)   = type[6]; //! Clearance around joints
+function drag_chain_supports(type)    = type[7]; //! Whether to print version of chain with or without supports
+function drag_chain_screw(type)       = type[8]; //! Mounting screw for the ends
+function drag_chain_screw_lists(type) = type[9]; //! Two lists of four bools to say which screws positions are used
+
+
+function drag_chain_radius(type) = //! The bend radius at the pivot centres
+    let(s = drag_chain_size(type))
+        s.x / 2 / sin(360 / 16);
+
+function drag_chain_z(type) = //! Outside dimension of a 180 bend
+    let(os = drag_chain_outer_size(type), s = drag_chain_size(type))
+        2 * drag_chain_radius(type) + os.z;
+
+function drag_chain(name, size, travel, wall = 1.6, bwall = 1.5, twall = 1.5, clearance = 0.1, supports = true, screw = M2_cap_screw, screw_lists = [[1,0,0,1],[1,0,0,1]]) = //! Constructor
+    [name, size, travel, wall, bwall, twall, clearance, supports, screw, screw_lists];
+
+function drag_chain_outer_size(type) = //! Link outer dimensions
+    let(s = drag_chain_size(type), z = s.z + drag_chain_bwall(type) + drag_chain_twall(type))
+        [s.x + z, s.y + 4 * drag_chain_wall(type) + 2 * drag_chain_clearance(type), z];
+
+function drag_chain_links(type) = //! Number of links in chain
+    ceil(drag_chain_travel(type) / drag_chain_size(type).x) + 4;
+
+function screw_lug_radius(screw) = //! Radius of a screw lug
+    corrected_radius(screw_clearance_radius(screw)) + 3.1 * extrusion_width;
+
+module screw_lug(screw, h = 0) //! Create a D shaped lug for a screw
+    extrude_if(h, center = false)
+        difference() {
+            r = screw_lug_radius(screw);
+            hull() {
+                circle4n(r);
+
+                translate([-r, -r])
+                    square([2 * r, eps]);
+            }
+            poly_circle(screw_clearance_radius(screw));
+        }
+
+function bool2int(b) = b ? 1 : 0;
+
+module drag_chain_screw_positions(type, end) { //! Place children at the screw positions, end = 0 for the start, 1 for the end
+    r = screw_lug_radius(drag_chain_screw(type));
+    s = drag_chain_size(type);
+    os = drag_chain_outer_size(type);
+    clearance = drag_chain_clearance(type);
+    R = os.z / 2;
+    x0 = end ? R + norm([drag_chain_cam_x(type), R - drag_chain_twall(type)]) + clearance + r : r;
+    x1 = end ? os.x - r : os.x - 2 * R - clearance - r;
+    for(i = [0 : 3], x = [x0, x1, x0, x1][i], y = [-1, -1, 1, 1][i])
+        if(drag_chain_screw_lists(type)[bool2int(end)][i])
+            translate([x, y * (s.y / 2 + r)])
+                let($a = [180, 0, 180, 0][i])
+                    children();
+}
+
+function drag_chain_cam_x(type) = // how far the cam sticks out
+    let(s = drag_chain_size(type),
+        r =  drag_chain_outer_size(type).z / 2,
+        wall =  drag_chain_wall(type),
+        cam_r = s.x - 2 * drag_chain_clearance(type) - wall - r,  // inner_x_normal - clearance - r
+        twall = drag_chain_twall(type)
+    )   min(sqrt(max(sqr(cam_r) - sqr(r - twall), 0)), r);
+
+module drag_chain_link(type, start = false, end = false, check_kids = true) { //! One link of the chain, special case for start and end
+    stl(str(drag_chain_name(type), "_drag_chain_link", start ? "_start" : end ? "_end" : ""));
+
+    s = drag_chain_size(type);
+    wall = drag_chain_wall(type);
+    bwall = drag_chain_bwall(type);
+    twall = drag_chain_twall(type);
+    os = drag_chain_outer_size(type);
+    clearance = drag_chain_clearance(type);
+    supports = drag_chain_supports(type);
+    r = os.z / 2;
+    // initial estimates of pin_r and pin_h
+    pin_r0 = r / 2 - 0.2;
+    pin_h0 = min(wall + clearance, 2 * pin_r0 - 1);
+     // for conical pin: ensure minimum radius of top of pin and pin does not overlap cutout
+    pin_r = supports ? r / 2 : min(r / 2 - 0.2, (os.z - 2 * twall - 3 * pin_h0 / 4 - 0.2) / 2);
+    pin_h = min(wall + clearance, 2 * pin_r - 1);
+
+    socket_x = r;
+    pin_x = socket_x + s.x;
+
+    outer_normal_x =  pin_x - r - clearance;     // s.x - clearance
+    outer_end_x = end ? os.x : outer_normal_x;
+
+    inner_x = start ? 0 : outer_normal_x - wall; // s.x - clearance - wall
+
+    roof_x_normal = 2 * r - twall;
+    cam_x = drag_chain_cam_x(type);
+    assert(r + norm([drag_chain_cam_x(type), r - drag_chain_twall(type)]) + clearance <= inner_x || start, "Link must be longer");
+
+    vflip(!supports)
+    difference() {
+        union() {
+            for(side = [-1, 1])
+                rotate([90, 0, 0]) {
+                    // Outer cheeks
+                    translate_z(side * (os.y / 2 - wall / 2))
+                        difference() {
+                            linear_extrude(wall, center = true)
+                                hull() {
+                                    if(start)
+                                        square([eps, os.z]);
+                                    else
+                                        translate([socket_x, r])
+                                            rotate(supports ? 180 : 0)
+                                                teardrop(r = r, h = 0);
+
+                                    translate([outer_end_x - eps, 0])
+                                        square([eps, os.z]);
+                                }
+                                if(!start)
+                                    if(supports)
+                                        translate([socket_x, r, 0])
+                                            horihole(pin_r, r, wall + 2*eps);
+                                    else
+                                        translate([socket_x, r, -side * (wall / 2 + clearance)])
+                                            rotate(180)
+                                                hull() {
+                                                    horihole(r = pin_r + pin_h / 2, z = r, h = eps);
+                                                    translate_z(side * pin_h)
+                                                        horihole(r = pin_r - pin_h / 2, z = r, h = eps);
+                                                }
+                            }
+                    // Inner cheeks
+                    translate_z(side * (s.y / 2 + wall / 2)) {
+                        linear_extrude(wall, center = true)
+                            difference() {
+                                union() {
+                                    hull() {
+                                        if(!end) {
+                                            translate([pin_x, r])
+                                                rotate(supports ? 180 : 0)
+                                                    teardrop(r = r, h = 0);
+
+                                            translate([pin_x, twall])
+                                                square([cam_x, eps]);
+                                        }
+                                        else
+                                            translate([os.x - eps, 0])
+                                                square([eps, os.z]);
+
+                                        translate([inner_x, 0])
+                                            square([eps, os.z]);
+                                    }
+                                }
+                                // Cutout for top wall
+                                if(!end)
+                                    intersection() {
+                                        translate([pin_x - r, 0])
+                                            square([3 * r, twall]);  // When straight
+
+                                        translate([pin_x, r])
+                                             rotate(-45)
+                                                translate([-r + roof_x_normal, -r - twall]) // When bent fully
+                                                    square(os.z);
+                                    }
+                            }
+                        // Pin
+                        if(!end)
+                            if(supports)
+                                translate([pin_x, r, side * (wall / 2 + clearance)])
+                                    horicylinder(r = pin_r, z = r, h = 2 * wall + eps);
+                            else
+                                translate([pin_x, r, side * wall / 2])
+                                    vflip(side == -1)
+                                        cylinder(r1 = pin_r + pin_h / 2, r2 = pin_r - pin_h / 2, h = pin_h + eps);
+                    }
+
+                    // Cheek joint
+                    translate([inner_x, 0, side * (s.y / 2 + wall) - 0.5])
+                        cube([outer_end_x - inner_x, os.z, 1]);
+                }
+
+            // Roof, actually the floor when printed with supports
+            roof_x = start ? 0 : roof_x_normal;
+            roof_end = end ? s.x + 2 * r : s.x + r - twall - clearance;
+            translate([roof_x, -s.y / 2 - wall, 0]) {
+                cube([roof_end - roof_x, s.y + 2 * wall, twall]);
+                translate([0, -wall, 0])
+                    cube([s.x - roof_x - clearance, s.y + 4 * wall, twall]);
+            }
+
+            // Floor, actually the roof when printed with supports
+            floor_x = start ? 0 : 2 * r;
+            floor_end = end ? s.x + 2 * r : s.x + r;
+            translate([floor_x, -s.y / 2 - wall, os.z - bwall]) {
+                cube([floor_end - floor_x, s.y + 2 * wall, bwall]);
+                translate([0, -wall, 0])
+                    cube([s.x - floor_x - clearance, s.y + 4 * wall, bwall]);
+            }
+
+            if(start || end) {
+                drag_chain_screw_positions(type, end)
+                    rotate($a)
+                        screw_lug(drag_chain_screw(type), os.z);
+
+                if(check_kids) {
+                    custom = drag_chain_screw_lists(type)[bool2int(end)] == [0, 0, 0, 0];
+                    assert($children == bool2int(custom), str("wrong number of children for ",  end ? "end" : "start", " STL customisation: ", $children));
+                }
+                children();
+            }
+        } // end union
+
+        if(start || end)
+            translate_z(-eps)
+                drag_chain_screw_positions(type, end)
+                    rotate($a)
+                        poly_cylinder(r = screw_clearance_radius(drag_chain_screw(type)), h = os.z + 2 * eps, center = false);
+    } // end difference
+
+    if(supports && show_supports() && !end) {
+        for(side = [-1, 1]) {
+            w = 2.1 * extrusion_width;
+            translate([s.x + r + cam_x - w / 2, side * (s.y / 2 + wall / 2), twall / 2])
+                cube([w, wall, twall], center = true);
+
+            h = round_to_layer(r - pin_r / sqrt(2));
+            y = s.y / 2  + max(wall + w / 2 + clearance, 2 * wall + clearance - w / 2);
+            translate([s.x + r, side * y, h / 2])
+                cube([pin_r * sqrt(2), w, h], center = true);
+
+            gap = cam_x - pin_r / sqrt(2) + extrusion_width;
+            translate([s.x + r + cam_x - gap / 2, side * (s.y / 2 + wall + clearance / 2), layer_height / 2])
+                cube([gap, 2 * wall + clearance, layer_height], center = true);
+        }
+    }
+}
+
+// Need to use a wrapper because can't define nested modules in an assembly
+module _drag_chain_assembly(type, pos = 0, render = false) {
+    s = drag_chain_size(type);
+    x = (1 + exploded()) * s.x;
+    r = drag_chain_radius(type) * x / s.x;
+    links = drag_chain_links(type);
+    actual_travel = (links - 4) * s.x;
+    z = drag_chain_outer_size(type).z;
+
+    zb = z / 2;                                     // z of bottom track
+    c = [actual_travel / 2 + pos / 2, 0, r + zb];   // centre of bend
+
+    points = [                                      // Calculate list of hinge points
+        for(i = 0, p = [0, 0, z / 2 + 2 * r]; i < links + 1;
+            i = i + 1,
+            dx = p.z > c.z ? x : -x,
+            p = max(p.x + dx, p.x) <= c.x ? p + [dx, 0, 0]      // Straight sections
+                  : let(q = circle_intersect(p, x, c, r))
+                        q.x <= c.x ? [p.x - sqrt(sqr(x) - sqr(p.z - zb)), 0, zb] // Transition back to straight
+                                   : q) // Circular section
+        p
+    ];
+    npoints = len(points);
+
+    module link(n)                                  // Position and colour link with origin at the hinge hole
+        translate([-z / 2, 0, -z / 2]) {
+            vflip(!drag_chain_supports(type))
+                stl_colour(n < 0 || n == npoints - 1 ? pp3_colour : n % 2 ? pp1_colour : pp2_colour)
+                    render_if(render)
+                        drag_chain_link(type, start = n == -1, end = n == npoints - 1, check_kids = false)
+                            let($fasteners = 0)
+                                children();
+
+            let($fasteners = 1) children();
+        }
+
+    screws = drag_chain_screw_lists(type);
+    custom_start = screws[0] == [0, 0, 0, 0];
+    custom_end   = screws[1] == [0, 0, 0, 0];
+    assert($children == bool2int(custom_start) + bool2int(custom_end), str("wrong number of children for end customisation: ", $children));
+
+    for(i = [0 : npoints - 2]) let(v = points[i + 1] - points[i])
+        translate(points[i])
+            rotate([0, -atan2(v.z, v.x), 0])
+                link(i);
+
+    translate(points[0] - [x, 0, 0])
+        link(-1)
+            if(custom_start)
+                children(0);
+
+    translate(points[npoints - 1])
+        hflip()
+            link(npoints - 1)
+                if(custom_end)
+                    children(custom_start ? 1 : 0);
+}
+
+//! 1. Remove the support material from the links with side cutters.
+//! 1. Clip the links together with the special ones at the ends.
+module drag_chain_assembly(type, pos = 0, render = false)  //! Drag chain assembly
+    assembly(str(drag_chain_name(type), "_drag_chain"), big = true, ngb = true)
+        if($children == 2)
+            _drag_chain_assembly(type, pos, render) {
+                children(0);
+                children(1);
+            }
+        else if($children == 1)
+            _drag_chain_assembly(type, pos, render)
+                children(0);
+        else
+            _drag_chain_assembly(type, pos, render);

printed/fan_guard.scad

@@ -17,7 +17,7 @@
 // If not, see <https://www.gnu.org/licenses/>.
 
 //
-//! Pintable fan finger guard to match the specified fan. To be ```include```d, not ```use```d.
+//! Printable fan finger guard to match the specified fan. To be `include`d, not `use`d.
 //!
 //! The ring spacing as well as the number of spokes can be specified, if zero a gasket is generated instead of a guard.
 //
@@ -29,7 +29,7 @@ function fan_guard_wall() = extrusion_width - layer_height / 2 + nozzle / 2 + ex
 function fan_guard_corner_r(type) = washer_diameter(screw_washer(fan_screw(type))) / 2 + 0.5; //! Corner radius of the guard
 function fan_guard_width(type) = max(2 * (fan_hole_pitch(type) + fan_guard_corner_r(type)), fan_bore(type) + 4 * fan_guard_wall()); //! Width of the guard
 
-module fan_guard(type, name = false, thickness = fan_guard_thickness(), spokes = 4, finger_width = 7, grill = false) { //! Generate the STL
+module fan_guard(type, name = false, thickness = fan_guard_thickness(), spokes = 4, finger_width = 7, grill = false, screws = true) { //! Generate the STL
     if(thickness)
         stl(name ? name : str("fan_guard_", fan_width(type)));
     hole_pitch = fan_hole_pitch(type);
@@ -54,7 +54,7 @@ module fan_guard(type, name = false, thickness = fan_guard_thickness(), spokes =
                 difference() {
                     rounded_square([width, width], r = width / 2 - hole_pitch);
 
-                    fan_holes(type, !grill, !grill, h = 0);
+                    fan_holes(type, !grill, !grill && screws, h = 0);
                 }
                 if(spokes) {
                     intersection() {

printed/fixing_block.scad

@@ -25,10 +25,10 @@
 //!
 //! Note that the block with its inserts is defined as a sub assembly, but its fasteners get added to the parent assembly.
 //!
-//! Specific fasteners can be omitted by setting a side's thickness to 0 and the block omitted by setting ```show_block``` to false.
+//! Specific fasteners can be omitted by setting a side's thickness to 0 and the block omitted by setting `show_block` to false.
 //! This allows the block and one set of fasteners to be on one assembly and the other fasteners on the mating assemblies.
 //!
-//! Star washers can be omitted by setting ```star_washers``` to false.
+//! Star washers can be omitted by setting `star_washers` to false.
 //
 include <../core.scad>
 use <../vitamins/insert.scad>
@@ -71,42 +71,43 @@ module fixing_block_h_hole_2D(screw = def_screw) //! Position 2D child on the ho
         children();
 
 module fixing_block(screw = def_screw) { //! Generate the STL
-    stl(str("fixing_block_M", screw_radius(screw) * 20));
-    r = 1;
+   r = 1;
     insert = screw_insert(screw);
     corner_rad = insert_outer_d(insert) / 2 + wall;
     fb_width = fixing_block_width(screw);
     fb_height = fixing_block_height(screw);
     fb_depth = fixing_block_depth(screw);
 
-    difference() {
-        union() {
-            linear_extrude(fb_height, convexity = 5)
-                difference() {
-                    hull() {
-                        for(side = [-1, 1]) {
-                            translate([side * (fb_width / 2 - corner_rad), fb_depth - corner_rad])
-                                circle4n(corner_rad);
+    stl(str("fixing_block_M", screw_radius(screw) * 20))
+        difference() {
+            union() {
+                linear_extrude(fb_height, convexity = 5)
+                    difference() {
+                        hull() {
+                            for(side = [-1, 1]) {
+                                translate([side * (fb_width / 2 - corner_rad), fb_depth - corner_rad])
+                                    circle4n(corner_rad);
 
-                            translate([side * (fb_width / 2 - r), r])
-                                circle4n(r);
+                                translate([side * (fb_width / 2 - r), r])
+                                    circle4n(r);
+                            }
                         }
+                        fixing_block_v_holes(screw)
+                            poly_circle(screw_clearance_radius(screw));
                     }
-                    fixing_block_v_holes(screw)
-                        poly_circle(screw_clearance_radius(screw));
-                }
-        }
-        translate_z(fb_height)
-            fixing_block_v_holes(screw)
-                insert_hole(insert);
+            }
+            translate_z(fb_height)
+                fixing_block_v_holes(screw)
+                    insert_hole(insert);
 
-        fixing_block_h_hole(screw)
-            insert_hole(insert, 10, true);
-    }
+            fixing_block_h_hole(screw)
+                insert_hole(insert, 10, true);
+        }
 }
 
-module fixing_block_assembly(screw = def_screw) pose([55, 180, 25], [0, 4.8, 4.8]) //! Printed part with the inserts inserted
-assembly(str("fixing_block_M", 20 * screw_radius(screw))) {
+module fixing_block_assembly(screw = def_screw) //! Printed part with the inserts inserted
+pose([55, 180, 25], [0, 4.8, 4.8])
+assembly(str("fixing_block_M", 20 * screw_radius(screw)), ngb = true) {
     translate_z(fixing_block_height(screw))
         rotate([0, 180, 0])
             stl_colour(pp1_colour) render() fixing_block(screw);
@@ -122,9 +123,7 @@ assembly(str("fixing_block_M", 20 * screw_radius(screw))) {
 
 module fastened_fixing_block_assembly(thickness, screw = def_screw, screw2 = undef, thickness2 = undef, show_block = true, star_washers = true) { //! Assembly with fasteners in place
     module fb_screw(screw, thickness) {
-        washer = screw_washer(screw);
-        insert = screw_insert(screw);
-        screw_length = screw_longer_than((star_washers ? 2 : 1) * washer_thickness(washer) + thickness + insert_length(insert));
+        screw_length = screw_length(screw, thickness, star_washers ? 2 : 1, true, longer = true);
 
         if(thickness)
             translate_z(thickness)

printed/flat_hinge.scad

@@ -25,8 +25,8 @@
 //!
 //! Opening the test in OpenSCAD with its customiser enabled allows these parameters to be played with.
 //!
-//! Note setting ```thickness1``` or ```thickness2``` to zero in the ```hinge_fastened_assembly()``` removes the screws from one side or the other and
-//! setting ```show_hinge``` to false removes the hinge.
+//! Note setting `thickness1` or `thickness2` to zero in the `hinge_fastened_assembly()` removes the screws from one side or the other and
+//! setting `show_hinge` to false removes the hinge.
 //! This allows the hinges and one set of screws to belong to one assembly and the other set of screws to another assembly.
 //
 include <../core.scad>
@@ -40,7 +40,10 @@ function hinge_knuckles(type)    = type[6]; //! How many knuckles
 function hinge_screw(type)       = type[7]; //! Screw type to mount it
 function hinge_screws(type)      = type[8]; //! How many screws
 function hinge_clearance(type)   = type[9]; //! Clearance between knuckles
-function hinge_margin(type)      = type[10]; //! How far to keep the screws from the knuckes
+function hinge_margin(type)      = type[10]; //! How far to keep the screws from the knuckles
+
+function flat_hinge(name, size, pin_d, knuckle_d, knuckles, screw, screws, clearance, margin) = //! Construct the property list for a flat hinge.
+ [name, size.x, size.y, size.z, pin_d, knuckle_d, knuckles, screw, screws, clearance, margin];
 
 function hinge_radius(type)      = washer_radius(screw_washer(hinge_screw(type))) + 1;
 
@@ -62,8 +65,6 @@ module hinge_screw_positions(type) { //! Place children at the screw positions
 }
 
 module hinge_male(type, female = false) {       //! The half with the stationary pin
-    stl(str("hinge_", female ? "fe": "", "male_", type[0]));
-
     r = hinge_radius(type);
     w = hinge_width(type);
     t = hinge_thickness(type);
@@ -72,7 +73,7 @@ module hinge_male(type, female = false) {       //! The half with the stationary
     assert(kr > pr, "knuckle diameter must be bigger than the pin diameter");
 
     n = hinge_knuckles(type);
-    assert(n >= 3, "must be at least three knuckes");
+    assert(n >= 3, "must be at least three knuckles");
     mn = ceil(n / 2);                           // Male knuckles
     fn = floor(n / 2);                          // Female knuckles
     gap = hinge_clearance(type);
@@ -82,37 +83,40 @@ module hinge_male(type, female = false) {       //! The half with the stationary
     teardrop_r = kr / cos(22.5);                // The corner on the teardrop
     inset = sqrt(sqr(teardrop_r + gap) - sqr(kr - t)) - kr;
 
-    linear_extrude(t)
-        difference() {
-            hull() {
-                for(side = [-1, 1])
-                    translate([side * (w / 2 - r), hinge_depth(type) - r])
-                        circle4n(r);
+    stl(str("hinge_", female ? "fe": "", "male_", type[0]))
+        union() {
+            linear_extrude(t)
+                difference() {
+                    hull() {
+                        for(side = [-1, 1])
+                            translate([side * (w / 2 - r), hinge_depth(type) - r])
+                                circle4n(r);
 
-                translate([-w / 2, inset])
-                    square([w, eps]);
-            }
-            hinge_screw_positions(type)
-                poly_circle(screw_clearance_radius(hinge_screw(type)));
+                        translate([-w / 2, inset])
+                            square([w, eps]);
+                    }
+                    hinge_screw_positions(type)
+                        poly_circle(screw_clearance_radius(hinge_screw(type)));
+                }
+
+            pitch = mw + gap + fw + gap;
+            dir = female ? -1 : 1;
+            translate([0, -kr, kr])
+                rotate([90, 0, -90])
+                    for(z = [0 : (female ? fn : mn) - 1])
+                        translate_z(-dir * w / 2 + z * dir * pitch + (female ? -fw - mw - gap : 0))
+                            linear_extrude(female ? fw : mw)
+                                difference() {
+                                    hull() {
+                                        rotate(180)
+                                            teardrop(r = kr, h = 0);
+
+                                        translate([-kr - 1, -kr])
+                                            square(1);
+                                    }
+                                    teardrop_plus(r = pr + (female ? gap : 0), h = 0);
+                                }
         }
-
-    pitch = mw + gap + fw + gap;
-    dir = female ? -1 : 1;
-    translate([0, -kr, kr])
-        rotate([90, 0, -90])
-            for(z = [0 : (female ? fn : mn) - 1])
-                translate_z(-dir * w / 2 + z * dir * pitch + (female ? -fw - mw - gap : 0))
-                    linear_extrude(female ? fw : mw)
-                        difference() {
-                            hull() {
-                                rotate(180)
-                                    teardrop(r = kr, h = 0);
-
-                                translate([-kr - 1, -kr])
-                                    square(1);
-                            }
-                            teardrop_plus(r = pr + (female ? gap : 0), h = 0);
-                        }
 }
 
 module hinge_female(type) hinge_male(type, true);
@@ -126,7 +130,7 @@ module hinge_both(type) { //! Both parts together for printing
 }
 
 module hinge_assembly(type, angle = 0)
-assembly(str("hinge_", type[0])) { //! Assembled hinge
+assembly(str("hinge_", type[0]), ngb = true) { //! Assembled hinge
     kr = hinge_knuckle_dia(type) / 2;
     hr = hinge_pin_dia(type) / 2;
     w = hinge_width(type);
@@ -152,9 +156,7 @@ module hinge_fastened_assembly(type, thickness1, thickness2, angle, show_hinge =
         hinge_assembly(type, angle);
 
     screw = hinge_screw(type);
-    washer_t = 2 * washer_thickness(screw_washer(screw));
     nut = screw_nut(screw);
-    nut_t = nut_thickness(nut, true);
     t = hinge_thickness(type);
     kr = hinge_knuckle_dia(type) / 2;
 
@@ -162,7 +164,7 @@ module hinge_fastened_assembly(type, thickness1, thickness2, angle, show_hinge =
         if(thickness)
             hinge_screw_positions(type) {
                 translate_z(t)
-                    screw_and_washer(screw, screw_longer_than(t + thickness + washer_t + nut_t));
+                    screw_and_washer(screw, screw_length(screw, t + thickness, 2, nyloc = true));
 
                 translate_z(-thickness)
                     vflip()

printed/foot.scad

@@ -24,8 +24,10 @@
 include <../core.scad>
 use <../vitamins/insert.scad>
 
-foot        = [25, 12, 3, 2, M4_cap_screw, 10];
-insert_foot = [20, 10, 0, 2, M3_cap_screw, 10];
+function Foot(d, h, t, r, screw, slant = 10) = [d, h, t, r, screw, slant]; //! Construct a foot property list
+
+foot        = Foot(25, 12, 3, 2, M4_cap_screw);
+insert_foot = Foot(20, 10, 0, 2, M3_cap_screw);
 
 function insert_foot() = insert_foot; //! Default foot with insert
 
@@ -37,7 +39,6 @@ function foot_screw(type = foot)    = type[4]; //! Screw type
 function foot_slant(type = foot)    = type[5]; //! Taper angle
 
 module foot(type = foot) { //! Generate STL
-    stl("foot");
     h = foot_height(type);
     t = foot_thickness(type);
     r1 = washer_radius(screw_washer(foot_screw(type)));
@@ -45,39 +46,40 @@ module foot(type = foot) { //! Generate STL
     r2 = r3 - h * tan(foot_slant(type));
     r =  foot_rad(type);
 
-    union() {
-        rotate_extrude(convexity = 3) {
-            hull() {
-                translate([r1, 0])
-                    square([r3 - r1, eps]);
+    stl("foot")
+        union() {
+            rotate_extrude(convexity = 3) {
+                hull() {
+                    translate([r1, 0])
+                        square([r3 - r1, eps]);
 
-                for(x = [r1 + r, r2 - r])
-                    translate([x, h - r])
-                        circle4n(r);
+                    for(x = [r1 + r, r2 - r])
+                        translate([x, h - r])
+                            circle4n(r);
+                }
+            }
+            linear_extrude(t)
+                difference() {
+                    circle(r1 + eps);
+
+                    poly_circle( screw_clearance_radius(foot_screw(type)));
             }
         }
-        linear_extrude(t)
-            difference() {
-                circle(r1 + eps);
-
-                poly_circle( screw_clearance_radius(foot_screw(type)));
-        }
-    }
 }
 
-module foot_assembly(t = 0, type = foot, flip = false) { //! Assembly with fasteners in place for specified sheet thickness
+module foot_assembly(t = 0, type = foot, flip = false, no_washer = false) { //! Assembly with fasteners in place for specified sheet thickness
     screw = foot_screw(type);
-    washer = screw_washer(screw);
     nut = screw_nut(screw);
     squeeze = 0.5;
-    screw_length = screw_longer_than(foot_thickness(type) + t + 2 * washer_thickness(washer) + nut_thickness(nut, true) - squeeze);
+    screw_length = screw_length(screw, foot_thickness(type) + t - squeeze, no_washer ? 1 : 2, nyloc = true);
 
     vflip() explode(15, true) {
-        stl_colour(pp4_colour) foot(type);
+        translate_z(-squeeze)
+            stl_colour(pp4_colour) foot(type);
 
         if(t)
             explode(15, true)
-                translate_z(foot_thickness(type))
+                translate_z(foot_thickness(type) - squeeze)
                     if(flip)
                         nut_and_washer(nut, true);
                     else
@@ -86,13 +88,18 @@ module foot_assembly(t = 0, type = foot, flip = false) { //! Assembly with faste
     if(t)
         translate_z(t)
             if(flip)
-                screw_and_washer(screw, screw_length);
+                if(no_washer)
+                    screw(screw, screw_length);
+                else
+                    screw_and_washer(screw, screw_length);
             else
-                nut_and_washer(nut, true);
+                if(no_washer)
+                    nut(nut, true);
+                else
+                    nut_and_washer(nut, true);
 }
 
 module insert_foot(type = insert_foot) { //! Generate STL for foot with insert
-    stl("insert_foot");
     h = foot_height(type);
     r3 = foot_diameter(type) / 2;
     r2 = r3 - h * tan(foot_slant(type));
@@ -102,36 +109,37 @@ module insert_foot(type = insert_foot) { //! Generate STL for foot with insert
     h2 = insert_hole_length(insert);
     r4 = insert_hole_radius(insert);
     r5 = r4 + 1;
-    union() {
-        rotate_extrude() {
-            union() {
-                hull() {
-                    translate([r5, 0]) {
-                        square([r3 - r5, eps]);
-                        square([eps, h]);
-                    }
+    stl("insert_foot")
+        union() {
+            rotate_extrude() {
+                union() {
+                    hull() {
+                        translate([r5, 0]) {
+                            square([r3 - r5, eps]);
+                            square([eps, h]);
+                        }
 
-                    translate([r2 - r, h - r])
-                        circle4n(r);
+                        translate([r2 - r, h - r])
+                            circle4n(r);
+                    }
                 }
             }
+            linear_extrude(h2 + eps)
+                difference() {
+                    circle(r5 + eps);
+
+                    poly_circle(r4);
+                }
+
+            translate_z(h2)
+                cylinder(r = r5 + eps, h = h - h2);
         }
-        linear_extrude(h2 + eps)
-            difference() {
-                circle(r5 + eps);
-
-                poly_circle(r4);
-            }
-
-        translate_z(h2)
-            cylinder(r = r5 + eps, h = h - h2);
-    }
 }
 //
 //! Place the insert in the bottom of the foot and push home with a soldering iron with a conical bit heated to 200&deg;C.
 //
 module insert_foot_assembly(type = insert_foot) //! Printed part with insert in place
-assembly("insert_foot") {
+assembly("insert_foot", ngb = true) {
     screw = foot_screw(type);
     insert = screw_insert(screw);
 
@@ -144,9 +152,7 @@ assembly("insert_foot") {
 
 module fastened_insert_foot_assembly(t = 3, type = insert_foot) { //! Assembly with fasteners in place for specified sheet thickness
     screw = foot_screw(type);
-    washer = screw_washer(screw);
-    insert = screw_insert(screw);
-    screw_length = screw_shorter_than(insert_length(insert) + t + 2 * washer_thickness(washer));
+    screw_length = screw_length(screw, t, 2, insert = true);
 
     explode(-10) insert_foot_assembly(type);
 

printed/handle.scad

@@ -46,8 +46,6 @@ module handle_holes(h = 100) //! Drills holes for the screws
         drill(screw_clearance_radius(screw), h);
 
 module handle_stl() { //! generate the STL
-    stl("handle");
-
     module end(end)
         translate([end * pitch / 2, 0])
             rotate_extrude()
@@ -59,29 +57,31 @@ module handle_stl() { //! generate the STL
                         square([dia / 2 + 1, dia + 1]);
                 }
 
-    translate_z(dia / 2)
-        union() {
-            hull() {
-                end(-1);
+    stl("handle")
+        translate_z(dia / 2)
+            union() {
+                hull() {
+                    end(-1);
 
-                end(1);
-            }
-
-            handle_screw_positions()
-                render() difference() {
-                    h =  height + dia / 2;
-                    cylinder(d = dia, h = h);
-
-                    translate_z(h)
-                        insert_hole(insert, 6);
+                    end(1);
                 }
-        }
+
+                handle_screw_positions()
+                    render() difference() {
+                        h =  height + dia / 2;
+                        cylinder(d = dia, h = h);
+
+                        translate_z(h)
+                            insert_hole(insert, 6);
+                    }
+            }
 }
 //
 //! Place inserts in the bottom of the posts and push them home with a soldering iron with a conical bit heated to 200°C.
 //
-module handle_assembly() pose([225, 0, 150], [0, 0, 14]) //! Printed part with inserts in place
-assembly("handle") {
+module handle_assembly() //! Printed part with inserts in place
+pose([225, 0, 150], [0, 0, 14])
+assembly("handle", ngb = true) {
     translate_z(handle_height())
         stl_colour(pp1_colour) vflip() handle_stl();
 
@@ -91,7 +91,7 @@ assembly("handle") {
 }
 
 module handle_fastened_assembly(thickness) { //! Assembly with fasteners in place
-    screw_length = screw_longer_than(thickness + insert_length(insert) + 2 * washer_thickness(screw_washer(screw)));
+    screw_length = screw_length(screw, thickness, 2, true, longer = true);
 
     handle_assembly();
 

printed/knob.scad

@@ -0,0 +1,171 @@
+//
+// NopSCADlib Copyright Chris Palmer 221
+// 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/>.
+//
+
+//
+//! Parametric knobs for potentiometers and encoders.
+//!
+//! A knob can be constructed by specififying all the parameters or the potentiometer can be specified to customise it for its shaft with a recess to clear the nut, washer and thread.
+//! An optional skirt and / or a pointer can be specified.
+//!
+//! The STL includes a support membrane that needs to be cut out and a thread needs to be tapped for the grub screw.
+//
+
+include <../core.scad>
+use <../utils/hanging_hole.scad>
+use <../utils/rounded_polygon.scad>
+use <../vitamins/potentiometer.scad>
+
+clearance = 0.2;
+
+function knob_name(type)     = type[0]; //! Name for the stl maker
+function knob_top_d(type)    = type[1]; //! Diameter at the top
+function knob_bot_d(type)    = type[2]; //! Diameter at the bottom
+function knob_height(type)   = type[3]; //! Height
+function knob_corner_r(type) = type[4]; //! Rounded top corner
+function knob_shaft_d(type)  = type[5]; //! Shaft diameter
+function knob_shaft_len(type)= type[6]; //! Shaft length
+function knob_flat_d(type)   = type[7]; //! The shaft diameter at the flat
+function knob_flat_h(type)   = type[8]; //! The length of the flat
+function knob_screw(type)    = type[9]; //! The grub screw type
+function knob_skirt(type)    = type[10]; //! Skirt diameter and thickness
+function knob_recess(type)   = type[11]; //! Recess diameter and thickness to clear nut and thread, diameter, nut height, thread height
+function knob_pointer(type)  = type[12]; //! Pointer outside radius, [point width, back width] and height height
+
+function knob(name = "knob", top_d = 12, bot_d = 15, height = 18, shaft_length, skirt = [20, 2], pointer = false, corner_r = 2, screw = M3_grub_screw, shaft_d, flat_d, flat_h, recess) = //! Constructor
+[
+    name, top_d, bot_d, height, corner_r, shaft_d, shaft_length, flat_d, flat_h, screw, skirt, recess, pointer
+];
+
+function knob_for_pot(pot, thickness, z = 1, washer = true, top_d = 12, bot_d = 15, height = 0, shaft_length = undef, skirt = [20, 2], pointer = false, corner_r = 2, screw = M3_grub_screw) =  //! Construct a knob to fit specified pot
+    let(s = pot_shaft(pot),
+        washer = washer && pot_washer(pot) ? pot_washer(pot) : [0, 0],
+        nut = pot_nut(pot) ? pot_nut(pot) : [pot_thread_d(pot) * cos(30), pot_thread_h(pot) - thickness],
+        shaft_length = is_undef(shaft_length) ? s.z : min(shaft_length, s.z),
+        h = round_to_layer(shaft_length + pot_thread_h(pot) - thickness - z),
+        height = max(height, h + 1),
+        recess = [(z > washer.y ? nut.x / cos(30) : washer.x) + 0.4, round_to_layer(nut.y + washer.y - z + layer_height), round_to_layer(pot_thread_h(pot) - z - thickness + 2 * layer_height)],
+        flat_d = s.y + 0.06,
+        flat_h = min(s[3], shaft_length)
+    )
+    knob(name = str(pot[0], "_knob"),
+         top_d = top_d,
+         bot_d = bot_d,
+         height = height,
+         corner_r = corner_r,
+         screw = screw,
+         skirt = skirt,
+         pointer = pointer,
+         shaft_d = s.x,
+         shaft_length = h,
+         flat_d = flat_d,
+         flat_h = flat_h,
+         recess = recess);
+
+function knob_screw_z(type) = knob_shaft_len(type) - knob_flat_h(type) / 2;
+
+module knob(type, supports = true) { //! Generate the STL for a knob
+    r_top = knob_top_d(type) / 2;
+    r_bot = knob_bot_d(type) / 2;
+    h = knob_height(type);
+    r = knob_corner_r(type);
+    screw = knob_screw(type);
+    sr = knob_shaft_d(type) / 2 + (screw ? clearance : 0);
+    top_wall = h - knob_shaft_len(type);
+    fr = knob_flat_d(type) - sr + 2 * clearance;
+    fh = knob_flat_h(type);
+    skirt = knob_skirt(type);
+    recess = knob_recess(type);
+    pointer = knob_pointer(type);
+
+    stl(knob_name(type))
+    {
+        difference() {
+            union() {
+                rotate_extrude() {
+                    rounded_polygon([
+                        [0, h, 0],
+                        [r_top - r, h - r, r],
+                        [r_bot, 0, 0],
+                        [0, 0, 0],
+                    ]);
+
+                    if(skirt)
+                        square([skirt.x / 2, skirt.y]);
+                }
+                if(pointer)
+                    linear_extrude(pointer.z)
+                        rotate(-90)
+                            hull() {
+                                translate([pointer.x, 0])
+                                    square([eps, pointer.y[0]], center = true);
+
+                                translate([r_bot, 0])
+                                    square([eps, pointer.y[1]], center = true);
+                            }
+            }
+            shaft_z = recess ? recess.z + (supports ? layer_height : -eps) : -eps;
+            translate_z(shaft_z) {
+                h = h - top_wall - shaft_z;
+                linear_extrude(h)
+                    difference() {
+                        poly_circle(sr);
+
+                        if(fr > 0)
+                            translate([-sr, fr])
+                                square([2 * sr, sr]);
+                    }
+
+                if(h > fh)
+                    poly_cylinder(sr, round_to_layer(h - fh), center = false);
+            }
+
+            if(recess)
+                translate_z(-eps)
+                    hull() {
+                        poly_cylinder(r = recess.x / 2, h = recess.y + eps, center = false);
+
+                        linear_extrude(recess.z + eps)
+                            offset(min(-(recess.z - recess.y), 0))
+                                poly_circle(recess.x / 2);
+                    }
+
+            if(screw)
+                translate_z(knob_screw_z(type))
+                    rotate([90, 0, 180])
+                        teardrop_plus(r = screw_pilot_hole(screw), h = max(r_top, r_bot) + eps, center = false);
+        }
+    }
+}
+
+//! Knob with grub screw in place
+module knob_assembly(type) explode(40, explode_children = true) { //! Assembly with the grub screw in place
+    sr = knob_shaft_d(type) / 2;
+    fr = knob_flat_d(type) < sr ? knob_flat_d(type) - sr : sr;
+    r_top = knob_top_d(type) / 2;
+    r_bot = knob_bot_d(type) / 2;
+    screw_length = screw_shorter_than(min(r_top, r_bot) - fr);
+    screw = knob_screw(type);
+
+    stl_colour(pp1_colour) render() knob(type, supports = false);
+
+    if(screw)
+        translate([0, (fr + screw_length), knob_screw_z(type)])
+            rotate([90, 0, 180])
+                screw(screw, screw_length);
+}

printed/pcb_mount.scad

@@ -66,35 +66,35 @@ module pcb_mount_washer_stl() //! A plastic washer to clamp a PCB
         pcb_mount_ring();
 
 module pcb_mount(pcb, height = 5, washers = true) { //! Make the STL of a pcb mount for the specified PCB.
-    stl(str("pcb_mount_", pcb[0], "_", height));
-
     y_pitch = pcb_width(pcb) > 4 * pillar_r + 4 ? pillar_r + 1
                                                 : pcb_width(pcb) / 2 + frame_w + 1 + pillar_r;
 
-    if(washers)
-        for(x = [-1, 1], y = [-1, 1])
-            translate([x * (pillar_r + 1), y * y_pitch, 0])
-                pcb_mount_washer_stl();
+    stl(str("pcb_mount_", pcb[0], "_", height)) union() {
+        if(washers)
+            for(x = [-1, 1], y = [-1, 1])
+                translate([x * (pillar_r + 1), y * y_pitch, 0])
+                    pcb_mount_washer_stl();
 
-    for(x = [-1, 1])
-        translate([x * pillar_x_pitch(pcb) / 2, 0, frame_t / 2])
-            cube([frame_w, pillar_y_pitch(pcb) - 2 * wall, frame_t], center = true);
+        for(x = [-1, 1])
+            translate([x * pillar_x_pitch(pcb) / 2, 0, frame_t / 2])
+                cube([frame_w, pillar_y_pitch(pcb) - 2 * wall, frame_t], center = true);
 
-    for(y = [-1, 1])
-        translate([0, y * pillar_y_pitch(pcb) / 2, frame_t / 2])
-            cube([pillar_x_pitch(pcb) - 2 * wall, frame_w, frame_t], center = true);
+        for(y = [-1, 1])
+            translate([0, y * pillar_y_pitch(pcb) / 2, frame_t / 2])
+                cube([pillar_x_pitch(pcb) - 2 * wall, frame_w, frame_t], center = true);
 
-    pcb_mount_screw_positions(pcb)
-        linear_extrude(height)
-            pcb_mount_ring();
-
-    linear_extrude(height + pcb_thickness(pcb) - layer_height)
-        difference() {
-            pcb_mount_screw_positions(pcb)
+        pcb_mount_screw_positions(pcb)
+            linear_extrude(height)
                 pcb_mount_ring();
 
-            square([pcb_length(pcb) + 2 * clearance, pcb_width(pcb) + 2 * clearance], center = true);
-        }
+        linear_extrude(height + pcb_thickness(pcb) - layer_height)
+            difference() {
+                pcb_mount_screw_positions(pcb)
+                    pcb_mount_ring();
+
+                square([pcb_length(pcb) + 2 * clearance, pcb_width(pcb) + 2 * clearance], center = true);
+            }
+    }
 }
 
 module pcb_mount_assembly(pcb, thickness, height = 5) { //! A PCB mount assembly with fasteners
@@ -103,10 +103,9 @@ module pcb_mount_assembly(pcb, thickness, height = 5) { //! A PCB mount assembly
 
     stl_colour(pp1_colour) pcb_mount(pcb, washers = false);
 
-    washer = screw_washer(screw);
     nut = screw_nut(screw);
     t = pcb_thickness(pcb);
-    screw_length = screw_longer_than(height + t + washer_thickness + thickness + washer_thickness(washer) + nut_thickness(nut, true));
+    screw_length = screw_length(screw, height + t + washer_thickness + thickness, 1, nyloc = true);
 
     pcb_mount_screw_positions(pcb) {
         translate_z(height + t) {

printed/pocket_handle.scad

@@ -0,0 +1,154 @@
+//
+// NopSCADlib Copyright Chris Palmer 2021
+// 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/>.
+//
+
+//
+//! Customisable pocket handle
+//
+include <../core.scad>
+
+function pocket_handle(hand_size = [90, 40, 40], slant = 35, screw = M3_cs_cap_screw, panel_t = 3, wall = 4, rad = 4) = //! Construct a pocket_handle property list
+    [hand_size, slant, screw, panel_t, wall, rad];
+
+function pocket_handle_hand_size(type) = type[0]; //! Size of the hole for the fingers
+function pocket_handle_slant(type)     = type[1]; //! Upward slant of the hand hole
+function pocket_handle_screw(type)     = type[2]; //! Screw type, can be countersunk or not
+function pocket_handle_panel_t(type)   = type[3]; //! Thickness of the panel it is mounted in
+function pocket_handle_wall(type)      = type[4]; //! Wall thickness
+function pocket_handle_rad(type)       = type[5]; //! Min corner rad
+
+function pocket_handle_flange(type) = //! Size of the flange
+    let(w = pocket_handle_wall(type),
+        f = washer_diameter(screw_washer(pocket_handle_screw(type))) + 2 + w,
+        s = pocket_handle_hand_size(type))
+             [s.x + 2 * f, s.y + 2 * f, w];
+
+module pocket_handle_hole_positions(type) { //! Place children at screw hole positions
+    f = pocket_handle_flange(type);
+    h = pocket_handle_hand_size(type);
+    x_pitch = (f.x + h.x) / 4;
+    y_pitch = (f.y + h.y) / 4;
+
+    for(x = [-1, 1], y = [-1, 1])
+        translate([x * x_pitch, y * y_pitch])
+            children();
+}
+
+module pocket_handle_holes(type, h = 0) { //! Panel cutout and screw holes
+    hand = pocket_handle_hand_size(type);
+    w = pocket_handle_wall(type);
+    slot = [hand.x + 2 * w, hand.y + 2 * w];
+    t = pocket_handle_panel_t(type);
+    clearance = norm([slot.y, t]) - slot.y + 0.2; // has to be enough clearance for the diagonal to swing it in
+
+    extrude_if(h) {
+        pocket_handle_hole_positions(type)
+            drill(screw_clearance_radius(pocket_handle_screw(type)), 0);
+
+        rounded_square([slot.x  + clearance, slot.y + clearance], pocket_handle_rad(type) + w + clearance / 2);
+    }
+}
+
+module pocket_handle(type) { //! Generate STL for pocket_handle
+    f = pocket_handle_flange(type);
+    r = pocket_handle_rad(type);
+    s = pocket_handle_slant(type);
+    o = f.z * tan(s);
+    h = pocket_handle_hand_size(type);
+    t = pocket_handle_panel_t(type);
+    w = pocket_handle_wall(type);
+    screw = pocket_handle_screw(type) ;
+
+    stl("pocket_handle")
+        union() {
+            difference() {
+                hull() {
+                    rounded_rectangle(f, r);
+
+                    translate_z(f.z - eps)
+                        rounded_rectangle([f.x + 2 * o, f.y + 2 * o, eps], r + o);
+                }
+                hull() {
+                    rounded_rectangle([h.x, h.y, f.z + eps], r);
+
+                    translate_z(-eps)
+                        rounded_rectangle([h.x + 2 * o, h.y + 2 * o, eps], r + o);
+                }
+                pocket_handle_hole_positions(type) {
+                    if(screw_head_height(screw))
+                        translate_z(-eps)
+                            poly_cylinder(r = screw_clearance_radius(screw), h = f.z + 2 * eps, center = false);
+                    else
+                        screw_polysink(screw, h = 2 * f.z + eps, alt = true);
+                }
+            }
+
+            translate_z(f.z)
+                linear_extrude(t)
+                    difference() {
+                        rounded_square([h.x + 2 * w, h.y + 2 * w], r + w);
+
+                        rounded_square([h.x, h.y], r);
+                    }
+
+            translate_z(f.z + t)
+                difference() {
+                    height = h.z - f.z - t;
+                    hull() {
+                        rounded_rectangle([h.x + 2 * w, h.y + 2 * w, eps], r + w);
+
+                        translate((height + w) * [0, sin(s), cos(s)])
+                            rounded_rectangle([h.x + 2 * w, h.y + 2 * w, eps], r + w);
+                    }
+
+                    hull() {
+                        translate_z(-eps)
+                            rounded_rectangle([h.x, h.y, eps], r);
+
+                        translate(height * [0, sin(s), cos(s)])
+                            rounded_rectangle([h.x, h.y, eps], r);
+                    }
+                }
+        }
+}
+
+module pocket_handle_assembly(type) { //! Assembly with fasteners in place
+    f = pocket_handle_flange(type);
+    screw = pocket_handle_screw(type);
+    nut = screw_nut(screw);
+    t = pocket_handle_panel_t(type);
+    washers = screw_head_height(screw) ? 2 : 1;
+    screw_length = screw_length(screw, f.z + t, washers, nyloc = true);
+
+    translate_z(f.z + t / 2) hflip() {
+        stl_colour(pp1_colour)
+            pocket_handle(type);
+
+        pocket_handle_hole_positions(type) {
+            translate_z(f.z + t)
+                explode(15, true)
+                    nut_and_washer(nut, true);
+
+            vflip()
+                if(washers == 2)
+                    screw_and_washer(screw, screw_length);
+                else
+                    screw(screw, screw_length);
+        }
+    }
+}

printed/press_fit.scad

@@ -0,0 +1,50 @@
+//
+// 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/>.
+//
+
+//
+//! Utility for making printed press fit connectors to join printed parts.
+//!
+//! Add solvent or glue to make a permanent fixture.
+//
+include <../utils/core/core.scad>
+
+interference = 0.0;
+
+bridge_droop = layer_height; //sqrt(4 * layer_height * filament_width / PI) - layer_height;
+
+module press_fit_socket(w = 5, h = 50, horizontal = false) { //! Make a square hole to accept a peg
+    h = horizontal ? h : h + bridge_droop;
+
+    cube([w, w, 2 * h], center = true);
+}
+
+module press_fit_peg(h, w = 5, horizontal = false) {    //! Make a rounded chamfered peg for easy insertion
+    module chamfered_square(w, horizontal) {
+        h = horizontal ? w - bridge_droop : w;
+        rounded_square([w, h], 1);
+    }
+
+    translate_z(-eps)
+        linear_extrude(height = h + eps - layer_height)
+            chamfered_square(w + interference, horizontal);
+
+    translate_z(h - layer_height - eps)
+        linear_extrude(height = layer_height + eps)
+            chamfered_square(w - layer_height, horizontal);
+}

printed/printed_box.scad

@@ -26,10 +26,15 @@
 //!
 //! It can also have printed feet on the base with the screws doubling up to hold the base on.
 //
-include <../core.scad>
+include <../utils/core/core.scad>
+use <../vitamins/screw.scad>
+use <../vitamins/washer.scad>
 use <../vitamins/insert.scad>
 use <foot.scad>
 
+function pbox(name, wall, top_t, base_t, radius, size, foot = false, screw = false, ridges = [0, 0]) //! Construct a printed box property list
+    = concat([name, wall, top_t, base_t, foot, screw, radius, ridges], size);
+
 function pbox_name(type)       = type[0]; //! Name to allow more than one box in a project
 function pbox_wall(type)       = type[1]; //! Wall thickness
 function pbox_top(type)        = type[2]; //! Top thickness
@@ -62,10 +67,8 @@ function pbox_insert(type) = screw_insert(pbox_screw(type)); //! The insert for
 function pbox_washer(type) = screw_washer(pbox_screw(type)); //! The washer for the base screws
 
 function pbox_screw_length(type, panel_thickness = 0) =  //! Length of the base screw
-    let(foot = pbox_foot(type))
-        screw_shorter_than(pbox_base(type) + washer_thickness(pbox_washer(type))
-                            + insert_length(pbox_insert(type))
-                            + (foot ? foot_thickness(foot) : panel_thickness));
+    let(foot = pbox_foot(type), screw = pbox_screw(type))
+        screw_length(screw, pbox_base(type) + (foot ? foot_thickness(foot) : panel_thickness), 1, true);
 
 function pbox_mid_offset(type) = pbox_ridges(type).y + pbox_wall(type) / 2; // Offset to wall midpoint
 
@@ -75,7 +78,7 @@ function pbox_screw_inset(type) = //! How far the base screws are inset
         R =  pbox_radius(type)
     ) max(r, R - (R - r) / sqrt(2));
 
-module pbox_screw_positions(type) {
+module pbox_screw_positions(type) { //! Place children at base screw positions
     foot = pbox_foot(type);
     inset = pbox_screw_inset(type);
     for(x = [-1, 1], y = [-1, 1])
@@ -124,29 +127,31 @@ module pbox_inner_shape(type) {
     rounded_square([w, d], rad, center = true);
 }
 
+module pbox_outer_shape(type) //! 2D outer shape of the box
+    offset(pbox_wall(type) / 2) pbox_mid_shape(type);
+
 module pbox_base(type) { //! Generate the STL for the base
-    stl(str(pbox_name(type),"_base"));
     t = pbox_base(type);
-    difference() {
-        union() {
-            linear_extrude(t)
-                offset(base_outset - 0.2)
-                    pbox_inner_shape(type);
 
-            if($children > 0)
-                children(0);
+    stl(str(pbox_name(type),"_base"))
+        difference() {
+            union() {
+                linear_extrude(t)
+                    offset(base_outset - 0.2)
+                        pbox_inner_shape(type);
+
+                if($children > 0)
+                    children(0);
+            }
+            pbox_screw_positions(type)
+                poly_cylinder(r = screw_clearance_radius(pbox_screw(type)), h = 2 * t + eps, center = true);
+
+            if($children > 1)
+                children(1);
         }
-        pbox_screw_positions(type)
-            poly_cylinder(r = screw_clearance_radius(pbox_screw(type)), h = 2 * t + eps, center = true);
-
-        if($children > 1)
-            children(1);
-    }
 }
 
 module pbox(type) { //! Generate the STL for the main case
-    stl(pbox_name(type));
-
     height = pbox_height(type);
     total_height = pbox_total_height(type);
     top_thickness = pbox_top(type);
@@ -155,60 +160,61 @@ module pbox(type) { //! Generate the STL for the main case
     ledge_inset = base_outset - base_overlap;
     ledge_h = pbox_base(type) ? (ledge_outset - ledge_inset) * 2 : 0;
 
-    difference() {
-        union() {
-            linear_extrude(total_height)
-                offset(wall / 2) pbox_mid_shape(type);
-
-            if($children > 2)
-                children(2);
-        }
+    stl(pbox_name(type))
         difference() {
-            translate_z(top_thickness)
-                union() {
-                    linear_extrude(height + eps)
-                         offset(-wall / 2) pbox_mid_shape(type);
+            union() {
+                linear_extrude(total_height)
+                    pbox_outer_shape(type);
 
-                     translate_z(height)                                     // Recess for the base
-                        linear_extrude(total_height - height)
-                            offset(base_outset)
-                                pbox_inner_shape(type);
-                }
-            // Ledge to support the lid
-            if(ledge_h)
-                translate_z(top_thickness + height - ledge_h)
-                    difference() {
-                        rounded_rectangle([pbox_width(type) + 2 * outset, pbox_depth(type) + 2 * outset, ledge_h], 1, center = false);
+                if($children > 2)
+                    children(2);
+            }
+            difference() {
+                translate_z(top_thickness)
+                    union() {
+                        linear_extrude(height + eps)
+                             offset(-wall / 2) pbox_mid_shape(type);
 
-                        hull() {
-                            linear_extrude(ledge_h + eps)
-                                offset(ledge_inset)
+                         translate_z(height)                                     // Recess for the base
+                            linear_extrude(total_height - height)
+                                offset(base_outset)
                                     pbox_inner_shape(type);
-
-                            linear_extrude(eps)
-                                offset(ledge_outset)
-                                     pbox_inner_shape(type);
-                        }
-                        pbox_screw_positions(type)
-                            insert_hole(pbox_insert(type));
                     }
+                // Ledge to support the lid
+                if(ledge_h)
+                    translate_z(top_thickness + height - ledge_h)
+                        difference() {
+                            rounded_rectangle([pbox_width(type) + 2 * outset, pbox_depth(type) + 2 * outset, ledge_h], 1);
 
-            // Corner lugs for inserts
-            outset = wall + pbox_ridges(type).y;
-            or = pbox_radius(type) + outset;
-            inset = pbox_screw_inset(type) + outset;
-            br = insert_boss_radius(pbox_insert(type), wall);
-            ext = sqrt(2) * inset - or * (sqrt(2) - 1) - br;
-            translate_z(height + top_thickness)
-                pbox_screw_positions(type)
-                    insert_lug(pbox_insert(type), wall, counter_bore = 0, extension = ext, corner_r = or);
+                            hull() {
+                                linear_extrude(ledge_h + eps)
+                                    offset(ledge_inset)
+                                        pbox_inner_shape(type);
 
-            if($children > 0)
-                children(0);
+                                linear_extrude(eps)
+                                    offset(ledge_outset)
+                                         pbox_inner_shape(type);
+                            }
+                            pbox_screw_positions(type)
+                                insert_hole(pbox_insert(type));
+                        }
+
+                // Corner lugs for inserts
+                outset = wall + pbox_ridges(type).y;
+                or = pbox_radius(type) + outset;
+                inset = pbox_screw_inset(type) + outset;
+                br = insert_boss_radius(pbox_insert(type), wall);
+                ext = sqrt(2) * inset - or * (sqrt(2) - 1) - br;
+                translate_z(height + top_thickness)
+                    pbox_screw_positions(type)
+                        insert_lug(pbox_insert(type), wall, counter_bore = 0, extension = ext, corner_r = or);
+
+                if($children > 0)
+                    children(0);
+            }
+            if($children > 1)
+                children(1);
         }
-        if($children > 1)
-            children(1);
-    }
 }
 
 module pbox_inserts(type) //! Place the inserts for the base screws

printed/printed_pulleys.scad

@@ -0,0 +1,200 @@
+//
+// 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/>.
+//
+//! Printed pulleys are a remix of droftarts's (see <https://www.thingiverse.com/droftarts/designs>) Parametric Pulleys
+//! on Thingiverse (see <https://www.thingiverse.com/thing:16627>) and are licensed under the
+//! Creative Commons - Attribution - Share Alike license (see <https://creativecommons.org/licenses/by-sa/3.0/>)
+//
+
+include <../utils/core/core.scad>
+use <../vitamins/pulley.scad>
+
+printed_pulley_GT2_profile = [[0.747183,-0.5],[0.747183,0],[0.647876,0.037218],[0.598311,0.130528],[0.578556,0.238423],[0.547158,0.343077],[0.504649,0.443762],[0.451556,0.53975],[0.358229,0.636924],[0.2484,0.707276],[0.127259,0.750044],[0,0.76447],[-0.127259,0.750044],[-0.2484,0.707276],[-0.358229,0.636924],[-0.451556,0.53975],[-0.504797,0.443762],[-0.547291,0.343077],[-0.578605,0.238423],[-0.598311,0.130528],[-0.648009,0.037218],[-0.747183,0],[-0.747183,-0.5]];
+
+function printed_pulley_inverted(type) = pulley_hub_dia(type) < pulley_flange_dia(type); //! Need to print upside down to prevent overhang
+
+function printed_pulley_od(tooth_count, tooth_pitch, pitch_line_offset)
+    = tooth_count * tooth_pitch / PI - 2 * pitch_line_offset;
+
+module printed_pulley_teeth_from_profile(tooth_count, tooth_depth, tooth_width, tooth_profile) {
+    pulley_od = printed_pulley_od(tooth_count, 2, 0.254);
+
+    difference() {
+        rotate (90 / tooth_count)
+            circle(r = pulley_od / 2, $fn = tooth_count * 4);
+        tooth_distance_from_centre = sqrt(pulley_od * pulley_od - (tooth_width + 0.2) * (tooth_width + 0.2)) / 2;
+        for(i = [1 : tooth_count])
+            rotate(i * 360 / tooth_count)
+                translate([0, -tooth_distance_from_centre])
+                    scale([(tooth_width + 0.2) / tooth_width, 1])
+                        polygon(tooth_profile);
+    }
+}
+
+module printed_pulley_GT2_teeth(type) {
+    tooth_count = pulley_teeth(type);
+    if (tooth_count == 0)
+        circle(r = pulley_od(type) / 2);
+    else
+        printed_pulley_teeth_from_profile(tooth_count, 0.764, 1.494, printed_pulley_GT2_profile);
+}
+
+
+module printed_pulley_teeth(type) { //! Draw the pulley's teeth
+    tooth_count = pulley_teeth(type);
+    tw = pulley_od(type) * PI / (tooth_count * 2);
+    ir = pulley_ir(type);
+    or = pulley_od(type) / 2;
+
+    T_angle = 40;
+    GT_r = 0.555;
+    for (i = [0 : 1 : tooth_count - 1])
+        rotate(i * 360 / tooth_count)
+            if (pulley_type(type)[0] == "G")
+                translate([0, ir + GT_r])
+                    hull() {
+                        circle(GT_r);
+                        translate([0, GT_r])
+                            square(2 * GT_r, center = true);
+                    }
+            else
+                translate([0, (ir + or) / 2])
+                    hull() {
+                        for(side = [-1, 1])
+                            translate([side * tw / 2, 0])
+                                rotate(-side * T_angle / 2)
+                                    square([eps, (or - ir)], center = true);
+
+                        translate([0, 1])
+                            square([tw, eps], center = true);
+                    }
+}
+
+module printed_pulley(type) { //! Draw a printable pulley
+    ft = pulley_flange_thickness(type);
+    hl = pulley_hub_length(type);
+    w = pulley_width(type);
+    r1 = pulley_bore(type) / 2;
+    or = pulley_od(type) / 2;
+    screw_z = pulley_screw_z(type);
+
+
+    module core() {
+        translate_z(pulley_hub_length(type) + ft)
+            linear_extrude(w + 1) let($fa  = 1, $fs = 0.1)
+                if ("GT2" == str(pulley_type(type)[0], pulley_type(type)[1], pulley_type(type)[2]))
+                    difference() {
+                        printed_pulley_GT2_teeth(type);
+                        circle(d = pulley_bore(type));
+                    }
+                else
+                    difference() {
+                        circle(or);
+                        printed_pulley_teeth(type);
+                        circle(d = pulley_bore(type));
+                    }
+    }
+
+    module screw_holes() {
+        if(pulley_screws(type))
+            translate_z(screw_z)
+                for(i = [0 : pulley_screws(type) - 1])
+                    rotate([-90, 180, i * -90])
+                        if(show_supports())
+                            teardrop(r = screw_pilot_hole(pulley_screw(type)), h = pulley_flange_dia(type) / 2 + 1, center = false);
+                        else
+                            cylinder(r = screw_radius(pulley_screw(type)), h = pulley_flange_dia(type) / 2 + 1);
+    }
+
+    module hub()
+        linear_extrude(hl)
+            difference() {
+                circle(d= pulley_hub_dia(type));
+                circle(d = pulley_bore(type));
+            }
+
+    stl(str("printed_pulley_", type[0]))
+        translate_z(printed_pulley_inverted(type) ? - hl : 0) {
+            // hub
+            if(hl)
+                translate_z(printed_pulley_inverted(type) ? hl + w + 2 * ft : 0)
+                    if(screw_z && screw_z < hl)
+                        render()
+                            difference() {
+                                hub();
+
+                                screw_holes();
+                            }
+                    else
+                        hub();
+
+            // bottom flange
+            translate_z(hl)
+                linear_extrude(ft)
+                    difference() {
+                        circle(d = pulley_flange_dia(type));
+                        circle(d = pulley_bore(type));
+                    }
+
+            // top flange
+            translate_z(hl + ft + w) {
+                // inner part, supported by core
+                linear_extrude(ft)
+                    difference() {
+                        circle(r = or);
+                        circle(d = pulley_bore(type));
+                    }
+                // outer part at 45 degrees for printing
+                rotate_extrude()
+                    translate([or - eps, ft])
+                        vflip()
+                            right_triangle(ft, ft);
+            }
+
+            if(screw_z && screw_z > hl)
+                render()
+                    difference() { // T5 pulleys have screws through the teeth
+                        core();
+
+                        translate_z(printed_pulley_inverted(type) ? pulley_height(type) + hl - 2 * screw_z : 0)
+                            screw_holes();
+                    }
+                else
+                    core();
+        }
+}
+
+module printed_pulley_assembly(type, colour = pp1_colour) //! Draw a printed pulley with its grub screws in place
+assembly(str("printed_pulley_", type[0]), ngb = true) {
+    translate_z(pulley_offset(type)) {
+        stl_colour(colour)
+            if(printed_pulley_inverted(type))
+                translate_z(pulley_height(type))
+                    hflip()
+                        printed_pulley(type);
+            else
+                printed_pulley(type);
+
+        if(pulley_screws(type))
+            translate_z(pulley_screw_z(type))
+                for(i = [0 : pulley_screws(type) - 1])
+                    rotate([-90, 0, i * -90])
+                        translate_z(pulley_bore(type) / 2 + pulley_screw_length(type))
+                            screw(pulley_screw(type), pulley_screw_length(type));
+    }
+}

printed/psu_shroud.scad

@@ -41,6 +41,7 @@ overlap = 6;
 cable_tie_inset = wall + 4;
 
 function psu_shroud_extent(type) = 15 + wall;                                   //! How far it extends beyond the PSU to clear the connections
+function psu_shroud_wall(type) = wall;                                          //! The wall thickness
 function psu_shroud_depth(type) =                                               //! Outside depth of the shroud
     psu_left_bay(type) + overlap + psu_shroud_extent(type);
 
@@ -79,8 +80,6 @@ module psu_shroud_holes(type, cable_d, cables = 1) {
 }
 
 module psu_shroud(type, cable_d, name, cables = 1) { //! Generate the STL file for a specified ssr and cable
-    stl(str("psu_shroud_", name));
-
     extent = psu_shroud_extent(type);
     depth = psu_shroud_depth(type);
     width = psu_shroud_width(type);
@@ -109,41 +108,43 @@ module psu_shroud(type, cable_d, name, cables = 1) { //! Generate the STL file f
         }
     }
 
-    // base and sides
-    translate([centre_x, -centre_y]) {
-        rounded_rectangle([depth - eps, width - eps, top], rad, center = false);
+    stl(str("psu_shroud_", name)) {
+        // base and sides
+        translate([centre_x, -centre_y]) {
+            rounded_rectangle([depth - eps, width - eps, top], rad);
 
-        linear_extrude(height)
-            difference() {
+            linear_extrude(height)
+                difference() {
+                    shape();
+
+                    translate([depth / 2, width / 2 - 5])
+                        square([2 * (depth - extent + terminal_clearance), 10], center = true);
+            }
+            linear_extrude(height - terminal_block_height(tb) - psu_terminal_block_z(type) - terminal_clearance)
                 shape();
-
-                translate([depth / 2, width / 2 - 5])
-                    square([2 * (depth - extent + terminal_clearance), 10], center = true);
         }
-        linear_extrude(height - terminal_block_height(tb) - psu_terminal_block_z(type) - terminal_clearance)
-            shape();
-    }
-    // cable slots
-    for(i = [0 : 1 : cables - 1])
-        translate([centre_x - depth / 2 + wall / 2, -centre_y + (i - cables / 2 + 0.5) *  psu_shroud_cable_pitch(cable_d), height / 2])
-            rotate([90, 0, 90])
-                linear_extrude(wall, center = true)
-                    difference() {
-                        square([cable_d + eps, height], center = true);
+        // cable slots
+        for(i = [0 : 1 : cables - 1])
+            translate([centre_x - depth / 2 + wall / 2, -centre_y + (i - cables / 2 + 0.5) *  psu_shroud_cable_pitch(cable_d), height / 2])
+                rotate([90, 0, 90])
+                    linear_extrude(wall, center = true)
+                        difference() {
+                            square([cable_d + eps, height], center = true);
 
-                        translate([0, height / 2])
-                                vertical_tearslot(h = 0, r = cable_d / 2, l = cable_d);
-                }
-    // insert lugs
-    mirror([0, 1, 0])
-        psu_shroud_hole_positions(type)
-            translate_z(height)
-                rotate($side * 90)
-                    insert_lug(insert, wall, counter_bore);
- }
+                            translate([0, height / 2])
+                                    vertical_tearslot(h = 0, r = cable_d / 2, l = cable_d);
+                    }
+        // insert lugs
+        mirror([0, 1, 0])
+            psu_shroud_hole_positions(type)
+                translate_z(height)
+                    rotate($side * 90)
+                        insert_lug(insert, wall, counter_bore);
+     }
+}
 
 module psu_shroud_assembly(type, cable_d, name, cables = 1) //! The printed parts with inserts fitted
-assembly(str("PSU_shroud_", name)) {
+assembly(str("PSU_shroud_", name), ngb = true) {
 
     translate_z(psu_shroud_height(type))
         vflip()
@@ -154,10 +155,9 @@ assembly(str("PSU_shroud_", name)) {
             insert(insert);
 }
 
-module psu_shroud_fastened_assembly(type, cable_d, thickness, name, cables = 1) //! Assembly with screws in place
+module psu_shroud_fastened_assembly(type, cable_d, thickness, name, cables = 1, screw = screw) //! Assembly with screws in place
 {
-    washer = screw_washer(screw);
-    screw_length = screw_shorter_than(2 * washer_thickness(washer) + thickness + insert_length(insert) + counter_bore);
+    screw_length = screw_length(screw,thickness + counter_bore, 2, true);
 
     psu_shroud_assembly(type, cable_d, name, cables);
 

printed/ribbon_clamp.scad

@@ -24,69 +24,73 @@ include <../core.scad>
 use <../vitamins/insert.scad>
 use <../vitamins/cable_strip.scad>
 
-wall = 2;
+wall = 1.6;
 min_wall = 2 * extrusion_width;
 screw = M3_cap_screw;
-insert = screw_insert(screw);
-screw_depth = insert_length(insert) + 1;
 
-function ribbon_clamp_hole_pitch(ways) = ribbon_clamp_slot(ways) + 2 * min_wall + 2 * corrected_radius(insert_hole_radius(insert)); //! Hole pitch
-function ribbon_clamp_width() = 2 * (insert_hole_radius(insert) + 2); //! Width
-function ribbon_clamp_length(ways) = ribbon_clamp_hole_pitch(ways) + ribbon_clamp_width(); //! Length given ways
-function ribbon_clamp_height() = screw_depth + 1; //! Height
+function ribbon_clamp_screw_depth(screw = screw) = insert_length(screw_insert(screw)) + 1;
+function ribbon_clamp_hole_pitch(ways, screw = screw) =
+    ribbon_clamp_slot(ways) + 2 * min_wall + 2 * corrected_radius(insert_hole_radius(screw_insert(screw))); //! Hole pitch
 
-module ribbon_clamp_hole_positions(ways, side = undef) //! Place children at hole positions
+function ribbon_clamp_width(screw = screw) = 2 * (insert_hole_radius(screw_insert(screw)) + wall); //! Width
+function ribbon_clamp_length(ways, screw = screw) = ribbon_clamp_hole_pitch(ways, screw) + ribbon_clamp_width(screw); //! Length given ways
+function ribbon_clamp_height(screw = screw) = ribbon_clamp_screw_depth(screw) + 1; //! Height
+
+module ribbon_clamp_hole_positions(ways, screw = screw, side = undef) //! Place children at hole positions
     for(x = is_undef(side) ? [-1, 1] : side)
-        translate([x * ribbon_clamp_hole_pitch(ways) / 2, 0])
+        translate([x * ribbon_clamp_hole_pitch(ways, screw) / 2, 0])
             children();
 
-module ribbon_clamp_holes(ways, h = 20) //! Drill screw holes
-    ribbon_clamp_hole_positions(ways)
+module ribbon_clamp_holes(ways, h = 20, screw = screw) //! Drill screw holes
+    ribbon_clamp_hole_positions(ways, screw)
         drill(screw_clearance_radius(screw), h);
 
-module ribbon_clamp(ways) { //! Generate STL for given number of ways
-    stl(str("ribbon_clamp_", ways));
+module ribbon_clamp(ways, screw = screw) { //! Generate STL for given number of ways
+    screw_d = screw_radius(screw) * 2;
 
-    pitch = ribbon_clamp_hole_pitch(ways);
-    d = ribbon_clamp_width();
-    h = ribbon_clamp_height();
-    t = h - ribbon_clamp_slot_depth() - wall;
+    pitch = ribbon_clamp_hole_pitch(ways, screw);
+    d = ribbon_clamp_width(screw);
+    h = ribbon_clamp_height(screw);
+    t = round_to_layer(ribbon_clamp_slot_depth() + wall);
+    insert = screw_insert(screw);
 
-    difference() {
-        union() {
-            hull() {
-                translate_z(h - t / 2)
-                    cube([ribbon_clamp_hole_pitch(ways), d, t], center = true);
+    stl(str("ribbon_clamp_", ways, screw_d != 3 ? str("_", screw_d) : ""))
+        difference() {
+            union() {
+                hull() {
+                    translate_z(h - t / 2)
+                        cube([ribbon_clamp_hole_pitch(ways, screw), d, t], center = true);
 
-                translate_z(1)
-                    cube([pitch, max(wall, d - 2 * (h - t)), 2], center = true);
+                    translate_z(1)
+                        cube([pitch, max(wall, d - 2 * (h - t)), 2], center = true);
+                }
+                ribbon_clamp_hole_positions(ways, screw, -1)
+                    cylinder(d = d, h = h);
+
+                ribbon_clamp_hole_positions(ways, screw, 1)
+                    cylinder(d = d, h = h);
             }
-            ribbon_clamp_hole_positions(ways, -1)
-                cylinder(d = d, h = h);
 
-            ribbon_clamp_hole_positions(ways,  1)
-                cylinder(d = d, h = h);
-
-        }
-
-        translate_z(h)
-            cube([ribbon_clamp_slot(ways), d + 1, ribbon_clamp_slot_depth() * 2], center = true);
-
-        ribbon_clamp_hole_positions(ways)
             translate_z(h)
-                rotate(22.5)
-                    insert_hole(insert, screw_depth - insert_length(insert));
-    }
+                cube([ribbon_clamp_slot(ways), d + 1, ribbon_clamp_slot_depth() * 2], center = true);
+
+            ribbon_clamp_hole_positions(ways, screw)
+                translate_z(h)
+                    rotate(22.5)
+                        insert_hole(insert, ribbon_clamp_screw_depth(screw) - insert_length(insert));
+        }
 }
 
-module ribbon_clamp_assembly(ways) pose([55, 180, 25])  //! Printed part with inserts in place
-    assembly(str("ribbon_clamp_", ways)) {
-    h = ribbon_clamp_height();
+module ribbon_clamp_assembly(ways, screw = screw)  //! Printed part with inserts in place
+pose([55, 180, 25])
+assembly(let(screw_d = screw_radius(screw) * 2)str("ribbon_clamp_", ways, screw_d != 3 ? str("_", screw_d) : ""), ngb = true) {
+    h = ribbon_clamp_height(screw);
+    insert = screw_insert(screw);
 
     stl_colour(pp1_colour) render()
-        translate_z(h) vflip() ribbon_clamp(ways);
+        translate_z(h) vflip() ribbon_clamp(ways, screw);
 
-    ribbon_clamp_hole_positions(ways)
+    ribbon_clamp_hole_positions(ways, screw)
         vflip()
             insert(insert);
 }
@@ -98,21 +102,28 @@ module ribbon_clamp_fastened_assembly(ways, thickness, screw = screw) { //! Clam
 
     vitamin(str(": Tape self amalgamating silicone ",tape_l," x 25mm"));
 
-    washer = screw_washer(screw);
-    screw_length = screw_shorter_than(2 * washer_thickness(washer) + thickness + screw_depth);
+    screw_length = screw_length(screw, thickness + ribbon_clamp_screw_depth(screw), 2);
 
-    ribbon_clamp_assembly(ways);
+    ribbon_clamp_assembly(ways, screw);
 
     color("red") translate_z(tape_thickness / 2)
         cube([tape_l, tape_width, tape_thickness], center = true);
 
-    ribbon_clamp_hole_positions(ways)
+    ribbon_clamp_hole_positions(ways, screw)
         vflip()
            translate_z(thickness)
                 screw_and_washer(screw, screw_length, true);
 }
 
 module ribbon_clamp_20_stl() ribbon_clamp(20);
+module ribbon_clamp_8_2_stl() ribbon_clamp(8, M2_dome_screw);
+module ribbon_clamp_7_2_stl() ribbon_clamp(8, M2_dome_screw);
 
 //! * Place inserts into the holes and press home with a soldering iron with a conical bit heated to 200&deg;C.
 module ribbon_clamp_20_assembly() ribbon_clamp_assembly(20);
+
+//! * Place inserts into the holes and press home with a soldering iron with a conical bit heated to 200&deg;C.
+module ribbon_clamp_8_2_assembly() ribbon_clamp_assembly(8, M2_dome_screw);
+
+//! * Place inserts into the holes and press home with a soldering iron with a conical bit heated to 200&deg;C.
+module ribbon_clamp_7_2_assembly() ribbon_clamp_assembly(8, M2_dome_screw);

printed/screw_knob.scad

@@ -34,32 +34,31 @@ knob_height = knob_stem_h + knob_thickness;
 function knob_height() = knob_height;
 
 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;
 
     function wave(a) = knob_r + sin(a * knob_waves) * knob_wave;
 
-    union() {
-        render() difference() {
-            cylinder(r = knob_stem_r, h = knob_thickness + knob_stem_h);
+    stl(str("screw_knob_M", screw_radius(screw) * 20))
+        union() {
+            render() difference() {
+                cylinder(r = knob_stem_r, h = knob_thickness + knob_stem_h);
 
-            hanging_hole(knob_nut_trap_depth(screw), screw_clearance_radius(screw))
-                rotate(45)
-                    circle(r = nut_trap_radius(screw_nut(screw)), $fn = 6);
-        }
-        linear_extrude(knob_thickness, convexity = 3)
-            difference() {
-                polygon(points = [for(a = [0 : 359]) [wave(a) * sin(a), wave(a) * cos(a)]]);
-
-                circle(knob_stem_r - eps);
+                hanging_hole(knob_nut_trap_depth(screw), screw_clearance_radius(screw))
+                    rotate(45)
+                        circle(r = nut_trap_radius(screw_nut(screw)), $fn = 6);
             }
-    }
+            linear_extrude(knob_thickness, convexity = 3)
+                difference() {
+                    polygon(points = [for(a = [0 : 359]) [wave(a) * sin(a), wave(a) * cos(a)]]);
+
+                    circle(knob_stem_r - eps);
+                }
+        }
 }
 
 //! Place the screw through the printed part
 module screw_knob_assembly(screw, length) //! Assembly with the screw in place
-assembly(str("screw_knob_M", 20 * screw_radius(screw), "_", length)) {
+assembly(str("screw_knob_M", 20 * screw_radius(screw), "_", length), ngb = true) {
     translate_z(knob_height)
         vflip()
             stl_colour(pp1_colour) screw_knob(screw);

printed/socket_box.scad

@@ -41,7 +41,6 @@ height = base_thickness + box_height;
 function socket_box_depth() = height; //! Outside depth of the backbox
 
 module socket_box(type) { //! Generate STL of the backbox for the specified socket
-    stl(str("socket_box_",type[0]));
 
     screw = mains_socket_screw(type);
     screw_clearance_radius = screw_clearance_radius(screw);
@@ -51,37 +50,38 @@ module socket_box(type) { //! Generate STL of the backbox for the specified sock
     insert_boss = mains_socket_insert_boss(type);
     insert_hole_radius = insert_hole_radius(insert);
 
-    difference() {
-        linear_extrude(height, convexity = 5)
-            face_plate(type);
-
+    stl(str("socket_box_",type[0]))
         difference() {
-            translate_z(base_thickness)
-                linear_extrude(height, convexity = 5)
-                     offset(-wall) offset(1) face_plate(type);
+            linear_extrude(height, convexity = 5)
+                face_plate(type);
 
-            for(side = [-1, 1])
-                hull()
-                    for(x = [1, 2])
-                        translate([side * mains_socket_pitch(type) / x, 0])
-                            cylinder(d = insert_boss, h = 100);
-        }
-        //
-        // Socket holes
-        //
-        translate_z(height)
-            mains_socket_hole_positions(type) {
-                poly_cylinder(r = screw_clearance_radius, h = 2 * box_height, center = true);
+            difference() {
+                translate_z(base_thickness)
+                    linear_extrude(height, convexity = 5)
+                         offset(-wall) offset(1) face_plate(type);
 
-                poly_cylinder(r = insert_hole_radius, h = 2 * insert_length, center = true);
+                for(side = [-1, 1])
+                    hull()
+                        for(x = [1, 2])
+                            translate([side * mains_socket_pitch(type) / x, 0])
+                                cylinder(d = insert_boss, h = 100);
             }
-        //
-        // Cable hole
-        //
-        translate([cable_x, cable_y(type), cable_z])
-            rotate([90, 0, 0])
-                teardrop_plus(r = cable_d / 2, h = 30);
-    }
+            //
+            // Socket holes
+            //
+            translate_z(height)
+                mains_socket_hole_positions(type) {
+                    poly_cylinder(r = screw_clearance_radius, h = 2 * box_height, center = true);
+
+                    poly_cylinder(r = insert_hole_radius, h = 2 * insert_length, center = true);
+                }
+            //
+            // Cable hole
+            //
+            translate([cable_x, cable_y(type), cable_z])
+                rotate([90, 0, 0])
+                    teardrop_plus(r = cable_d / 2, h = 30);
+        }
 }
 
 module socket_box_MKLOGIC_stl() socket_box(MKLOGIC);
@@ -105,8 +105,7 @@ module socket_box_MKLOGIC_assembly() socket_box_assembly(MKLOGIC);
 
 module socket_box_fastened_assembly(type, thickness) { //! The socket and backbox on each side of the specified panel thickness
     screw = mains_socket_screw(type);
-    insert = screw_insert(screw);
-    screw_length = screw_longer_than(mains_socket_height(type) + thickness + insert_length(insert));
+    screw_length = screw_length(screw, mains_socket_height(type) + thickness, 0, true, longer = true);
 
     explode(-50)
         translate_z(-height - thickness)

printed/ssr_shroud.scad

@@ -61,53 +61,54 @@ module ssr_shroud_holes(type, cable_d) { //! Drill the screw and ziptie holes
 }
 
 module ssr_shroud(type, cable_d, name) {    //! Generate the STL file for a specified ssr and cable
-    stl(str("ssr_shroud_", name));
-
     width = ssr_shroud_width(type);
     depth = ssr_length(type) / 3 + ssr_shroud_extent(type, cable_d);
     height = ssr_shroud_height(type);
     cable_x = ssr_shroud_cable_x(type, cable_d);
     center_x = -ssr_length(type) / 6 - depth / 2;
 
-    // base and sides
-    translate([center_x, 0]) {
-        rounded_rectangle([depth - eps, width - eps, top], rad, center = false);
 
-        linear_extrude(height) difference() {
-            round(or = wall / 2 - eps, ir = 0) difference() {
-                rounded_square([depth, width], rad);
+    stl(str("ssr_shroud_", name)) {
+        // base and sides
+        translate([center_x, 0]) {
+            rounded_rectangle([depth - eps, width - eps, top], rad);
 
-                rounded_square([depth - 2 * wall, width - 2 * wall], rad - wall);
+            linear_extrude(height) difference() {
+                round(or = wall / 2 - eps, ir = 0) difference() {
+                    rounded_square([depth, width], rad);
 
-                translate([depth / 2, 0])
-                    square([2 * rad, width], center = true);
+                    rounded_square([depth - 2 * wall, width - 2 * wall], rad - wall);
 
+                    translate([depth / 2, 0])
+                        square([2 * rad, width], center = true);
+
+                }
+                translate([cable_x - center_x, 0])
+                    square([cable_d, width + 1], center = true);
             }
-            translate([cable_x - center_x, 0])
-                square([cable_d, width + 1], center = true);
         }
-    }
-    // cable slots
-    for(side = [-1, 1])
-        translate([cable_x, side * (width / 2 - wall / 2), height / 2])
-            rotate([90, 0, 0])
-                linear_extrude(wall, center = true)
-                    difference() {
-                        square([cable_d + eps, height], center = true);
+        // cable slots
+        for(side = [-1, 1])
+            translate([cable_x, side * (width / 2 - wall / 2), height / 2])
+                rotate([90, 0, 0])
+                    linear_extrude(wall, center = true)
+                        difference() {
+                            square([cable_d + eps, height], center = true);
 
-                        translate([0, height / 2])
-                            vertical_tearslot(h = 0, r = cable_d / 2, l = cable_d);
-                    }
-    // insert boss
-    ssr_shroud_hole_positions(type)
-        vflip()
-            translate_z(height)
-                rotate($side * 90)
-                    insert_lug(insert, wall, counter_bore);
+                            translate([0, height / 2])
+                                vertical_tearslot(h = 0, r = cable_d / 2, l = cable_d);
+                        }
+        // insert boss
+        ssr_shroud_hole_positions(type)
+            vflip()
+                translate_z(height)
+                    rotate($side * 90)
+                        insert_lug(insert, wall, counter_bore);
+    }
 }
 
 module ssr_shroud_assembly(type, cable_d, name) //! The printed parts with inserts fitted
-assembly(str("SSR_shroud_", name)) {
+assembly(str("SSR_shroud_", name), ngb = true) {
 
     translate_z(ssr_shroud_height(type))
         vflip()
@@ -119,8 +120,7 @@ assembly(str("SSR_shroud_", name)) {
 
 module ssr_shroud_fastened_assembly(type, cable_d, thickness, name) //! Assembly with screws in place
 {
-    washer = screw_washer(screw);
-    screw_length = screw_shorter_than(2 * washer_thickness(washer) + thickness + insert_length(insert) + counter_bore);
+    screw_length = screw_length(screw, thickness + counter_bore, 2, true);
 
     ssr_shroud_assembly(type, cable_d, name);
 
@@ -135,7 +135,7 @@ module ssr_shroud_fastened_assembly(type, cable_d, thickness, name) //! Assembly
 
             *translate_z(cable_d / 2)
                 rotate([90, 0, 0])
-                    stl_colour(grey20)
+                    stl_colour(grey(20))
                         cylinder(d = cable_d, h = 20, center = true);
         }
 }

printed/strap_handle.scad

@@ -24,8 +24,7 @@
 include <../core.scad>
 use <../vitamins/insert.scad>
 
-strap = [18, 2, M3_pan_screw, 3, 25];
-function strap() = strap;
+strap = strap();
 
 wall = 2;
 clearance = 0.5;
@@ -40,6 +39,10 @@ function strap_screw(type = strap)     = type[2]; //! Screw type
 function strap_panel(type = strap)     = type[3]; //! Panel thickness
 function strap_extension(type = strap) = type[4]; //! How much length of the strap that can pull out
 
+
+function strap(width = 18, thickness = 2, screw = M3_pan_screw, panel_thickness = 3, extension = 25) = //! Construct a property list for a strap
+ [ width, thickness, screw, panel_thickness, extension ];
+
 function strap_insert(type) = screw_insert(strap_screw(type)); //! The insert type
 function strap_key(type) = strap_panel(type) - panel_clearance;
 function strap_height(type) = wall + max(insert_length(strap_insert(type)) - strap_key(type), strap_thickness(type) + clearance); //! Height of the ends
@@ -72,32 +75,29 @@ module strap_holes(length, type = strap, h = 100) //! The panel cut outs
                     strap_boss_shape(type);
 
 module strap(length, type = strap) { //! Generate the STL for the rubber strap
-    stl("strap");
-
     len = length - 2 * (wall + clearance);
     w = strap_width(type);
 
-    linear_extrude(strap_thickness(type), convexity = 3)
-        difference() {
-            rounded_square([len, w], w / 2 - eps);
+    stl("strap")
+        linear_extrude(strap_thickness(type), convexity = 3)
+            difference() {
+                rounded_square([len, w], w / 2 - eps);
 
-            for(end = [-1, 1])
-                translate([end * (len / 2 - strap_min_width(type) - strap_boss_r(type) - clearance), 0])
-                    rotate(end * 90 + 90)
-                        hull() {
-                            offset(clearance)
-                                strap_boss_shape(type);
-
-                            translate([strap_extension(type) / 2, 0])
+                for(end = [-1, 1])
+                    translate([end * (len / 2 - strap_min_width(type) - strap_boss_r(type) - clearance), 0])
+                        rotate(end * 90 + 90)
+                            hull() {
                                 offset(clearance)
                                     strap_boss_shape(type);
-                        }
-        }
+
+                                translate([strap_extension(type) / 2, 0])
+                                    offset(clearance)
+                                        strap_boss_shape(type);
+                            }
+            }
 }
 
 module strap_end(type = strap) { //! Generate the STL for end piece
-    stl("strap_end");
-
     z1 = strap_height(type) - strap_thickness(type) - clearance;
     z2 = strap_height(type) + strap_key(type);
     r1 = strap_boss_r(type) - 1;
@@ -118,48 +118,49 @@ module strap_end(type = strap) { //! Generate the STL for end piece
             circle(r1);
         }
 
-    union() {
-        linear_extrude(z1)
-            with_hole()
-                outer();
-
-        translate_z(z1)
-            linear_extrude(strap_height(type) - z1)
-                difference() {
+    stl("strap_end")
+        union() {
+            linear_extrude(z1)
+                with_hole()
                     outer();
 
-                    hull() {
-                        translate([0, -strap_width(type) / 2 - clearance])
-                            square([strap_boss_r(type) + overlap, strap_width(type) + 2 * clearance]);
+            translate_z(z1)
+                linear_extrude(strap_height(type) - z1)
+                    difference() {
+                        outer();
 
-                        translate([-strap_extension(type) / 2, 0])
-                            circle(d = strap_width(type) + 2 * clearance);
+                        hull() {
+                            translate([0, -strap_width(type) / 2 - clearance])
+                                square([strap_boss_r(type) + overlap, strap_width(type) + 2 * clearance]);
+
+                            translate([-strap_extension(type) / 2, 0])
+                                circle(d = strap_width(type) + 2 * clearance);
+                        }
                     }
-                }
 
-        linear_extrude(strap_height(type) - layer_height)
-            with_hole()
-                strap_boss_shape(type);
+            linear_extrude(strap_height(type) - layer_height)
+                with_hole()
+                    strap_boss_shape(type);
 
-        linear_extrude(z2)
-            with_hole()
-                 offset(cnc_bit_r)
-                    offset(-step - cnc_bit_r)
-                        strap_boss_shape(type);
+            linear_extrude(z2)
+                with_hole()
+                     offset(cnc_bit_r)
+                        offset(-step - cnc_bit_r)
+                            strap_boss_shape(type);
 
-        render() difference() {
-            cylinder(r = r1 + eps, h = z2);
+            render() difference() {
+                cylinder(r = r1 + eps, h = z2);
 
-            translate_z(z2)
-                insert_hole(strap_insert(type), counterbore);
+                translate_z(z2)
+                    insert_hole(strap_insert(type), counterbore);
+            }
         }
-    }
 }
 //
 //! * Place the insert into the hole and push home with a soldering iron with a tapered bit heated to 200&deg;C.
 //
 module strap_end_assembly(type = strap)
-assembly("strap_end") {
+assembly("strap_end", ngb = true) {
     stl_colour(pp1_colour)
         strap_end(type);
 
@@ -169,11 +170,9 @@ assembly("strap_end") {
 
 module strap_assembly(length, type = strap) { //! Assembly with screws in place
     screw = strap_screw(type);
-    washer = screw_washer(screw);
-    penny = penny_washer(washer);
-    insert = strap_insert(type);
+    penny = penny_washer(screw_washer(screw));
 
-    screw_length = screw_shorter_than(washer_thickness(washer) + washer_thickness(penny) + insert_length(insert) + panel_clearance + counterbore);
+    screw_length = screw_length(screw, washer_thickness(penny) + panel_clearance + counterbore, 1, true);
 
     stl_colour(pp4_colour) strap(length, type);
 

scripts/blurb.py

@@ -39,8 +39,6 @@ def _scrape_blurb(lines):
         if b:
             break
         text += t
-    if len(text):
-        text += '\n'
     return text
 
 def scrape_blurb(scad_file):
@@ -49,6 +47,16 @@ def scrape_blurb(scad_file):
         lines = file.readlines()
     return _scrape_blurb(lines)
 
+def split_blurb(lines):
+    """ Split blurb on horizontal rules."""
+    blurbs = [""]
+    for line in lines.split('\n')[:-1]:
+        if re.match(r'\*{3,}',line):
+            blurbs.append("")
+        else:
+            blurbs[-1] += line + '\n'
+    return blurbs
+
 def scrape_module_blurb(lines):
     """ Find the Markup lines before the last function or module. """
     text = ""
@@ -73,7 +81,7 @@ def scrape_code(scad_file):
             match = re.match(r'^function (.*?\(.*?\)).*?(?://! ?(.*))$', line)
             if match:
                 functions[match.group(1)] = match.group(2)
-        match = re.match(r'^module (.*?\(.*?\)).*?(?://! ?(.*))$', line)
+        match = re.match(r'^module (.*?\(.*\)).*?(?://! ?(.*))$', line)
         if match:
             modules[match.group(1)] = match.group(2)
 

scripts/bom.py

@@ -31,6 +31,12 @@ from set_config import *
 import json
 import re
 
+try:
+    import parts
+    got_parts_py = True
+except:
+    got_parts_py = False
+
 def find_scad_file(mname):
     for filename in os.listdir(source_dir):
         if filename[-5:] == ".scad":
@@ -46,6 +52,18 @@ def find_scad_file(mname):
                             return filename
     return None
 
+def main_assembly(target):
+    file = None
+    if target:
+        assembly = target + "_assembly"
+        file = find_scad_file(assembly)
+    if not file:
+        assembly = "main_assembly"
+        file = find_scad_file(assembly)
+    if not file:
+        raise Exception("can't find source for " + assembly)
+    return assembly, file
+
 class Part:
     def __init__(self, args):
         self.count = 1
@@ -60,6 +78,8 @@ class BOM:
     def __init__(self, name):
         self.name = name
         self.big = None
+        self.ngb = False
+        self.zoomed = 0
         self.count = 1
         self.vitamins = {}
         self.printed = {}
@@ -73,6 +93,8 @@ class BOM:
         return {
              "name"       : self.name,
              "big"        : self.big,
+             "ngb"        : self.ngb,
+             "zoomed"     : self.zoomed,
              "count"      : self.count,
              "assemblies" : assemblies,
              "vitamins"   : {v : self.vitamins[v].data() for v in self.vitamins},
@@ -113,6 +135,33 @@ class BOM:
             return ass
         return ass.replace("assembly", "assemblies")
 
+    def print_CSV(self,  file = None):
+        i = 0
+        for part in sorted(self.vitamins):
+            i += 1
+            if ': ' in part:
+                part_no, description = part.split(': ')
+            else:
+                part_no, description = "", part
+            qty = self.vitamins[part].count
+            if got_parts_py:
+                match = re.match(r'^.*\((.*?)[,\)].*$', part_no)
+                if match and not match.group(1).startswith('"'):
+                    part_no = part_no.replace('(' + match.group(1), '_' + match.group(1) + '(').replace('(, ', '(')
+                func = 'parts.' + part_no.replace('(', '(%d, ' % qty).replace(', )', ')')
+                func = func.replace('true',  'True').replace('false', 'False').replace('undef', 'None')
+                try:
+                    price, url = eval(func)
+                    print("'%s',%3d,%.2f,'=B%d*C%d',%s" % (description, qty, price, i, i, url), file=file)
+                except:
+                    if part_no:
+                        print("%s not found in parts.py" % func)
+                    print("'%s',%3d" % (description, qty), file=file)
+            else:
+                print("'%s',%3d" % (description, qty), file=file)
+        if got_parts_py:
+            print(",'=SUM(B1:B%d)',,'=SUM(D1:D%d)'" %(i, i), file=file)
+
     def print_bom(self, breakdown, file = None):
         if self.vitamins:
             print("Vitamins:", file=file)
@@ -217,28 +266,20 @@ def parse_bom(file = "openscad.log", name = None):
     return main
 
 def usage():
-    print("\nusage:\n\tbom [target_config] [<accessory_name>_assembly] - Generate BOMs for a project or an accessory to a project.")
+    print("\nusage:\n\tbom [target_config] - Generate BOMs for a project.")
     sys.exit(1)
 
-def boms(target = None, assembly = None):
+def boms(target = None):
     try:
         bom_dir = set_config(target, usage) + "bom"
-        if assembly:
-            bom_dir += "/accessories"
-            if not os.path.isdir(bom_dir):
-                os.makedirs(bom_dir)
-        else:
-            assembly = "main_assembly"
-            if os.path.isdir(bom_dir):
-                shutil.rmtree(bom_dir)
-                sleep(0.1)
-            os.makedirs(bom_dir)
+        if os.path.isdir(bom_dir):
+            shutil.rmtree(bom_dir)
+            sleep(0.1)
+        os.makedirs(bom_dir)
         #
-        # Find the scad file that makes the module
+        # Find the scad file that makes the main assembly
         #
-        scad_file = find_scad_file(assembly)
-        if not scad_file:
-            raise Exception("can't find source for " + assembly)
+        assembly, scad_file = main_assembly(target)
         #
         # make a file to use the module
         #
@@ -249,14 +290,15 @@ def boms(target = None, assembly = None):
         #
         # Run openscad
         #
-        openscad.run("-D", "$bom=2", "-D", "$preview=true", "--hardwarnings", "-o", "openscad.echo", "-d", bom_dir + "/bom.deps", bom_maker_name)
+        openscad.run("-D", "$bom=2", "-D", "$preview=true", "-o", "openscad.echo", "-d", bom_dir + "/bom.deps", bom_maker_name)
         os.remove(bom_maker_name)
         print("Generating bom ...", end=" ")
 
         main = parse_bom("openscad.echo", assembly)
 
-        if assembly == "main_assembly":
-            main.print_bom(True, open(bom_dir + "/bom.txt","wt"))
+        main.print_bom(True, open(bom_dir + "/bom.txt","wt"))
+
+        main.print_CSV(open(bom_dir + "/bom.csv","wt"))
 
         for ass in main.assemblies:
             with open(bom_dir + "/" + ass + ".txt", "wt") as f:
@@ -274,20 +316,8 @@ def boms(target = None, assembly = None):
         sys.exit(1)
 
 if __name__ == '__main__':
-    if len(sys.argv) > 3: usage()
+    if len(sys.argv) > 2: usage()
 
-    if len(sys.argv) == 3:
-        target, assembly = sys.argv[1], sys.argv[2]
-    else:
-        if len(sys.argv) == 2:
-            if sys.argv[1][-9:] == "_assembly":
-                target, assembly = None, sys.argv[1]
-            else:
-                target, assembly = sys.argv[1], None
-        else:
-            target, assembly = None, None
+    target = sys.argv[1] if len(sys.argv) == 2 else None
 
-    if assembly:
-        if assembly[-9:] != "_assembly": usage()
-
-    boms(target, assembly)
+    boms(target)

scripts/changelog.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python
+
+#
+# NopSCADlib Copyright Chris Palmer 2021
+# 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/>.
+#
+#! Creates the changelog from the git log
+
+from __future__ import print_function
+import sys
+import subprocess
+import re
+from tests import do_cmd
+
+filename = 'CHANGELOG.md'
+
+def tag_version(t):
+    """ Format a version tag """
+    return 'v%d.%d.%d' % t
+
+def initials(name):
+    """ Convert full name to initials with a tooltip """
+    i = ''.join([n[0].upper() + '.' for n in name.split(' ')])
+    return '[%s](# "%s")' % (i, name)
+
+def get_remote_url():
+    """ Get the git remote URL for the repository """
+    url = subprocess.check_output(["git", "config", "--get", "remote.origin.url"]).decode("utf-8").strip("\n")
+    if url.startswith("git@"):
+        url = url.replace(":", "/", 1).replace("git@", "https://", 1)
+    if url.endswith(".git"):
+        url = url[:-4]
+    return url
+
+def iscode(word):
+    """ try to guess if the word is code """
+    endings = ['()', '*']
+    starts = ['$', '--']
+    anywhere = ['.', '_', '=', '[', '/']
+    words = ['center', 'false', 'true', 'ngb']
+
+    for w in words:
+        if word == w:
+            return True
+
+    for end in endings:
+        if word.endswith(end):
+            return True
+
+    for start in starts:
+        if word.startswith(start):
+            return True
+
+    for any in anywhere:
+        if word.find(any) >= 0:
+            return True
+
+    return False
+
+def codify(word, url):
+    """ if a word is deemed code enclose it backticks """
+    if word:
+        if re.match(r'#[0-9]+', word):
+            return '[%s](%s "show issue")' % (word, url + '/issues/' + word[1:])
+        if iscode(word):
+            return  '`' + word + '`'
+    return word
+
+
+def fixup_comment(comment, url):
+    comment = comment.replace('cnc_bit+_r', 'cnc_bit_r')
+    """ markup code words and fix new paragraphs """
+    result = ''
+    word = ''
+    code = False
+    for i, c in enumerate(comment):
+        if c == '`' or code:                # Already a code block
+            result += c                     # Copy verbatim
+            if c == '`': code = not code    # Keep track of state
+        else:
+            if c in ' \n' or (c == '.' and (i + 1 == len(comment) or comment[i + 1] in ' \n')): # if a word terminator
+                result += codify(word, url) + c  # Add codified word before terminator
+                word = ''
+            else:
+                word += c                   # Accumulate next word
+    result += codify(word, url)             # In case comment ends without a terminator
+    return result.replace('\n\n','\n\n * ') # Give new paragraphs a bullet point
+
+class Commit(): # members dynamically added from commit_fields
+    pass
+
+blurb = """
+# %s Changelog
+This changelog is generated by `changelog.py` using manually added semantic version tags to classify commits as breaking changes, additions or fixes.
+
+"""
+
+if __name__ == '__main__':
+    url = get_remote_url()
+
+    commit_fields = {
+        'hash':    "%H|",       # commit commit_hash
+        'tag':     "%D|",       # tag
+        'author': "%aN|",       # author name
+        'date': "  %as|",       # author date short form
+        'comment': "%B~"        # body
+    }
+
+    # Produce the git log
+    format = ''.join([v for k, v in commit_fields.items()])
+    text = subprocess.check_output(["git", "log", "--topo-order", "--format=" + format]).decode("utf-8")
+
+    # Process the log into a list of Commit objects
+    commits = []
+    for line in text.split('~'):
+        line = line.strip('\n')
+        if line:
+            fields = line.split('|')
+            commit = Commit()
+            for i, k in enumerate(commit_fields):
+                exec('commit.%s = """%s"""' % (k, fields[i]), locals())
+            # Convert version tag to tuple
+            if commit.tag:
+                match = re.match(r'.*tag: v([0-9]+)\.([0-9]+)\.([0-9]+).*', commit.tag)
+                commit.tag = (int(match.group(1)), int(match.group(2)), int(match.group(3))) if match else ''
+            commits.append(commit)
+
+    # Format the results from the Commit objects
+    with open(filename, "wt") as file:
+        print(blurb % url.split('/')[-1], file = file)
+        for i, c in enumerate(commits):
+            if c.tag:
+                ver = tag_version(c.tag)
+                level, type = (3, 'Fixes') if c.tag[2] else (2, 'Additions') if c.tag[1] else (1, 'Breaking Changes') if c.tag[0] else (1, 'First publicised version')
+
+                # Find the previous tagged commit
+                j = i + 1
+                diff = ''
+                while j < len(commits):
+                    if commits[j].tag:
+                        last_ver = tag_version(commits[j].tag)
+                        diff = '[...](%s "diff with %s")' % (url + '/compare/' + last_ver + '...' + ver, last_ver)
+                        break
+                    j += 1
+
+                # Print verson info
+                print('%s [%s](%s "show release") %s %s' % ('#' * (level + 1), ver, url + '/releases/tag/' + ver, type, diff), file = file)
+
+            # Print commits excluding merges
+
+            if not c.comment.startswith('Merge branch') and not c.comment.startswith('Merge pull') and not re.match(r'U..ated chang.*log.*', c.comment):
+                print('* %s [`%s`](%s "show commit") %s %s\n' % (c.date, c.hash[:7], url + '/commit/' + c.hash, initials(c.author), fixup_comment(c.comment, url)), file = file)
+    do_cmd(('codespell -w -L od ' + filename).split())

scripts/deps.py

@@ -18,6 +18,7 @@
 #
 import os
 from set_config import source_dir
+from colorama import Fore
 
 def mtime(file):
     if os.path.isfile(file):
@@ -41,13 +42,13 @@ def read_deps(dname):
 def check_deps(target, dname):
     target_mtime = mtime(target)
     if not target_mtime:
-        return target + " missing"
+        return Fore.CYAN + target + " missing" + Fore.WHITE
     if not os.path.isfile(dname):
-        return "no deps"
+        return Fore.CYAN + "no deps" + Fore.WHITE
     deps = read_deps(dname)
     for dep in deps:
         if mtime(dep) > target_mtime:
-            return dep + ' changed'
+            return Fore.CYAN + dep + ' changed' + Fore.WHITE
     return None
 
 def source_dirs(bom_dir):

scripts/doc_scripts.py

@@ -36,7 +36,7 @@ def doc_scripts():
         print(
 '''
 # Python scripts
-These are located in the ```scripts``` subdirectory, which needs to be added to the program search path.
+These are located in the `scripts` subdirectory, which needs to be added to the program search path.
 
 They should work with both Python 2 and Python 3.
 
@@ -60,7 +60,8 @@ They should work with both Python 2 and Python 3.
                         break
                 if not blurb:
                     print("Missing description for", file)
-                print("| ```%s``` | %s |" % (file, blurb), file = doc_file)
+                else:
+                    print("| `%s` | %s |" % (file, blurb), file = doc_file)
 
     with open(dir + "/readme.html", "wt") as html_file:
         do_cmd(("python -m markdown -x tables " + doc_name).split(), html_file)

scripts/exports.py

@@ -28,7 +28,10 @@ from set_config import *
 import time
 import times
 from deps import *
+from tmpdir import *
 import json
+import shutil
+from colorama import Fore, init
 
 def bom_to_parts(bom_dir, part_type, assembly = None):
     #
@@ -43,7 +46,7 @@ def bom_to_parts(bom_dir, part_type, assembly = None):
             if words:
                 last_word = words[-1]
                 if last_word.endswith(suffix):
-                   part_files.append(last_word[:-4] + '.' + part_type)
+                    part_files.append(last_word[:-4] + '.' + part_type)
     return part_files
 
 def usage(t):
@@ -62,20 +65,29 @@ def make_parts(target, part_type, parts = None):
     #
     top_dir = set_config(target, lambda: usage(part_type))
     target_dir = top_dir + part_type + 's'
-    deps_dir = top_dir + "deps"
+    deps_dir = target_dir + "/deps"
     bom_dir = top_dir + "bom"
+    tmp_dir = mktmpdir(top_dir)
+
     if not os.path.isdir(target_dir):
         os.makedirs(target_dir)
+
     if not os.path.isdir(deps_dir):
         os.makedirs(deps_dir)
+
+    old_deps = top_dir + 'deps'  #old location
+    if os.path.isdir(old_deps):
+         shutil.rmtree(old_deps)
+
     times.read_times(target_dir)
     #
     # Decide which files to make
     #
+    all_parts = bom_to_parts(bom_dir, part_type)
     if parts:
         targets = list(parts)           #copy the list so we dont modify the list passed in
     else:
-        targets = bom_to_parts(bom_dir, part_type)
+        targets = list(all_parts)
         for file in os.listdir(target_dir):
             if file.endswith('.' + part_type):
                 if not file in targets:
@@ -119,18 +131,19 @@ def make_parts(target, part_type, parts = None):
                                         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"
+                                            changed = Fore.CYAN + "No bounds" + Fore.WHITE
                                         if changed:
                                             print(changed)
                                             #
                                             # make a file to use the module
                                             #
-                                            part_maker_name = part_type + ".scad"
+                                            part_maker_name = tmp_dir + '/' + part_type + ".scad"
                                             with open(part_maker_name, "w") as f:
-                                                f.write("use <%s/%s>\n" % (dir, filename))
+                                                f.write("include <NopSCADlib/global_defs.scad>\n")
+                                                f.write("use <%s/%s>\n" % (reltmp(dir, target), filename))
                                                 f.write("%s();\n" % module);
                                             t = time.time()
-                                            openscad.run("-D$bom=1", "-d", dname, "-o", part_file, part_maker_name)
+                                            openscad.run("-o", part_file, part_maker_name, "-D$bom=1", "-d", dname)
                                             times.add_time(part, t)
                                             if part_type == 'stl':
                                                 bounds = c14n_stl.canonicalise(part_file)
@@ -144,10 +157,14 @@ def make_parts(target, part_type, parts = None):
         with open(bounds_fname, 'w') as outfile:
             json.dump(bounds_map, outfile, indent = 4)
     #
+    # Remove tmp dir
+    #
+    rmtmpdir(tmp_dir)
+    #
     # List the ones we didn't find
     #
     if targets:
         for part in targets:
             print("Could not find a module called", part[:-4] + module_suffix, "to make", part)
         usage(part_type)
-    times.print_times()
+    times.print_times(all_parts)

scripts/gallery.py

@@ -52,7 +52,7 @@ def gallery(force):
             if os.path.isfile(document):
                 with open(document, 'rt') as readme:
                     for line in readme.readlines():
-                        match = re.match(r"^.*!(\[.*\]\(.*\)).*$", line)
+                        match = re.search(r"!(\[.*\]\(.*\))", line)
                         if match:
                             image = match.group(0)
                             if image.startswith('![Main Assembly](assemblies/'):
@@ -68,9 +68,10 @@ def gallery(force):
                             match = re.match(r"^(#+).*$", line)
                             if match:
                                 line = '#' + line
-                        if line == '---\n':
-                            break;
-                        print(line[:-1], file = output_file)
+                        if line == '---\n' or line == '<span></span>\n':
+                            break
+                        if line != '<a name="TOP"></a>\n':
+                            print(line[:-1], file = output_file)
             else:
                 print(Fore.MAGENTA + "Can't find", document, Fore.WHITE);
     with open(target_dir + "/readme.html", "wt") as html_file:

scripts/make_all.py

@@ -18,7 +18,7 @@
 # You should have received a copy of the GNU General Public License along with NopSCADlib.
 # If not, see <https://www.gnu.org/licenses/>.
 #
-#! Generates all the files for a project by running ```bom.py```, ```stls.py```, ```dxfs.py```, ```render.py``` and ```views.py```.
+#! Generates all the files for a project by running `bom.py`, `stls.py`, `dxfs.py`, `render.py` and `views.py`.
 
 import sys
 

scripts/openscad.py

@@ -18,28 +18,37 @@
 #
 
 #
-# Run openscad
+#! Run `openscad.exe` and capture `stdout` and `stderr` in `openscad.log` as well as printing to the console.
 #
 from __future__ import print_function
 
 import subprocess, sys
 
-def run_list(args, silent = False):
-    cmd = ["openscad"] + args
+def run_list(args, silent = False, verbose = False):
+    cmd = ["openscad"] + args + ["--hardwarnings"]
     if not silent:
         for arg in cmd:
             print(arg, end=" ")
         print()
     with open("openscad.log", "w") as log:
         rc = subprocess.call(cmd, stdout = log, stderr = log)
-    for line in open("openscad.log", "rt"):
-        if 'ERROR:' in line or 'WARNING:' in line:
+    log_file = "openscad.echo" if "openscad.echo" in cmd else "openscad.log"
+    bad = False
+    for line in open(log_file, "rt"):
+        if verbose or 'ERROR:' in line or 'WARNING:' in line:
+            bad = True
             print(line[:-1])
     if rc:
         sys.exit(rc)
 
+    if bad:
+        sys.exit(1)
+
 def run(*args):
     run_list(list(args), False)
 
 def run_silent(*args):
     run_list(list(args), True);
+
+if __name__ == '__main__':
+    run_list(sys.argv[1:], True, True)

scripts/options.py

@@ -17,9 +17,10 @@
 # If not, see <https://www.gnu.org/licenses/>.
 #
 
-# Set command line options from enviroment variables and check if they have changed
+# Set command line options from environment variables and check if they have changed
 
 import json, os, deps
+from colorama import Fore, init
 
 def check_options(dir = '.'):
     global options, options_mtime
@@ -37,7 +38,7 @@ def check_options(dir = '.'):
 
 def have_changed(changed, target):
     if not changed and deps.mtime(target) < options_mtime:
-        return "command line options changed"
+        return Fore.CYAN + "command line options changed" + Fore.WHITE
     return changed
 
 def list():

scripts/panels.py

@@ -18,7 +18,7 @@
 # You should have received a copy of the GNU General Public License along with NopSCADlib.
 # If not, see <https://www.gnu.org/licenses/>.
 #
-#! Panelises DXF files so they can be routed together by running scad files found in the ```panels``` directory.
+#! Panelises DXF files so they can be routed together by running scad files found in the `panels` directory.
 
 from __future__ import print_function
 import sys

scripts/plateup.py

@@ -26,7 +26,10 @@ import sys
 import c14n_stl
 from set_config import *
 from deps import *
-from shutil import copyfile
+import shutil
+import re
+import time
+import times
 
 source_dirs = { "stl" : "platters", "dxf" : "panels" }
 target_dirs = { "stl" : "printed",  "dxf" : "routed" }
@@ -38,61 +41,107 @@ def plateup(target, part_type, usage = None):
     top_dir = set_config(target, usage)
     parts_dir = top_dir + part_type + 's'
     target_dir = parts_dir + '/' + target_dirs[part_type]
-    source_dir = top_dir + source_dirs[part_type]
-    deps_dir = source_dir + "/deps"
-    if not os.path.isdir(source_dir):
-        return
-    if not os.path.isdir(target_dir):
-        os.makedirs(target_dir)
-    if not os.path.isdir(deps_dir):
-        os.makedirs(deps_dir)
+    source_dir1 = source_dirs[part_type]
+    source_dir2 = top_dir + source_dirs[part_type]
+
     #
-    # Decide which files to make
+    # Loop through source directories
     #
-    sources = [file for file in os.listdir(source_dir) if file.endswith('.scad')]
-    #
-    # Run OpenSCAD on the source files to make the targets
-    #
-    used = []
-    for src in sources:
-        src_file = source_dir + '/' + src
-        part_file = target_dir + '/' + src[:-4] + part_type
-        dname = deps_name(deps_dir, src)
-        changed = check_deps(part_file, dname)
-        if changed:
-            print(changed)
-            openscad.run("-D$bom=1", "-d", dname, "-o", part_file, src_file)
-            if part_type == 'stl':
-                c14n_stl.canonicalise(part_file)
-            log_name = 'openscad.log'
-        else:
-            log_name = 'openscad.echo'
-            openscad.run_silent("-D$bom=1", "-o", log_name, src_file)
+    all_used = []
+    all_sources = []
+    all_parts = []
+    read_times = False
+    for dir in [source_dir1, source_dir2]:
+        if not os.path.isdir(dir):
+            continue
+        if not os.path.isdir(target_dir):
+            os.makedirs(target_dir)
+
+        if not read_times:
+            times.read_times(target_dir)
+            read_times = True
         #
-        # Add the files on the BOM to the used list
+        # Make the deps dir
         #
-        with open(log_name) as file:
-            for line in file.readlines():
-                if line.startswith('ECHO: "~') and line.endswith('.' + part_type + '"\n'):
-                    used.append(line[8:-2])
-    #
-    # Copy file that are not included
-    #
+        deps_dir = parts_dir + "/deps"
+        if not os.path.isdir(deps_dir):
+            os.makedirs(deps_dir)
+
+        if os.path.isdir(dir + '/deps'): #old deps
+            shutil.rmtree(dir + '/deps')
+        #
+        # Decide which files to make
+        #
+        sources = [file for file in os.listdir(dir) if file.endswith('.scad')]
+        all_sources += sources
+        #
+        # Run OpenSCAD on the source files to make the targets
+        #
+        target_def = ['-D$target="%s"' % target] if target else []
+        cwd_def = ['-D$cwd="%s"' % os.getcwd().replace('\\', '/')]
+        for src in sources:
+            src_file = dir + '/' + src
+            part =  src[:-4] + part_type
+            all_parts.append(part)
+            part_file = target_dir + '/' + part
+            uses_file = deps_dir + '/' + src[:-4] + 'txt'
+            dname = deps_name(deps_dir, src)
+            oldest = part_file if mtime(part_file) < mtime(uses_file) else uses_file
+            changed = check_deps(oldest, dname)
+            used = []
+            if changed:
+                print(changed)
+                t = time.time()
+                openscad.run_list(["-D$bom=1"] + target_def + cwd_def + ["-d", dname, "-o", part_file, src_file])
+                if part_type == 'stl':
+                    c14n_stl.canonicalise(part_file)
+                times.add_time(part, t)
+                log_name = 'openscad.log'
+                #
+                # Add the files on the BOM to the used list
+                #
+                with open(log_name) as file:
+                    for line in file.readlines():
+                        match = re.match(r'^ECHO: "~(.*?\.' + part_type + r').*"$', line)
+                        if match:
+                            used.append(match.group(1))
+                with open(uses_file, "wt") as file:
+                    for part in used:
+                        print(part, file = file)
+            else:
+                with open(uses_file, "rt") as file:
+                    for line in file:
+                        used.append(line[:-1])
+            all_used += used
+
     copied = []
-    for file in os.listdir(parts_dir):
-        if file.endswith('.' + part_type) and not file in used:
-            src = parts_dir + '/' + file
-            dst = target_dir + '/' + file
-            if mtime(src) > mtime(dst):
-                print("Copying %s to %s" % (src, dst))
-                copyfile(src, dst)
-            copied.append(file)
-    #
-    # Remove any cruft
-    #
-    targets = [file[:-4] + part_type for file in sources]
-    for file in os.listdir(target_dir):
-        if file.endswith('.' + part_type):
-            if not file in targets and not file in copied:
-                print("Removing %s" % file)
-                os.remove(target_dir + '/' + file)
+    if all_sources:
+        #
+        # Copy files that are not included
+        #
+        for file in os.listdir(parts_dir):
+            if file.endswith('.' + part_type) and not file in all_used:
+                src = parts_dir + '/' + file
+                dst = target_dir + '/' + file
+                if mtime(src) > mtime(dst):
+                    print("Copying %s to %s" % (src, dst))
+                    shutil.copyfile(src, dst)
+                copied.append(file)
+        #
+        # Remove any cruft
+        #
+        targets = [file[:-4] + part_type for file in all_sources]
+        for file in os.listdir(target_dir):
+            if file.endswith('.' + part_type):
+                if not file in targets and not file in copied:
+                    print("Removing %s" % file)
+                    os.remove(target_dir + '/' + file)
+
+        targets = [file[:-4] + 'txt' for file in all_sources]
+        for file in os.listdir(deps_dir):
+            if file.endswith('.' + 'txt'):
+                if not file in targets:
+                    print("Removing %s" % file)
+                    os.remove(deps_dir + '/' + file)
+
+        times.print_times(all_parts)

scripts/platters.py

@@ -18,7 +18,7 @@
 # You should have received a copy of the GNU General Public License along with NopSCADlib.
 # If not, see <https://www.gnu.org/licenses/>.
 #
-#! Generates build plates of STL files for efficient printing by running scad files found in the ```platters``` directory.
+#! Generates build plates of STL files for efficient printing by running scad files found in the `platters` directory.
 
 from __future__ import print_function
 import sys

scripts/readme.md

@@ -1,22 +1,24 @@
 
 # Python scripts
-These are located in the ```scripts``` subdirectory, which needs to be added to the program search path.
+These are located in the `scripts` subdirectory, which needs to be added to the program search path.
 
 They should work with both Python 2 and Python 3.
 
 | Script  | Function  |
 |:---|:---|
-| ```bom.py``` | Generates BOM files for the project. |
-| ```c14n_stl.py``` | OpenSCAD produces randomly ordered STL files. This script re-orders them consistently so that GIT can tell if they have changed or not. |
-| ```doc_scripts.py``` | Makes this document and doc/usage.md. |
-| ```dxfs.py``` | Generates DXF files for all the routed parts listed on the BOM or a specified list. |
-| ```gallery.py``` | Finds projects and adds them to the gallery. |
-| ```make_all.py``` | Generates all the files for a project by running ```bom.py```, ```stls.py```, ```dxfs.py```, ```render.py``` and ```views.py```. |
-| ```panels.py``` | Panelises DXF files so they can be routed together by running scad files found in the ```panels``` directory. |
-| ```platters.py``` | Generates build plates of STL files for efficient printing by running scad files found in the ```platters``` directory. |
-| ```render.py``` | Renders STL and DXF files to PNG for inclusion in the build instructions. |
-| ```set_config.py``` | Sets the target configuration for multi-target projects that have variable configurations. |
-| ```stls.py``` | Generates STL files for all the printed parts listed on the BOM or a specified list. |
-| ```svgs.py``` | Generates SVG files for all the routed parts listed on the BOM or a specified list. |
-| ```tests.py``` | Runs all the tests in the tests directory and makes the readme file with a catalog of the results. |
-| ```views.py``` | Generates exploded and unexploded assembly views and scrapes build instructions to make readme.md, readme.html and printme.html files for the project. |
+| `bom.py` | Generates BOM files for the project. |
+| `c14n_stl.py` | OpenSCAD produces randomly ordered STL files. This script re-orders them consistently so that GIT can tell if they have changed or not. |
+| `changelog.py` | Creates the changelog from the git log |
+| `doc_scripts.py` | Makes this document and doc/usage.md. |
+| `dxfs.py` | Generates DXF files for all the routed parts listed on the BOM or a specified list. |
+| `gallery.py` | Finds projects and adds them to the gallery. |
+| `make_all.py` | Generates all the files for a project by running `bom.py`, `stls.py`, `dxfs.py`, `render.py` and `views.py`. |
+| `openscad.py` | Run `openscad.exe` and capture `stdout` and `stderr` in `openscad.log` as well as printing to the console. |
+| `panels.py` | Panelises DXF files so they can be routed together by running scad files found in the `panels` directory. |
+| `platters.py` | Generates build plates of STL files for efficient printing by running scad files found in the `platters` directory. |
+| `render.py` | Renders STL and DXF files to PNG for inclusion in the build instructions. |
+| `set_config.py` | Sets the target configuration for multi-target projects that have variable configurations. |
+| `stls.py` | Generates STL files for all the printed parts listed on the BOM or a specified list. |
+| `svgs.py` | Generates SVG files for all the routed parts listed on the BOM or a specified list. |
+| `tests.py` | Runs all the tests in the tests directory and makes the readme file with a catalog of the results. |
+| `views.py` | Generates exploded and unexploded assembly views and scrapes build instructions to make readme.md, readme.html and printme.html files for the project. |

scripts/render.py

@@ -30,6 +30,7 @@ from tests import do_cmd, update_image, colour_scheme, background
 from deps import mtime
 from colorama import init
 import json
+from tmpdir import *
 
 def usage():
     print("\nusage:\n\trender [target_config] - Render images of the stl and dxf files.");
@@ -40,6 +41,7 @@ def render(target, type):
     # Make the target directory
     #
     top_dir = set_config(target, usage)
+    tmp_dir = mktmpdir(top_dir)
     target_dir = top_dir + type + 's'
     bom_dir = top_dir + 'bom'
     if not os.path.isdir(target_dir):
@@ -80,7 +82,7 @@ def render(target, type):
         # make a file to import the stl
         #
         if mtime(part_file) > mtime(png_name):
-            png_maker_name = "png.scad"
+            png_maker_name = tmp_dir + "/png.scad"
             pp1 = [0, 146/255, 0]
             colour = pp1
             if part in colours:
@@ -88,15 +90,21 @@ def render(target, type):
                 if not '[' in colour:
                     colour = '"' + colour + '"'
             with open(png_maker_name, "w") as f:
-                f.write('color(%s) import("%s");\n' % (colour, part_file))
+                f.write('color(%s) import("%s");\n' % (colour, reltmp(part_file, target)))
             cam = "--camera=0,0,0,70,0,315,500" if type == 'stl' else "--camera=0,0,0,0,0,0,500"
             render = "--preview" if type == 'stl' or colour != pp1 else "--render"
-            tmp_name = 'tmp.png'
-            openscad.run(colour_scheme, "--projection=p", "--imgsize=4096,4096", cam, render, "--autocenter", "--viewall", "-o", tmp_name, png_maker_name);
+            tmp_name = tmp_dir + '/' + part[:-4] + '.png'
+            dummy_deps_name = tmp_dir + '/tmp.deps' # work around for OpenSCAD issue #3879
+            openscad.run("-o", tmp_name, png_maker_name, colour_scheme, "--projection=p", "--imgsize=4096,4096", cam, render, "--autocenter", "--viewall", "-d", dummy_deps_name)
             do_cmd(("magick "+ tmp_name + " -trim -resize 280x280 -background %s -gravity Center -extent 280x280 -bordercolor %s -border 10 %s"
                     % (background, background, tmp_name)).split())
             update_image(tmp_name, png_name)
             os.remove(png_maker_name)
+            os.remove(dummy_deps_name)
+    #
+    # Remove tmp dir
+    #
+    rmtmpdir(tmp_dir)
 
 if __name__ == '__main__':
     init()

scripts/set_config.py

@@ -69,17 +69,22 @@ def set_config(target, usage = None):
         sys.exit(1)
 
     fname = source_dir + "/target.scad"
-    text = "include <config_%s.scad>\n" % target;
-    line = ""
+    text = ['include <config_%s.scad>\n' % target,
+            '$target = "%s";\n' % target,
+            '$cwd="%s";\n' % os.getcwd().replace('\\', '/')
+    ]
+
+    lines = [""]
     try:
         with open(fname,"rt") as f:
-            line = f.read()
+            lines = f.readlines()
     except:
         pass
 
-    if line != text:
+    if lines != text:
         with open(fname,"wt") as f:
-            f. write(text);
+            for t in text:
+                f. write(t);
     return target + "/"
 
 def usage():

scripts/tests.py

@@ -34,6 +34,7 @@ import shutil
 from deps import *
 from blurb import *
 from colorama import Fore
+from tmpdir import *
 
 w = 4096
 h = w
@@ -50,13 +51,17 @@ def do_cmd(cmd, output = sys.stdout):
     return subprocess.call(cmd, stdout = output, stderr = output)
 
 def compare_images(a, b, c):
+    if not os.path.isfile(b):
+        print(Fore.MAGENTA + "Failed to generate %s while making %s" % (b, a), Fore.WHITE)
+        sys.exit(1)
     if not os.path.isfile(a):
         return -1
     log_name = 'magick.log'
     with open(log_name, 'w') as output:
         do_cmd(("magick compare -metric AE -fuzz %d%% %s %s %s" % (fuzz, a, b, c)).split(), output = output)
     with open(log_name, 'r') as f:
-        pixels = int(f.read().strip())
+        pixels = f.read().strip()
+        pixels = int(float(pixels if pixels.isnumeric() else -1))
     os.remove(log_name)
     return pixels
 
@@ -67,6 +72,8 @@ def update_image(tmp_name, png_name):
     if pixels < 0 or pixels > threshold:
         shutil.copyfile(tmp_name, png_name)
         print(Fore.YELLOW + png_name + " updated" + Fore.WHITE, pixels if pixels > 0 else '')
+        if png_name.endswith('_tn.png') and os.path.isfile(diff_name):
+            os.remove(diff_name)
     else:
         os.utime(png_name, None)
         os.remove(diff_name)
@@ -91,13 +98,13 @@ def usage():
 
 def tests(tests):
     scad_dir = "tests"
+    tmp_dir = mktmpdir(scad_dir + '/')
     deps_dir = scad_dir + "/deps"
     png_dir  = scad_dir + "/png"
     bom_dir  = scad_dir + "/bom"
     for dir in [deps_dir, png_dir, bom_dir]:
         if not os.path.isdir(dir):
             os.makedirs(dir)
-    doc_name = "readme.md"
     index = {}
     bodies = {}
     done = []
@@ -108,14 +115,27 @@ def tests(tests):
     #
     png_name = "libtest.png"
     scad_name = "libtest.scad"
-    if not os.path.isfile(png_name):
-        openscad.run(colour_scheme, "--projection=p", "--imgsize=%d,%d" % (w, h), "--camera=0,0,0,50,0,340,500", "--autocenter", "--viewall", "-o", png_name, scad_name);
-        do_cmd(["magick", png_name, "-trim", "-resize", "1280", "-bordercolor", background, "-border", "10", png_name])
+    if os.path.isfile(scad_name):
+        libtest = True
+        lib_blurb = scrape_blurb(scad_name)
+        if not os.path.isfile(png_name):
+            openscad.run(scad_name, "-o", png_name, colour_scheme, "--projection=p", "--imgsize=%d,%d" % (w, h), "--camera=0,0,0,50,0,340,500", "--autocenter", "--viewall");
+            do_cmd(["magick", png_name, "-trim", "-resize", "1280", "-bordercolor", background, "-border", "10", png_name])
+    else:
+        #
+        # Project tests so just a title
+        #
+        libtest = False
+        project = ' '.join(word[0].upper() + word[1:] for word in os.path.basename(os.getcwd()).split('_'))
+        lib_blurb = '#' + project + ' Tests\n'
+
+    doc_base_name = "readme" if libtest else "tests"
+    doc_name = doc_base_name + ".md"
     #
     # List of individual part files
     #
     scads = [i for i in sorted(os.listdir(scad_dir), key = lambda s: s.lower()) if i[-5:] == ".scad"]
-
+    types = []
     for scad in scads:
         base_name = scad[:-5]
         if not tests or base_name in tests:
@@ -132,29 +152,42 @@ def tests(tests):
             if is_plural(base_name) and os.path.isfile(vits_name):
                 objects_name = vits_name
 
-            locations = [
-                ('vitamins/' + depluralise(base_name) + '.scad', 'Vitamins'),
-                ('printed/' + base_name + '.scad',               'Printed'),
-                ('utils/' + base_name + '.scad',                 'Utilities'),
-                ('utils/core/' + base_name + '.scad',            'Core Utilities'),
-            ]
+            locations = []
+            if os.path.isdir('vitamins'):
+                locations.append(('vitamins/' + depluralise(base_name) + '.scad', 'Vitamins'))
+            if os.path.isdir('printed'):
+                locations.append(('printed/' + base_name + '.scad',               'Printed'))
+            if os.path.isdir('utils'):
+                locations.append(('utils/' + base_name + '.scad',                 'Utilities'))
+            if libtest and os.path.isdir('utils/core'):
+                locations.append(('utils/core/' + base_name + '.scad',            'Core Utilities'))
 
             for name, type in locations:
                 if os.path.isfile(name):
                     impl_name = name
                     break
             else:
-                print("Can't find implementation!")
-                continue
+                if libtest:
+                    print("Can't find implementation!")
+                    continue
+                else:
+                    type = 'Tests'                         # OK when testing part of a project
+                    impl_name = None
 
-            vsplit = "AJR" + chr(ord('Z') + 1)
-            vtype = locations[0][1]
-            types = [vtype + ' ' + vsplit[i] + '-'  + chr(ord(vsplit[i + 1]) - 1) for i in range(len(vsplit) - 1)] + [loc[1] for loc in locations[1 :]]
-            if type == vtype:
-                for i in range(1, len(vsplit)):
-                    if cap_name[0] < vsplit[i]:
-                         type = types[i - 1]
-                         break
+            if libtest:
+                vsplit = "AIR" + chr(ord('Z') + 1)
+                vtype = locations[0][1]
+                types = [vtype + ' ' + vsplit[i] + '-' + chr(ord(vsplit[i + 1]) - 1) for i in range(len(vsplit) - 1)] + [loc[1] for loc in locations[1 :]]
+                if type == vtype:
+                    for i in range(1, len(vsplit)):
+                        if cap_name[0] < vsplit[i]:
+                             type = types[i - 1]
+                             break
+            else:
+                if not types:
+                    types = [loc[1] for loc in locations]   # No need to split up the vitamin list
+                    if not type in types:                   # Will happen when implementation is not found and type is set to Tests
+                        types.append(type)
 
             for t in types:
                 if not t in bodies:
@@ -193,7 +226,7 @@ def tests(tests):
                     if things:
                         body += ['### %s\n| %s | Description |\n|:--- |:--- |' % (thing.title(), heading)]
                         for item in sorted(things):
-                            body += ['| ```%s``` | %s |' % (item, things[item])]
+                            body += ['| `%s` | %s |' % (item, things[item])]
                         body += ['']
 
             body += ["![%s](%s)\n" %(base_name, png_name)]
@@ -206,14 +239,15 @@ def tests(tests):
             if changed:
                 print(changed)
                 t = time.time()
-                tmp_name = 'tmp.png'
-                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]);
+                tmp_name = tmp_dir + '/tmp.png'
+                openscad.run_list([scad_name, "-o", tmp_name] + 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]);
                 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)
                 BOM = bom.parse_bom()
                 with open(bom_name, 'wt') as outfile:
                     json.dump(BOM.flat_data(), outfile, indent = 4)
+                print()
 
             with open(bom_name, "rt") as bom_file:
                 BOM = json.load(bom_file)
@@ -226,7 +260,7 @@ def tests(tests):
                             desc = ''
                             if thing == "vitamins":
                                 vit = item.split(':')
-                                name = '```' + vit[0] + '```' if vit[0] else ''
+                                name = '`' + vit[0] + '`' if vit[0] else ''
                                 while '[[' in name and ']]' in name:
                                     i = name.find('[[')
                                     j = name.find(']]') + 2
@@ -250,24 +284,7 @@ def tests(tests):
         usage()
 
     with open(doc_name, "wt") as doc_file:
-        print('# NopSCADlib', file = doc_file)
-        print('''\
-An ever expanding library of parts modelled in OpenSCAD useful for 3D printers and enclosures for electronics, etc.
-
-It contains lots of vitamins (the RepRap term for non-printed parts), some general purpose printed parts and
-some utilities. There are also Python scripts to generate Bills of Materials (BOMs),
- STL files for all the printed parts, DXF files for CNC routed parts in a project and a manual containing assembly
-instructions and exploded views by scraping markdown embedded in OpenSCAD comments, [see scripts](scripts/readme.md). A simple example project can be found [here](examples/MainsBreakOutBox/readme.md).
-
-For more examples of what it can make see the [gallery](gallery/readme.md).
-
-The license is GNU General Public License v3.0, see [COPYING](COPYING).
-
-See [usage](docs/usage.md) for requirements, installation instructions and a usage guide.
-
-<img src="libtest.png" width="100%"/>\n
-''', file = doc_file)
-
+        print(lib_blurb, file = doc_file)
         print('## Table of Contents<a name="top"/>', file = doc_file)
         print('<table><tr>', file = doc_file)
         n = 0
@@ -288,10 +305,15 @@ See [usage](docs/usage.md) for requirements, installation instructions and a usa
         for type in types:
             for line in bodies[type]:
                 print(line, file = doc_file)
-    with open("readme.html", "wt") as html_file:
-        do_cmd("python -m markdown -x tables readme.md".split(), html_file)
+    with open(doc_base_name + ".html", "wt") as html_file:
+        do_cmd(("python -m markdown -x tables " + doc_name).split(), html_file)
     times.print_times()
-    do_cmd('codespell -L od readme.md'.split())
+    #
+    # Remove tmp dir
+    #
+    rmtmpdir(tmp_dir)
+
+    do_cmd(('codespell -L od ' + doc_name).split())
 
 if __name__ == '__main__':
     for arg in sys.argv[1:]:

scripts/times.py

@@ -44,7 +44,7 @@ def got_time(name):
 
 def check_have_time(changed, name):
     if not changed and not got_time(name):
-        changed = "no previous time"
+        changed = Fore.CYAN + "no previous time" + Fore.WHITE
     return changed
 
 def add_time(name, start):
@@ -52,23 +52,34 @@ def add_time(name, start):
         del times[name.lower()]
     times[name] = round(time.time() - start, 3)
 
-def print_times():
-    write_times()
+def print_times(files = None):
     sorted_times = sorted(times.items(), key=lambda kv: kv[1])
     total = 0
+    old_total = 0
     for entry in sorted_times:
-        colour = Fore.WHITE
         key = entry[0]
-        new = entry[1]
-        delta = 0
-        if key in last_times:
-            old = last_times[key]
-            delta = new - old
-            if delta > 0.3:
-                colour = Fore.RED
-            if delta < -0.3:
-                colour = Fore.GREEN
-        print(colour + "%5.1f %5.1f %s" % (new, delta, key))
-        total += new
+        if files and not key in files:
+            del times[key]
+        else:
+            new = entry[1]
+            delta = 0
+            colour = Fore.WHITE
+            if key in last_times:
+                old = last_times[key]
+                old_total += old
+                delta = new - old
+                if delta > 0.3:
+                    colour = Fore.RED
+                if delta < -0.3:
+                    colour = Fore.GREEN
+            print(colour + "%6.1f %5.1f %s" % (new, delta, key))
+            total += new
+    write_times()
     if sorted_times:
-        print(Fore.WHITE + "%5.1f" % total)
+        colour = Fore.WHITE
+        delta = total - old_total
+        if delta > 1:
+            colour = Fore.RED
+        if delta < -1:
+            colour = Fore.GREEN
+        print(colour + "%6.1f %5.1f TOTAL%s" % (total, delta, Fore.WHITE))

scripts/tmpdir.py

@@ -0,0 +1,41 @@
+#
+# NopSCADlib Copyright Chris Palmer 2021
+# 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/>.
+#
+"""
+Make a directory for tmp files.
+"""
+import os
+import time
+
+def mktmpdir(top_dir):
+    tmp_dir = top_dir + 'tmp'
+    if not os.path.isdir(tmp_dir):
+        time.sleep(0.1)
+        os.makedirs(tmp_dir)
+    else:
+        for file in os.listdir(tmp_dir):
+            os.remove(tmp_dir + '/' + file)
+    return tmp_dir
+
+def reltmp(dir, target):
+    return dir if os.path.isabs(dir) else '../../' + dir if target else '../' + dir
+
+def rmtmpdir(tmp_dir):
+    os.rmdir(tmp_dir)
+    while os.path.isdir(tmp_dir):
+        time.sleep(0.1)

scripts/views.py

@@ -35,7 +35,10 @@ import json
 import blurb
 import bom
 import shutil
+import re
+import copy
 from colorama import Fore
+from tmpdir import *
 
 def is_assembly(s):
     return s[-9:] == '_assembly' or s[-11:] == '_assemblies'
@@ -73,19 +76,17 @@ def bom_to_assemblies(bom_dir, bounds_map):
     # Remove the main assembly if it is a shell
     #
     if flat_bom:
-        ass =  flat_bom[-1]
-        if len(ass["assemblies"]) < 2 and not ass["vitamins"] and not ass["printed"] and not ass["routed"]:
+        ass = flat_bom[-1]
+        if len(ass["assemblies"]) == 1 and not ass["vitamins"] and not ass["printed"] and not ass["routed"]:
             flat_bom = flat_bom[:-1]
     return [assembly["name"] for  assembly in flat_bom]
 
-def eop(print_mode, doc_file, last = False, first = False):
-    if print_mode:
-         print('\n<div style="page-break-after: always;"></div>', file = doc_file)
-    else:
-        if not first:
-            print('[Top](#TOP)',   file = doc_file)
-        if not last:
-            print("\n---", file = doc_file)
+def eop(doc_file, last = False, first = False):
+    print('<span></span>', file = doc_file)     # An invisible marker for page breaks because markdown takes much longer if the document contains a div
+    if not first:
+        print('[Top](#TOP)', file = doc_file)
+    if not last:
+        print("\n---", file = doc_file)
 
 def pad(s, before, after = 0):
     return '&nbsp;' * before + str(s) + '&nbsp;' * after
@@ -102,14 +103,36 @@ def usage():
     print("\nusage:\n\t views [target_config] [<name1>_assembly] ... [<nameN>_assembly] - Create assembly images and readme.")
     sys.exit(1)
 
+types = ["vitamins", "printed", "routed"]
+
+def merged(bom):
+    bom = copy.deepcopy(bom)
+    for aname in bom["assemblies"]:
+        count = bom["assemblies"][aname]
+        for ass in flat_bom:
+            if ass['name'] == aname and ass['ngb']:
+                merged_assembly = merged(ass)
+                total = ass['count']
+                for t in types:
+                    for thing in merged_assembly[t]:
+                        items = merged_assembly[t][thing]['count'] * count // total
+                        if thing in bom[t]:
+                            bom[t][thing]['count'] += items
+                        else:
+                            bom[t][thing] = merged_assembly[t][thing]
+                            bom[t][thing]['count'] = items
+                break
+    return bom
+
 def views(target, do_assemblies = None):
     done_assemblies = []
     #
     # Make the target directory
     #
     top_dir = set_config(target, usage)
+    tmp_dir = mktmpdir(top_dir)
     target_dir = top_dir + 'assemblies'
-    deps_dir = top_dir + "deps"
+    deps_dir = target_dir + "/deps"
     bom_dir = top_dir + "bom"
     if not os.path.isdir(target_dir):
         os.makedirs(target_dir)
@@ -138,6 +161,8 @@ def views(target, do_assemblies = None):
     # Find all the scad files
     #
     main_blurb = None
+    main_assembly, main_file = bom.main_assembly(target)
+    pngs = []
     for dir in source_dirs(bom_dir):
         if os.path.isdir(dir):
             for filename in os.listdir(dir):
@@ -161,33 +186,44 @@ def views(target, do_assemblies = None):
                                     #
                                     for ass in flat_bom:
                                         if ass["name"] == real_name:
+                                            zoomed = ass['zoomed']
                                             if not "blurb" in ass:
                                                 ass["blurb"] = blurb.scrape_module_blurb(lines[:line_no])
                                             break
-                                    if not do_assemblies or real_name in do_assemblies:
+
+                                    #
+                                    # Run openscad on the created file
+                                    #
+                                    dname = deps_name(deps_dir, filename)
+                                    for explode in [0, 1]:
                                         #
-                                        # Run openscad on the created file
+                                        # Generate png name
                                         #
-                                        dname = deps_name(deps_dir, filename)
-                                        for explode in [0, 1]:
-                                            png_name = target_dir + '/' + real_name + '.png'
-                                            if not explode:
-                                                png_name = png_name.replace('_assembly', '_assembled')
+                                        png_name = target_dir + '/' + real_name + '.png'
+                                        if not explode:
+                                            png_name = png_name.replace('_assembly', '_assembled')
+                                        pngs.append(png_name)
+
+                                        if not do_assemblies or real_name in do_assemblies:
                                             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'
+                                            tmp_name = tmp_dir + '/' + real_name + '.png'
                                             if changed:
                                                 print(changed)
                                                 #
                                                 # make a file to use the module
                                                 #
-                                                png_maker_name = 'png.scad'
+                                                png_maker_name = tmp_dir + '/png.scad'
                                                 with open(png_maker_name, "w") as f:
-                                                    f.write("use <%s/%s>\n" % (dir, filename))
+                                                    f.write("include <NopSCADlib/global_defs.scad>\n")
+                                                    f.write("use <%s/%s>\n" % (reltmp(dir, target), filename))
                                                     f.write("%s();\n" % module);
                                                 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]);
+                                                target_def = ['-D$target="%s"' % target] if target else []
+                                                cwd_def = ['-D$cwd="%s"' % os.getcwd().replace('\\', '/')]
+                                                view_def = ['--viewall', '--autocenter'] if not (zoomed & (1 << explode)) else ['--camera=0,0,0,55,0,25,140']
+                                                openscad.run_list(["-o", tmp_name, png_maker_name] + options.list() + target_def + cwd_def + view_def + ["-D$pose=1", "-D$explode=%d" % explode, colour_scheme, "--projection=p", "--imgsize=4096,4096", "-d", dname]);
                                                 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)
@@ -198,190 +234,221 @@ def views(target, do_assemblies = None):
                                                 update_image(tmp_name, tn_name)
                                     done_assemblies.append(real_name)
                                 else:
-                                    if module == 'main_assembly':
+                                    if module == main_assembly:
                                         main_blurb = blurb.scrape_module_blurb(lines[:line_no])
                         line_no += 1
-    times.print_times()
     #
     # Build the document
     #
-    for print_mode in [True, False]:
-        doc_name = top_dir + "readme.md"
-        with open(doc_name, "wt") as doc_file:
-            #
-            # Title, description and picture
-            #
-            project = ' '.join(word[0].upper() + word[1:] for word in os.path.basename(os.getcwd()).split('_'))
-            print('<a name="TOP"></a>\n# %s' % project, file = doc_file)
-            main_file = bom.find_scad_file('main_assembly')
-            if not main_file:
-                raise Exception("can't find source for main_assembly")
-            text = blurb.scrape_blurb(source_dir + '/' + main_file)
-            if len(text):
-                print(text, file = doc_file, end = '')
-            else:
-                if print_mode:
-                    print(Fore.MAGENTA + "Missing project description" + Fore.WHITE)
+    doc_name = top_dir + "readme.md"
+    with open(doc_name, "wt") as doc_file:
+        #
+        # Title, description and picture
+        #
+        project = ' '.join(word[0].upper() + word[1:] for word in os.path.basename(os.getcwd()).split('_'))
+        print('<a name="TOP"></a>', file = doc_file)
+        print('# %s' % project, file = doc_file)
+        text = blurb.scrape_blurb(source_dir + '/' + main_file)
+        blurbs = blurb.split_blurb(text)
+        if len(text):
+            print(blurbs[0], file = doc_file)
+        else:
+            print(Fore.MAGENTA + "Missing project description" + Fore.WHITE)
+        #
+        # Only add the image if the first blurb section doesn't contain one.
+        #
+        if not re.search(r'\!\[.*\]\(.*\)', blurbs[0], re.MULTILINE):
             print('![Main Assembly](assemblies/%s.png)\n' % flat_bom[-1]["name"].replace('_assembly', '_assembled'), file = doc_file)
-            eop(print_mode, doc_file, first = True)
-            #
-            # Build TOC
-            #
-            print('## Table of Contents', file = doc_file)
-            print('1. [Parts list](#Parts_list)', file = doc_file)
-            for ass in flat_bom:
-                name =  ass["name"]
-                cap_name = titalise(name)
-                print('1. [%s](#%s)' % (cap_name, name), file = doc_file)
-            print(file = doc_file)
-            eop(print_mode, doc_file)
-            #
-            # Global BOM
-            #
-            print('<a name="Parts_list"></a>\n## Parts list', file = doc_file)
-            types = ["vitamins", "printed", "routed"]
-            headings = {"vitamins" : "vitamins", "printed" : "3D printed parts", "routed" : "CNC routed parts"}
-            things = {}
+        eop(doc_file, first = True)
+        #
+        # Build TOC
+        #
+        print('## Table of Contents', file = doc_file)
+        print('1. [Parts list](#Parts_list)', file = doc_file)
+        for ass in flat_bom:
+            name =  ass["name"]
+            cap_name = titalise(name)
+            print('1. [%s](#%s)' % (cap_name, name), file = doc_file)
+        print(file = doc_file)
+        if len(blurbs) > 1:
+            print(blurbs[1], file = doc_file)
+        eop(doc_file)
+        #
+        # Global BOM
+        #
+        global_bom = [merged(ass) for ass in flat_bom if not ass['ngb']]
+        print('<a name="Parts_list"></a>\n## Parts list', file = doc_file)
+        headings = {"vitamins" : "vitamins", "printed" : "3D printed parts", "routed" : "CNC routed parts"}
+        things = {}
+        for t in types:
+            things[t] = {}
+        for ass in flat_bom:
             for t in types:
-                things[t] = {}
-            for ass in flat_bom:
-                for t in types:
-                    for thing in ass[t]:
-                        if thing in things[t]:
-                            things[t][thing] += ass[t][thing]["count"]
-                        else:
-                            things[t][thing] = ass[t][thing]["count"]
-            for ass in flat_bom:
-                name = titalise(ass["name"][:-9]).replace(' ','&nbsp;')
-                print('| <span style="writing-mode: vertical-rl; text-orientation: mixed;">%s</span> ' % name, file = doc_file, end = '')
-            print('| <span style="writing-mode: vertical-rl; text-orientation: mixed;">TOTALS</span> |  |', file = doc_file)
+                for thing in ass[t]:
+                    if thing in things[t]:
+                        things[t][thing] += ass[t][thing]["count"]
+                    else:
+                        things[t][thing] = ass[t][thing]["count"]
+        for ass in global_bom:
+            name = titalise(ass["name"][:-9]).replace(' ','&nbsp;')
+            if ass["count"] > 1:
+                name = "%d x %s" % (ass["count"], name)
+            print('| <span style="writing-mode: vertical-rl; text-orientation: mixed;">%s</span> ' % name, file = doc_file, end = '')
+        print('| <span style="writing-mode: vertical-rl; text-orientation: mixed;">TOTALS</span> |  |', file = doc_file)
+        print(('|---:' * len(global_bom) + '|---:|:---|'), file = doc_file)
 
-            print(('|---:' * len(flat_bom) + '|---:|:---|'), file = doc_file)
-
-            for t in types:
-                if things[t]:
-                    totals = {}
-                    heading = headings[t][0:1].upper() + headings[t][1:]
-                    print(('|  ' * len(flat_bom) + '| | **%s** |') % heading, file = doc_file)
-                    for thing in sorted(things[t], key = lambda s: s.split(":")[-1]):
-                        for ass in flat_bom:
-                            count = ass[t][thing]["count"] if thing in ass[t] else 0
-                            print('| %s ' % pad(count if count else '.', 2, 1), file = doc_file, end = '')
-                            name = ass["name"]
-                            if name in totals:
-                                totals[name] += count
-                            else:
-                                totals[name] = count
-                        print('|  %s | %s |' % (pad(things[t][thing], 2, 1), pad(thing.split(":")[-1], 2)), file = doc_file)
-
-                    grand_total = 0
-                    for ass in flat_bom:
+        for t in types:
+            if things[t]:
+                totals = {}
+                grand_total2 = 0
+                heading = headings[t][0].upper() + headings[t][1:]
+                print(('|  ' * len(global_bom) + '| | **%s** |') % heading, file = doc_file)
+                for thing in sorted(things[t], key = lambda s: s.split(":")[-1]):
+                    for ass in global_bom:
+                        count = ass[t][thing]["count"] if thing in ass[t] else 0
+                        print('| %s ' % pad(count if count else '.', 2, 1), file = doc_file, end = '')
                         name = ass["name"]
-                        total = totals[name] if name in totals else 0
-                        print('| %s ' % pad(total if total else '.', 2, 1), file = doc_file, end = '')
-                        grand_total += total
-                    print("| %s | %s |" % (pad(grand_total, 2, 1), pad('Total %s count' % headings[t], 2)), file = doc_file)
+                        if name in totals:
+                            totals[name] += count
+                        else:
+                            totals[name] = count
+                        grand_total2 += count
+                    print('|  %s | %s |' % (pad(things[t][thing], 2, 1), pad(thing.split(":")[-1], 2)), file = doc_file)
 
-            print(file = doc_file)
-            eop(print_mode, doc_file)
-            #
-            # Assembly instructions
-            #
-            for ass in flat_bom:
-                name = ass["name"]
-                cap_name = titalise(name)
-
-                if ass["count"] > 1:
-                    print('<a name="%s"></a>\n## %d x %s' % (name, ass["count"], cap_name), file = doc_file)
-                else:
-                    print('<a name="%s"></a>\n## %s' % (name, cap_name), file = doc_file)
-                vitamins = ass["vitamins"]
-                if vitamins:
-                    print("### Vitamins",         file = doc_file)
-                    print("|Qty|Description|",    file = doc_file)
-                    print("|---:|:----------|",    file = doc_file)
-                    for v in sorted(vitamins, key = lambda s: s.split(":")[-1]):
-                        print("|%d|%s|" % (vitamins[v]["count"], v.split(":")[1]),     file = doc_file)
-                    print("\n", file = doc_file)
-
-                printed = ass["printed"]
-                if printed:
-                    print('### 3D Printed parts', file = doc_file)
-                    keys = sorted(list(printed.keys()))
-                    for i in range(len(keys)):
-                        p = keys[i]
-                        print('%s %d x %s |' % ('\n|' if not (i % 3) else '', printed[p]["count"], p), file = doc_file, end = '')
-                        if (i % 3) == 2 or i == len(printed) - 1:
-                            n = (i % 3) + 1
-                            print('\n|%s' % ('---|' * n), file =  doc_file)
-                            for j in range(n):
-                                part = keys[i - n + j + 1]
-                                print('| ![%s](stls/%s) %s' % (part, part.replace('.stl','.png'), '|\n' if j == j - 1 else ''), end = '', file = doc_file)
-                            print('\n', file = doc_file)
-                    print('\n', file  = doc_file)
-
-                routed = ass["routed"]
-                if routed:
-                    print("### CNC Routed parts", file = doc_file)
-                    keys = sorted(list(routed.keys()))
-                    for i in range(len(keys)):
-                        r = keys[i]
-                        print('%s %d x %s |' % ('\n|' if not (i % 3) else '', routed[r]["count"], r), file = doc_file, end = '')
-                        if (i % 3) == 2 or i == len(routed) - 1:
-                            n = (i % 3) + 1
-                            print('\n|%s' % ('---|' * n), file =  doc_file)
-                            for j in range(n):
-                                part = keys[i - n + j + 1]
-                                print('| ![%s](dxfs/%s) %s' % (part, part.replace('.dxf','.png'), '|\n' if j == j - 1 else ''), end = '', file = doc_file)
-                            print('\n', file = doc_file)
-                    print('\n', file  = doc_file)
-
-                sub_assemblies = ass["assemblies"]
-                if sub_assemblies:
-                    print("### Sub-assemblies", file = doc_file)
-                    keys = sorted(list(sub_assemblies.keys()))
-                    for i in range(len(keys)):
-                        a = keys[i]
-                        print('%s %d x %s |' % ('\n|' if not (i % 3) else '', sub_assemblies[a], a), file = doc_file, end = '')
-                        if (i % 3) == 2 or i == len(keys) - 1:
-                            n = (i % 3) + 1
-                            print('\n|%s' % ('---|' * n), file =  doc_file)
-                            for j in range(n):
-                                a = keys[i - n + j + 1].replace('_assembly', '_assembled')
-                                print('| ![%s](assemblies/%s) %s' % (a, a + '_tn.png', '|\n' if j == j - 1 else ''), end = '', file = doc_file)
-                            print('\n', file = doc_file)
-                    print('\n', file  = doc_file)
-
-                small = not ass["big"]
-                suffix = '_tn.png' if small else '.png'
-                print('### Assembly instructions', file = doc_file)
-                print('![%s](assemblies/%s)\n' % (name, name + suffix), file = doc_file)
-
-                if "blurb" in ass and ass["blurb"]:
-                    print(ass["blurb"], file = doc_file)
-                else:
-                    if print_mode:
-                        print(Fore.MAGENTA + "Missing instructions for %s" % name, Fore.WHITE)
-
-                name = name.replace('_assembly', '_assembled')
-                print('![%s](assemblies/%s)\n' % (name, name + suffix), file = doc_file)
-                eop(print_mode, doc_file, last = ass == flat_bom[-1] and not main_blurb)
-            #
-            # If main module is suppressed print any blurb here
-            #
-            if main_blurb:
-                print(main_blurb, file = doc_file)
-                eop(print_mode, doc_file, last = True)
+                grand_total = 0
+                for ass in global_bom:
+                    name = ass["name"]
+                    total = totals[name] if name in totals else 0
+                    print('| %s ' % pad(total if total else '.', 2, 1), file = doc_file, end = '')
+                    grand_total += total
+                print("| %s | %s |" % (pad(grand_total, 2, 1), pad('Total %s count' % headings[t], 2)), file = doc_file)
+                assert grand_total == grand_total2
+        print(file = doc_file)
+        if len(blurbs) > 2:
+            print(blurbs[2], file = doc_file)
+        eop(doc_file)
         #
-        # Convert to HTML
+        # Assembly instructions
         #
-        html_name = "printme.html" if print_mode else "readme.html"
-        with open(top_dir + html_name, "wt") as html_file:
-            do_cmd(("python -m markdown -x tables -x sane_lists " + doc_name).split(), html_file)
+        for ass in flat_bom:
+            name = ass["name"]
+            cap_name = titalise(name)
+
+            print('<a name="%s"></a>' % name, file = doc_file)
+            if ass["count"] > 1:
+                print('## %d x %s' % (ass["count"], cap_name), file = doc_file)
+            else:
+                print('## %s' % cap_name, file = doc_file)
+            vitamins = ass["vitamins"]
+            if vitamins:
+                print("### Vitamins",         file = doc_file)
+                print("|Qty|Description|",    file = doc_file)
+                print("|---:|:----------|",    file = doc_file)
+                for v in sorted(vitamins, key = lambda s: s.split(":")[-1]):
+                    print("|%d|%s|" % (vitamins[v]["count"], v.split(":")[1]),     file = doc_file)
+                print("\n", file = doc_file)
+
+            printed = ass["printed"]
+            if printed:
+                print('### 3D Printed parts', file = doc_file)
+                keys = sorted(list(printed.keys()))
+                for i, p in enumerate(keys):
+                    print('%s %d x %s |' % ('\n|' if not (i % 3) else '', printed[p]["count"], p), file = doc_file, end = '')
+                    if (i % 3) == 2 or i == len(printed) - 1:
+                        n = (i % 3) + 1
+                        print('\n|%s' % ('---|' * n), file =  doc_file)
+                        for j in range(n):
+                            part = keys[i - n + j + 1]
+                            print('| ![%s](stls/%s) %s' % (part, part.replace('.stl','.png'), '|\n' if j == j - 1 else ''), end = '', file = doc_file)
+                        print('\n', file = doc_file)
+                print('\n', file  = doc_file)
+
+            routed = ass["routed"]
+            if routed:
+                print("### CNC Routed parts", file = doc_file)
+                keys = sorted(list(routed.keys()))
+                for i, r in enumerate(keys):
+                    print('%s %d x %s |' % ('\n|' if not (i % 3) else '', routed[r]["count"], r), file = doc_file, end = '')
+                    if (i % 3) == 2 or i == len(routed) - 1:
+                        n = (i % 3) + 1
+                        print('\n|%s' % ('---|' * n), file =  doc_file)
+                        for j in range(n):
+                            part = keys[i - n + j + 1]
+                            print('| ![%s](dxfs/%s) %s' % (part, part.replace('.dxf','.png'), '|\n' if j == j - 1 else ''), end = '', file = doc_file)
+                        print('\n', file = doc_file)
+                print('\n', file  = doc_file)
+
+            sub_assemblies = ass["assemblies"]
+            if sub_assemblies:
+                print("### Sub-assemblies", file = doc_file)
+                keys = sorted(list(sub_assemblies.keys()))
+                for i, a in enumerate(keys):
+                    print('%s %d x %s |' % ('\n|' if not (i % 3) else '', sub_assemblies[a], a), file = doc_file, end = '')
+                    if (i % 3) == 2 or i == len(keys) - 1:
+                        n = (i % 3) + 1
+                        print('\n|%s' % ('---|' * n), file =  doc_file)
+                        for j in range(n):
+                            a = keys[i - n + j + 1].replace('_assembly', '_assembled')
+                            print('| ![%s](assemblies/%s) %s' % (a, a + '_tn.png', '|\n' if j == j - 1 else ''), end = '', file = doc_file)
+                        print('\n', file = doc_file)
+                print('\n', file  = doc_file)
+
+            small = not ass["big"]
+            suffix = '_tn.png' if small else '.png'
+            print('### Assembly instructions', file = doc_file)
+            print('![%s](assemblies/%s)\n' % (name, name + suffix), file = doc_file)
+
+            if "blurb" in ass and ass["blurb"]:
+                print(ass["blurb"], file = doc_file)
+            else:
+                print(Fore.MAGENTA + "Missing instructions for %s" % name, Fore.WHITE)
+
+            name = name.replace('_assembly', '_assembled')
+            print('![%s](assemblies/%s)\n' % (name, name + suffix), file = doc_file)
+            eop(doc_file, last = ass == flat_bom[-1] and not main_blurb)
+        #
+        # If main module is suppressed print any blurb here
+        #
+        if main_blurb:
+            print(main_blurb, file = doc_file)
+            eop(doc_file, last = True)
+    #
+    # Convert to HTML
+    #
+    html_name = top_dir + 'readme.html'
+    t = time.time()
+    with open(html_name, "wt") as html_file:
+        do_cmd(("python -m markdown -x tables -x sane_lists " + doc_name).split(), html_file)
+    times.add_time(html_name, t)
+    times.print_times(pngs + [html_name])
+    #
+    # Make the printme.html by replacing empty spans that invisbly mark the page breaks by page break divs.
+    #
+    with open(html_name, 'rt') as src:
+        lines = src.readlines()
+
+    i = 0
+    with open(top_dir + 'printme.html', 'wt') as dst:
+        while i < len(lines):
+            line = lines[i]
+            if line.startswith('<p><span></span>'):                # Empty span used to mark page breaks
+                i += 1
+                if lines[i].startswith('<a href="#TOP">Top</a>'):  # The first page break won't have one
+                    i += 1
+                if i < len(lines) and lines[i] == '<hr />\n':      # The last page break doesn't have one
+                    dst.write('<div style="page-break-after: always;"></div>\n')
+                    i += 1
+            else:
+                dst.write(line)
+                i += 1
+    #
+    # Remove tmp dir
+    #
+    rmtmpdir(tmp_dir)
     #
     # Spell check
     #
-    do_cmd('codespell -L od readme.md'.split())
+    do_cmd(('codespell -L od ' + top_dir + 'readme.md').split())
     #
     # List the ones we didn't find
     #

tests/7_segments.scad

@@ -0,0 +1,31 @@
+//
+// NopSCADlib Copyright Chris Palmer 2021
+// 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 <../utils/core/core.scad>
+use <../utils/layout.scad>
+
+include <../vitamins/7_segments.scad>
+
+function digits(s) = 7_segment_digits(s) < 2 ? 2 : 1;
+
+module 7_segments()
+    layout([for(s = 7_segments) 7_segment_size(s).x * digits(s)], 3) let(s = 7_segments[$i])
+        7_segment_digits(s, digits(s));
+
+if($preview)
+    7_segments();

tests/BLDC_motors.scad

@@ -0,0 +1,31 @@
+//
+// NopSCADlib Copyright Chris Palmer 2021
+// 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/bldc_motors.scad>
+
+module bldc_motors()
+    layout([for(b = bldc_motors) BLDC_diameter(b)])
+        rotate(-90)
+            BLDC(bldc_motors[$i]);
+
+if($preview)
+    let($show_threads = 1)
+        bldc_motors();

tests/BOM.scad

@@ -20,17 +20,16 @@
 //
 //! BOM and assembly demonstration
 //
+$explode = 1; // Normally set on the command line when generating assembly views with views.py
 include <../core.scad>
 include <../vitamins/sheets.scad>
 use <../vitamins/insert.scad>
-$explode = 1; // Normally set on the command line when generating assembly views with views.py
 
 screw = M3_cap_screw;
 sheet = PMMA3;
 height = 10;
 
 insert = screw_insert(screw);
-washer = screw_washer(screw);
 
 module widget(thickness) {
     vitamin(str("widget(", thickness, "): Rivit like thing for ", thickness, "mm sheets"));
@@ -44,31 +43,29 @@ module widget(thickness) {
     }
 }
 
-module widgit_stl() {
-    stl("widget");
+module widget_stl() {
+    stl("widget")
+        union() {
+            rounded_rectangle([30, 30, 3], 2, true);
 
-    union() {
-        rounded_rectangle([30, 30, 3], 2);
-
-        render() insert_boss(insert, height, 2.2);
-    }
+            render() insert_boss(insert, height, 2.2);
+        }
 }
 
-module widgit_dxf() {
-    dxf("widget");
+module widget_dxf() {
+    dxf("widget")
+        difference() {
+            sheet_2D(sheet, 20, 20, 1);
 
-    difference() {
-        sheet_2D(sheet, 20, 20, 1);
-
-        drill(screw_clearance_radius(screw), 0);
-    }
+            drill(screw_clearance_radius(screw), 0);
+        }
 }
 
 //! * Push the insert into the base with a soldering iron heated to 200&deg;C
-module widgit_base_assembly()
-assembly("widgit_base") {
+module widget_base_assembly()
+assembly("widget_base") {
     stl_colour(pp1_colour)
-        widgit_stl();
+        widget_stl();
 
     translate_z(height)
         insert(insert);
@@ -81,18 +78,18 @@ assembly("widget_top") {
         widget(sheet_thickness(sheet));
 
     render_2D_sheet(sheet)      // Must be last because it is transparent
-        widgit_dxf();
+        widget_dxf();
 }
 
 //! * Screw the two assemblies together
-module widgit_assembly()
-assembly("wigdit") {
+module widget_assembly()
+assembly("widget") {
 
-    widgit_base_assembly();                 // Note this is not exloded because it is sub-assembly
+    widget_base_assembly();                 // Note this is not exloded because it is sub-assembly
 
     translate_z(height) {
         translate_z(sheet_thickness(sheet))
-            screw_and_washer(screw, screw_longer_than(sheet_thickness(sheet) + 2 * washer_thickness(washer) + 3), true);
+            screw_and_washer(screw, screw_length(screw, sheet_thickness(sheet) + 3, 2, longer = true), true);
 
         explode(5)
             translate_z(sheet_thickness(sheet) / 2 + eps)
@@ -101,7 +98,7 @@ assembly("wigdit") {
 }
 
 module boms() {
-    widgit_assembly();
+    widget_assembly();
 }
 
 boms();

tests/DIP.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 <../core.scad>
+include <../utils/core/core.scad>
 use <../vitamins/dip.scad>
 
 dips = [[6, "OPTO"], [8, "NE555"], [14, "74HC00"], [16, "ULN2003"], [18, "ULN2803"], [20, "74HC245"], [28, "ATMEGA328"]];

tests/LDRs.scad

@@ -16,6 +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 <../utils/core/core.scad>
 include <../vitamins/ldrs.scad>
 
 use <../utils/layout.scad>

tests/PCB.scad

@@ -22,6 +22,8 @@ include <../vitamins/d_connectors.scad>
 include <../vitamins/leds.scad>
 include <../vitamins/axials.scad>
 include <../vitamins/smds.scad>
+include <../vitamins/7_segments.scad>
+include <../vitamins/potentiometers.scad>
 
 use <../vitamins/pcb.scad>
 
@@ -34,7 +36,7 @@ TMC2130 = ["TMC2130", "TMC2130",
     [
         [  10,  1,  0, "-2p54header", 8, 1 ,undef, "blue" ],
         [  10, 13,  0, "-2p54header", 8, 1],
-        [  12,  7,  0, "-chip", 6, 4, 1, grey20 ],
+        [  12,  7,  0, "-chip", 6, 4, 1, grey(20) ],
         // mock up a heat sink
         [  10,  7,  0, "block", 9, 9,  2, TMC2130HeatSinkColor ],
         [  10, 11,  0, "block", 9, 1, 11, TMC2130HeatSinkColor ],
@@ -46,7 +48,7 @@ TMC2130 = ["TMC2130", "TMC2130",
     []
 ];
 
-test_pcb = ["TestPCB", "Test PCB",
+test_pcb = ["test_pcb", "Test PCB",
     100, 250, 1.6, // length, width, thickness
     3,      // Corner radius
     2.75,   // Mounting hole diameter
@@ -58,23 +60,31 @@ test_pcb = ["TestPCB", "Test PCB",
     // components
     [
         [ 20, -5, 180, "trimpot10"],
-        [ 20, -15,  0, "trimpot10", true],
-        [ 10,  2,   0, "smd_led", LED0805, "red"],
+        [ 20, -15,  90, "trimpot10", true],
+        [ 10,  2,   90, "smd_led", LED0805, "red"],
+        [ 13,  2,   90, "smd_led", LED0603, "orange"],
+        [ 16,  2,   90, "smd_res", RES1206, "1K"],
+        [ 19,  2,   90, "smd_res", RES0805, "1K"],
+        [ 22,  2,   90, "smd_res", RES0603, "1K"],
+        [ 25,  2,   90, "smd_cap", CAP1206, 1.5],
+        [ 28,  2,   90, "smd_cap", CAP0805, 1.0],
+        [ 31,  2,   90, "smd_cap", CAP0603, 0.7],
+
         [ 10,  10,   0, "2p54header", 4, 1],
-        [ 25,  10,   0, "2p54header", 5, 1, undef, "blue" ],
+        [ 25,  10,   0, "2p54header", 5, 1, false, "blue" ],
         [ 10,  20,   0, "2p54boxhdr", 4, 2],
         [ 10,  30,   0, "2p54socket", 6, 1],
-        [ 25,  30,   0, "2p54socket", 4, 1, undef, undef, undef, "red" ],
-        [ 10,  40,   0, "chip", 10, 5, 1, grey20],
-        [  5,  50,   0, "led", LED3mm, "red"],
-        [ 12,  50,   0, "led", LED5mm, "orange"],
-        [ 25,  50,   0, "led", LED10mm, "yellow"],
-        [ 10,  65, 180, "rj45"],
-        [  8,  85, 180, "usb_A"],
+        [ 25,  30,   0, "2p54socket", 4, 1, false, 0, false, "red" ],
+        [ 65,  50,   0, "led", LED3mm, "red"],
+        [ 75,  50,   0, "led", LED5mm, "orange"],
+        [ 90,  50,   0, "led", LED10mm, "yellow"],
+        [ 10,  45, 180, "rj45"],
+        [  8,  65, 180, "usb_A"],
         [  8, 105, 180, "usb_Ax2"],
+        [  7,  85, 180, "molex_usb_Ax1"],
+        [ 8.5,125, 180, "molex_usb_Ax2"],
         [  3, 140, 180, "usb_uA"],
         [  8, 155, 180, "usb_B"],
-        [  8.5, 125, 180, "molex_usb_Ax2"],
         [ 25, 200,   0, "buzzer", 4.5, 8.5],
         [ 25, 218,   0, "buzzer"],
         [  8, 190, 180, "jack"],
@@ -82,22 +92,28 @@ test_pcb = ["TestPCB", "Test PCB",
         [  5, 218, 180, "hdmi"],
         [  3, 235, 180, "mini_hdmi"],
         [  6, 175, 180, "uSD", [12, 11.5, 1.4]],
+
+        [ 65,   9,   0, "link", inch(0.4)],
         [ 65,  12,   0, "ax_res", res1_8, 1000],
         [ 65,  17,   0, "ax_res", res1_4, 10000],
         [ 65,  22,   0, "ax_res", res1_2, 100000],
+        [ 55,  22,   0, "vero_pin"],
+        [ 55,  17,   0, "vero_pin", true],
 
+        [ 80,   9,   0, "link", inch(0.2), inch(0.4)],
         [ 80,  12,   0, "ax_res", res1_8, 1000000, 1, inch(0.1)],
         [ 80,  17,   0, "ax_res", res1_4, 100,     2, inch(0.1)],
         [ 80,  22,   0, "ax_res", res1_2, 10,     10, inch(0.2)],
 
         [ 60,   3,   0, "flex"],
-        [ 50,  15,   0, "flat_flex"],
+        [ 50,  15, -90, "flat_flex"],
+        [ 40,  15, -90, "flat_flex", true],
         [ 60,  35,   0, "D_plug", DCONN9],
 
         [ 50,  50,   0, "molex_hdr", 2],
         [ 50,  60,   0, "jst_xh", 2],
         [ 50,  70, 180, "term254", 3],
-        [ 63,  70, 180, "term254", 3, undef, grey20],
+        [ 63,  70, 180, "term254", 3, undef, grey(20)],
         [ 75,  70, 180, "gterm508",2, undef, "blue"],
 
         [ 50,  90, 180, "gterm35", 4, [1,2]],
@@ -107,22 +123,26 @@ test_pcb = ["TestPCB", "Test PCB",
 
         [ 55, 110, 180, "gterm635", 2],
         [ 75, 110, 180, "gterm635", 2, undef, "blue"],
-        [ 90, 110, 180, "gterm", gt_5x17, 2, undef, grey20],
+        [ 90, 110, 180, "gterm", gt_5x17, 2, undef, grey(20)],
 
         [ 50, 130, 180, "term35", 4],
         [ 70, 130, 180, "term35", 3, "lime"],
         [ 50, 150,   0, "transition", 5],
         [ 50, 160,   0, "block", 10, 5, 8, "orange"],
-        [ 50, 170,   0, "button_6mm"],
+        [ 45, 170,   0, "button_6mm"],
+        [ 55, 170,   0, "button_4p5mm"],
         [ 50, 185,   0, "microswitch", small_microswitch],
         [ 52, 200,   0, "pcb", 11, TMC2130 ],
         [ 80, 200,   0, "pdip", 24, "27C32", true, inch(0.6) ],
         [ 80, 170,   0, "pdip", 8, "NE555" ],
+        [ 80, 150,   0, "chip", 10, 5, 1, grey(20)],
+
         [ 52, 206,   0, "2p54socket", 8, 1 ],
-        [ 52, 194,   0, "2p54socket", 8, 1, undef, undef, undef, "red" ],
+        [ 52, 194,   0, "2p54socket", 8, 1, false, 0, false, "red" ],
         [ 50, 220,   0, "standoff",  5, 4.5, 12.5, 2.54],
         [ 50, 240,   0, "potentiometer"],
-        [ 75, 240,   0, "potentiometer", 7, 8],
+        [ 75, 240,   0, "potentiometer", KY_040_encoder, 8],
+        [ 30,  85,   -90, "7seg", WT5011BSR, 2],
     ],
     // accessories
     []