Project blurb can now be split with into sections with markdown horizonal rules

made with asterisks.
If an image is include in the first section the default image is supressed.

docs/usage.md

@@ -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,7 +112,7 @@ 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.
@@ -123,17 +123,17 @@ Any other vitamins used need to be included explicitly. One can copy the include
 
 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 +144,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.
@@ -182,26 +182,26 @@ 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.
 
 ### 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 +216,50 @@ 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>`.
 
 ### 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.

global_defs.scad

@@ -35,8 +35,8 @@ extrusion_width = is_undef($extrusion_width) ? 0.5    : $extrusion_width; // fil
 nozzle          = is_undef($nozzle)          ? 0.45   : $nozzle;          // 3D printer nozzle
 cnc_bit_r       = is_undef($cnc_bit_r)       ? 1.2    : $cnc_bit_r;       // minimum 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
+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
 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

lib.scad

@@ -90,6 +90,7 @@ use <utils/gears.scad>
 use <utils/hanging_hole.scad>
 use <utils/fillet.scad>
 use <utils/rounded_polygon.scad>
+use <utils/rounded_right_triangle.scad>
 use <utils/layout.scad>
 use <utils/round.scad>
 use <utils/offset.scad>

libtest.scad

@@ -52,6 +52,7 @@ 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>
@@ -77,6 +78,7 @@ use <tests/opengrab.scad>
 use <tests/panel_meters.scad>
 use <tests/PCBs.scad>
 use <tests/pillars.scad>
+use <tests/press_fit.scad>
 use <tests/PSUs.scad>
 use <tests/pulleys.scad>
 use <tests/rails.scad>
@@ -136,9 +138,12 @@ cable_grommets_y = 0;
 translate([x5, cable_grommets_y])
     cable_grommets();
 
-translate([x5 + 80, cable_grommets_y])
+translate([x5 + 50, cable_grommets_y])
     ribbon_clamps();
 
+translate([x5 + 95, cable_grommets_y])
+    press_fits();
+
 translate([x5, cable_grommets_y + 60])
     fixing_blocks();
 
@@ -417,12 +422,16 @@ translate([x4 + 200, belts_y + 58]) {
 
     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([770, fans_y + 50])
     cable_strips();
 
 translate([x4, kp_pillow_blocks_y])

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:
@@ -109,7 +109,7 @@ module grill_hole_positions(width, height, r = 1000) {
     }
 }
 
-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.
+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)
         if(poly)
             grill_hole_positions(width, height, r)
@@ -121,11 +121,12 @@ module grill(width, height, r = 1000, poly = false, h = 0) { //! A staggered arr
 
 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
         }
@@ -212,33 +213,39 @@ module box_bezel(type, bottom) { //! Generates top and bottom bezel STLs
     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() {
+        w = box_width(type);
+        d = box_depth(type);
         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);
+            tw = w + 2 * outset;
+            td = d + 2 * outset;
+            rounded_rectangle([tw, td, 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);
+                        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);
+                        cube([w - 2 * (foot_length - foot_extension), td + 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);
+                        cube([tw + 1, d - 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);
+                        cube([tw + 1, d - 2 * (foot_length - foot_extension), 1], center = true);
                 }
         }
         //
@@ -247,28 +254,28 @@ module box_bezel(type, bottom) { //! Generates top and bottom bezel STLs
         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([i * (w + t - sheet_slot_clearance) / 2, 0])
+                         square([t, d - 2 * cgap], 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);
+                    translate([0, i * (d + t - sheet_slot_clearance) / 2])
+                         square([w - 2 * cgap, 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);
+        translate_z(cgap)
+            rounded_rectangle([w + bezel_clearance, d + 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)
+            linear_extrude(box_profile_overlap(type) + cgap + 2)
                 union() {
                     difference() {
-                        square([box_width(type) - 2 * box_inset(type),
-                                box_depth(type) - 2 * box_inset(type)], center = true);
+                        square([w - 2 * inset,
+                                d - 2 * inset], center = true);
 
-                        box_corner_quadrants(type, box_width(type), box_depth(type));
+                        box_corner_quadrants(type, w, d);
                     }
                     box_screw_hole_positions(type)
                         poly_circle(screw_clearance_radius(box_screw(type)));
@@ -291,7 +298,9 @@ module box_bezel_section(type, bottom, rows, cols, x, y) { //! Generates interlo
     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() {
@@ -299,14 +308,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() {
@@ -318,7 +327,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);
                 }
     }
 
@@ -359,7 +368,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([tw / 2 - x * w, th / 2 - 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)
@@ -419,10 +428,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");
@@ -551,25 +564,25 @@ module box_shelf_bracket_section(type, rows, cols, x, y) { //! Generates section
             children();
 }
 
-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_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);

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);
 //

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

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>

printed/drag_chain.scad

@@ -0,0 +1,321 @@
+//
+// 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 mininium 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>
+
+clearance = 0.1;
+
+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_screw(type)       = type[6]; //! Mounting screw for the ends
+function drag_chain_screw_lists(type) = type[7]; //! Two lists of four bools to say which screws positions are used
+
+function drag_chain_clearance() = clearance; //! Clearance around joints.
+
+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, screw = M2_cap_screw, screw_lists = [[1,0,0,1],[1,0,0,1]]) = //! Constructor
+    [name, size, travel, wall, bwall, twall, 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 * clearance, z];
+
+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);
+    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 * clearance - 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);
+    r = os.z / 2;
+    pin_r = r / 2;
+
+    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;
+    roof_x = start ? 0 : roof_x_normal;
+
+    floor_x = start ? 0 : 2 * r;
+    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");
+
+    difference() {
+        union() {
+            for(side = [-1, 1])
+                rotate([90, 0, 0]) {
+                    // Outer cheeks
+                    translate_z(side * (os.y / 2 - wall / 2))
+                        linear_extrude(wall, center = true)
+                            difference() {
+                                hull() {
+                                    if(start)
+                                        square([eps, os.z]);
+                                    else
+                                        translate([socket_x, r])
+                                            rotate(180)
+                                                teardrop(r = r, h = 0);
+
+                                    translate([outer_end_x - eps, 0])
+                                        square([eps, os.z]);
+                                }
+                                if(!start)
+                                    translate([socket_x, r])
+                                        horihole(pin_r, r);
+                            }
+                    // 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(180)
+                                                    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)
+                        translate([pin_x, r, side * (s.y / 2 + wall + clearance)])
+                            horicylinder(r = pin_r, z = r, h = 2 * wall);
+
+                    // 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
+            roof_end = end ? s.x + 2 * r : s.x + r - twall - clearance;
+            translate([roof_x, -s.y / 2 - 0.5])
+                cube([roof_end - roof_x , s.y + 1, twall]);
+
+            translate([roof_x, -os.y / 2 + 0.5])
+                cube([s.x - clearance - roof_x, os.y - 1, twall]);
+
+            // Floor, actually the roof when printed
+            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([floor_x, -os.y / 2 + 0.5,  os.z - bwall])
+                cube([s.x - floor_x - clearance, os.y -1, 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();
+            }
+        }
+        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);
+
+    }
+
+    if(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) {
+    s = drag_chain_size(type);
+    x = (1 + exploded()) * s.x;
+    r = drag_chain_radius(type) * x / s.x;
+    travel = drag_chain_travel(type);
+    links = ceil(travel / s.x);
+    actual_travel = links * 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 + 5;
+            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]) {
+            stl_colour(n < 0 || n == npoints - 1 ? pp3_colour : n % 2 ? pp1_colour : pp2_colour)
+                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)  //! Drag chain assembly
+    assembly(str(drag_chain_name(type), "_drag_chain"), big = true)
+        if($children == 2)
+            _drag_chain_assembly(type, pos) {
+                children(0);
+                children(1);
+            }
+        else if($children == 1)
+            _drag_chain_assembly(type, pos)
+                children(0);
+        else
+            _drag_chain_assembly(type, pos);

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.
+//! Pintable 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.
 //

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>

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>

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 <../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/ribbon_clamp.scad

@@ -81,7 +81,7 @@ module ribbon_clamp(ways, screw = screw) { //! Generate STL for given number of
     }
 }
 
-module ribbon_clamp_assembly(ways, screw) pose([55, 180, 25])  //! Printed part with inserts in place
+module ribbon_clamp_assembly(ways, screw = screw) pose([55, 180, 25])  //! Printed part with inserts in place
     assembly(let(screw_d = screw_radius(screw) * 2)str("ribbon_clamp_", ways, screw_d != 3 ? str("_", screw_d) : "")) {
     h = ribbon_clamp_height(screw);
     insert = screw_insert(screw);
@@ -117,9 +117,13 @@ module ribbon_clamp_fastened_assembly(ways, thickness, screw = screw) { //! Clam
 
 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°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°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°C.
+module ribbon_clamp_7_2_assembly() ribbon_clamp_assembly(8, M2_dome_screw);

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 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 = ""

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,7 @@ 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)
+                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/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

@@ -24,8 +24,8 @@ 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.exe"] + args
     if not silent:
         for arg in cmd:
             print(arg, end=" ")
@@ -33,7 +33,7 @@ def run_list(args, silent = False):
     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:
+        if verbose or 'ERROR:' in line or 'WARNING:' in line:
             print(line[:-1])
     if rc:
         sys.exit(rc)
@@ -43,3 +43,6 @@ def run(*args):
 
 def run_silent(*args):
     run_list(list(args), True);
+
+if __name__ == '__main__':
+    run_list(sys.argv[1:], True, True)

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/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. |
+| `doc_scripts.py` | Makes this document and doc/usage.md. |
+| `dxf.py` |  |
+| `dxf2pdf.py` |  |
+| `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. |

scripts/tests.py

@@ -219,7 +219,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)]
@@ -252,7 +252,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

scripts/views.py

@@ -35,6 +35,7 @@ import json
 import blurb
 import bom
 import shutil
+import re
 from colorama import Fore
 
 def is_assembly(s):
@@ -217,12 +218,21 @@ def views(target, do_assemblies = None):
             if not main_file:
                 raise Exception("can't find source for main_assembly")
             text = blurb.scrape_blurb(source_dir + '/' + main_file)
+            blurbs = blurb.split_blurb(text)
             if len(text):
-                print(text, file = doc_file, end = '')
+                print(blurbs[0], file = doc_file)
             else:
                 if print_mode:
                     print(Fore.MAGENTA + "Missing project description" + Fore.WHITE)
-            print('![Main Assembly](assemblies/%s.png)\n' % flat_bom[-1]["name"].replace('_assembly', '_assembled'), file = doc_file)
+            #
+            # Only add the image if the first blurb section doesn't contain one.
+            #
+            got_image = False
+            for line in blurbs[0].split('\n'):
+                if re.match(r'.*\!\[.*\]\(.*\).*', line):
+                    got_image = True
+            if not got_image:
+                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
@@ -234,6 +244,8 @@ def views(target, do_assemblies = None):
                 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(print_mode, doc_file)
             #
             # Global BOM
@@ -283,6 +295,8 @@ def views(target, do_assemblies = None):
                     print("| %s | %s |" % (pad(grand_total, 2, 1), pad('Total %s count' % headings[t], 2)), file = doc_file)
 
             print(file = doc_file)
+            if len(blurbs) > 2:
+                print(blurbs[2], file = doc_file)
             eop(print_mode, doc_file)
             #
             # Assembly instructions
@@ -308,8 +322,7 @@ def views(target, do_assemblies = None):
                 if printed:
                     print('### 3D Printed parts', file = doc_file)
                     keys = sorted(list(printed.keys()))
-                    for i in range(len(keys)):
-                        p = keys[i]
+                    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
@@ -324,8 +337,7 @@ def views(target, do_assemblies = None):
                 if routed:
                     print("### CNC Routed parts", file = doc_file)
                     keys = sorted(list(routed.keys()))
-                    for i in range(len(keys)):
-                        r = keys[i]
+                    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
@@ -340,8 +352,7 @@ def views(target, do_assemblies = None):
                 if sub_assemblies:
                     print("### Sub-assemblies", file = doc_file)
                     keys = sorted(list(sub_assemblies.keys()))
-                    for i in range(len(keys)):
-                        a = keys[i]
+                    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

tests/belts.scad

@@ -39,7 +39,7 @@ module belt_test() {
             screw = find_screw(hs_cs_cap, pulley_bore(pulley));
             insert = screw_insert(screw);
 
-            rotate([0, flip ? 180 : 0, 0]) {
+            hflip(flip) {
                 pulley_assembly(pulley);
                 translate_z(pulley_height(pulley) + pulley_offset(pulley) + screw_head_depth(screw, pulley_bore(pulley)))
                     screw(screw, 20);

tests/dogbones.scad

@@ -26,6 +26,12 @@ module dogbones() {
     #translate([15, 0])
         dogbone_rectangle([10, 20, 5], center = false);
 
+    #translate([30, 0])
+        dogbone_rectangle_x([10, 20, 5], center = false);
+
+    #translate([45, 0])
+        dogbone_rectangle_y([10, 20, 5], center = false);
+
     sq = 3;
     translate([-5 + sq / 2 + eps, -10 + sq / 2 + eps])
         %cube([sq, sq, 1], center = true);

tests/drag_chain.scad

@@ -0,0 +1,59 @@
+//
+// 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/>.
+//
+
+// Link length between hinges
+x = 10; //[8 : 30]
+
+// Link inner width
+y = 10; //[5 : 30]
+
+// Link inner height
+z = 5;  //[4 : 11]
+// Side wall thickness
+wall = 1.6; //[0.9: 0.1: 3]
+// Bottom wall thickness
+bwall = 1.5; //[1: 0.25: 3]
+// Top wall thickness
+twall = 1.5; //[1: 0.25: 3]
+// Max travel in each direction
+travel = 100;
+// Current position
+pos = 50; // [-100 : 1 : 100]
+
+include <../core.scad>
+use <../printed/drag_chain.scad>
+
+include <../vitamins/leadnuts.scad>
+
+drag_chain = drag_chain("x", [x, y, z], travel, wall = wall, bwall = bwall, twall = twall);
+
+module drag_chains()
+    drag_chain_assembly(drag_chain, pos);
+
+if($preview)
+    drag_chains();
+else {
+    drag_chain_link(drag_chain);
+
+    translate([-x * 2, 0])
+        drag_chain_link(drag_chain, start = true);
+
+    translate([x * 2, 0])
+        drag_chain_link(drag_chain, end = true);
+}

tests/polyholes.scad

@@ -21,30 +21,60 @@ include <../utils/core/core.scad>
 use <../vitamins/rod.scad>
 include <../vitamins/sheets.scad>
 
-module polyholes() {
-    module positions()
-        for(i = [1 : 10]) {
-            translate([(i * i + i) / 2 + 3 * i , 8])
-                let($r = i / 2)
+module positions()
+    for(i = [1 : 10]) {
+        translate([(i * i + i) / 2 + 3 * i , 8])
+            let($r = i / 2)
+                children();
+
+        let(d = i + 0.5)
+            translate([(d * d + d) / 2 + 3 * d, 19])
+                let($r = d / 2)
                     children();
+    }
 
-            let(d = i + 0.5)
-                translate([(d * d + d) / 2 + 3 * d, 19])
-                    let($r = d / 2)
-                        children();
-        }
+module polyhole_stl() {
+    stl("polyhole");
 
-    stl_colour(pp1_colour) linear_extrude(3, center = true)
+    linear_extrude(3, center = true)
         difference() {
             square([100, 27]);
 
             positions()
                 poly_circle(r = $r);
         }
+}
 
-     positions()
+module alt_polyhole_stl() {
+    holes = [2.5, 2, 1.5];
+    n = len(holes);
+    size = [n * 10, 10, 10];
+    difference() {
+        translate([-size.x / n / 2, $preview ? 0 : -size.y / 2])
+            cube($preview ? [size.x, size.y / 2, size.z] : size);
+
+        for(i = [0 : n - 1])
+            translate([i * 10, 0])
+                if(i % 2)
+                    translate_z(size.z)
+                        poly_cylinder(r = holes[i] / 2, h = 2 * size.z, center = true, twist = i + 1);
+                else
+                    poly_cylinder(r = holes[i] / 2, h = size.z, center = false, twist = i + 1);
+    }
+}
+
+module polyholes() {
+    stl_colour(pp1_colour)
+        polyhole_stl();
+
+    positions()
         rod(d = 2 * $r, l = 8 * $r + 5);
     //
+    // Alternating polyholes
+    //
+    translate([30, -40])
+        alt_polyhole_stl();
+    //
     // Poly rings
     //
     ir = 3 / 2;
@@ -74,4 +104,11 @@ module polyholes() {
             }
 }
 
-polyholes();
+if($preview)
+    polyholes();
+else {
+    polyhole_stl();
+
+    translate([50, -20])
+        alt_polyhole_stl();
+}

tests/press_fit.scad

@@ -0,0 +1,71 @@
+//
+// NopSCADlib Copyright Chris Palmer 2020
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib is free software: you can redistribute it and/or modify it under the terms of the
+// GNU General Public License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+//
+
+include <../printed/press_fit.scad>
+
+module press_fits()
+{
+    thickness = 2;
+    width = 20;
+    vthickness = 4;
+
+    translate([0, width + 2])
+        difference() {
+            cube([width, width, thickness]);
+
+            for(x = [0.25, 0.75])
+                for(y = [0.25, 0.75])
+                    translate([x * width, y * width])
+                        press_fit_socket();
+        }
+
+    union() {
+        cube([width, width, thickness]);
+
+        for(x = [0.25, 0.75])
+            for(y = [0.25, 0.75])
+                translate([x * width, y * width, thickness])
+                    press_fit_peg(h = thickness);
+    }
+
+    translate([width + 2, width + 2])
+        difference() {
+            cube([width, vthickness, width]);
+
+            for(x = [0.25, 0.75])
+                for(y = [0.25, 0.75])
+                    translate([x, 0, y] * width)
+                        rotate([90, 0, 0])
+                            press_fit_socket();
+        }
+
+    translate([width + 2, 0])
+        union() {
+            cube([width, width, thickness]);
+
+            for(x = [0.25, 0.75])
+                for(y = [0.25, 0.75])
+                    translate([x * width, y * width, thickness])
+                        press_fit_peg(h = vthickness, horizontal = true);
+        }
+
+}
+
+
+press_fits();

tests/rails.scad

@@ -23,6 +23,7 @@ use <../utils/layout.scad>
 use <../vitamins/nut.scad>
 
 sheet = 3;
+pos = 1; //[-1 : 0.1 : 1]
 
 module rails()
     layout([for(l = rails) carriage_width(rail_carriage(l))], 20)
@@ -33,7 +34,7 @@ module rails()
             nut = screw_nut(screw);
             washer = screw_washer(screw);
 
-            rail_assembly(rail, length, rail_travel(rail, length) / 2, $i<2 ? grey(20) : "green", $i<2 ? grey(20) : "red");
+            rail_assembly(rail, length, pos * rail_travel(rail, length) / 2, $i<2 ? grey(20) : "green", $i<2 ? grey(20) : "red");
 
             rail_screws(rail, length, sheet + nut_thickness(nut, true) + washer_thickness(washer));
 

tests/rounded_rectangle.scad

@@ -25,6 +25,12 @@ module rounded_rectangles() {
 
     translate([40, 0])
         rounded_rectangle([30, 20, 10], 3);
+
+    translate([80, 0])
+        rounded_rectangle_xz([30, 20, 10], 3);
+
+    translate([120, 0])
+        rounded_rectangle_yz([30, 20, 10], 3);
 }
 
 rounded_rectangles();

tests/rounded_right_triangle.scad

@@ -0,0 +1,31 @@
+//
+// NopSCADlib Copyright Chris Palmer 2018
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib is free software: you can redistribute it and/or modify it under the terms of the
+// GNU General Public License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+//
+
+include <../global_defs.scad>
+use <../utils/rounded_right_triangle.scad>
+
+
+module rounded_right_triangles() {
+    rounded_right_triangle(10, 20, 5, 0.5);
+
+    translate([20, 0])
+        rounded_right_triangle(10, 20, 5, 0.5, offset = true);
+}
+
+rounded_right_triangles();

tests/screws.scad

@@ -18,20 +18,46 @@
 //
 include <../core.scad>
 
-module screws()
-for(y = [0 : len(screw_lists) -1])
-    for(x = [0 : len(screw_lists[y]) -1]) {
-        screw = screw_lists[y][x];
-        if(screw) {
-             length = screw_head_type(screw) == hs_grub ? 6
-                    : screw_radius(screw) <= 1.5 ? 10
-                    : screw_max_thread(screw) ? screw_longer_than(screw_max_thread(screw) + 5)
-                    : 30;
-            translate([x * 20, y * 20])
-                screw(screw, length);
-        }
+module polysink_stl() {
+    stl("polysink");
+
+    cs_screws = [for(list = screw_lists, screw = list) if(screw_head_type(screw) == hs_cs_cap) screw];
+    n = len(cs_screws);
+    size = [n * 20, 20, 10];
+    difference() {
+        translate([-size.x / n / 2, $preview ? 0 : -size.y / 2])
+            cube($preview ? [size.x, size.y / 2, size.z] : size);
+
+        for(i = [0 : n - 1])
+            let(s = cs_screws[i])
+                translate([i * 20, 0]) {
+                    translate_z(size.z)
+                        screw_polysink(s, 2 * size.z + 1);
+
+                    screw_polysink(s, 2 * size.z + 1, alt = true);
+                }
     }
+}
+
+module screws() {
+    for(y = [0 : len(screw_lists) -1])
+        for(x = [0 : len(screw_lists[y]) -1]) {
+            screw = screw_lists[y][x];
+            if(screw) {
+                 length = screw_head_type(screw) == hs_grub ? 6
+                        : screw_radius(screw) <= 1.5 ? 10
+                        : screw_max_thread(screw) ? screw_longer_than(screw_max_thread(screw) + 5)
+                        : 30;
+                translate([x * 20, y * 20])
+                    screw(screw, length);
+            }
+        }
+        translate([80, 20])
+            polysink_stl();
+}
 
 if($preview)
     let($show_threads = true)
         screws();
+else
+    polysink_stl();

tests/sheets.scad

@@ -20,12 +20,30 @@ include <../utils/core/core.scad>
 use <../utils/layout.scad>
 
 include <../vitamins/sheets.scad>
+include <../vitamins/screws.scad>
 
 width = 30;
+2d = true;
 
 module sheets()
     layout([for(s = sheets) width], 5)
-        render_sheet(sheets[$i]) sheet(sheets[$i], width, width, 2);
+        let(sheet = sheets[$i], w = sheet_is_woven(sheet) ? width : undef)
+        if(2d)
+            render_2D_sheet(sheet, w = w, d = w)
+                difference() {
+                    sheet_2D(sheet, width, width, 2);
+
+                    circle(3);
+                }
+        else
+            render_sheet(sheet, w = w, d = w)
+                difference() {
+                    sheet(sheet, width, width, 2);
+
+                    translate_z(sheet_thickness(sheet) / 2)
+                        screw_countersink(M3_cs_cap_screw);
+                }
+
 
 if($preview)
     sheets();

utils/bezier.scad

@@ -22,14 +22,14 @@
 //
 include <../global_defs.scad>
 
-function bezier(t, v) = //! Returns a point at distance ```t``` [0 - 1] along the curve with control points ```v```
+function bezier(t, v) = //! Returns a point at distance `t` [0 - 1] along the curve with control points `v`
     (len(v) > 2) ? bezier(t, [for (i = [0 : len(v) - 2]) v[i] * (1 - t) + v[i + 1] * (t)])
                  : v[0] * (1 - t) + v[1] * (t);
 
-function bezier_path(v, steps = 100) = //! Returns a Bezier path from control points ```v``` with ```steps``` segments
+function bezier_path(v, steps = 100) = //! Returns a Bezier path from control points `v` with `steps` segments
     [for(i = [0 : steps], t = i / steps) bezier(t, v)];
 
-function bezier_length(v, delta = 0.01, t = 0, length = 0) = //! Calculate the length of a Bezier curve from control points ```v```
+function bezier_length(v, delta = 0.01, t = 0, length = 0) = //! Calculate the length of a Bezier curve from control points `v`
     t > 1 ? length
           : bezier_length(v, delta, t + delta, length + norm(bezier(t, v) - bezier(t + delta, v)));
 
@@ -37,7 +37,7 @@ function adjust_bezier(v, r) =
     let(extension = (v[1] - v[0]) * (r - 1))
         [v[0], v[1] + extension, v[2] + extension, v[3]];
 
-function adjust_bezier_length(v, l, eps = 0.001, r1 = 1.0, r2 = 1.5, l1, l2) = //! Adjust Bezier control points ```v``` to get the required curve length ```l```
+function adjust_bezier_length(v, l, eps = 0.001, r1 = 1.0, r2 = 1.5, l1, l2) = //! Adjust Bezier control points `v` to get the required curve length `l`
     let(l1 = l1 != undef ? l1 : bezier_length(adjust_bezier(v, r1)),
         l2 = l2 != undef ? l2 : bezier_length(adjust_bezier(v, r2))
        ) abs(l1 - l) < eps ? adjust_bezier(v, r1)
@@ -45,10 +45,10 @@ function adjust_bezier_length(v, l, eps = 0.001, r1 = 1.0, r2 = 1.5, l1, l2) = /
                                  abs(r - r1) < abs(r - r2) ? adjust_bezier_length(v, l, eps, r, r1, undef, l1)
                                                            : adjust_bezier_length(v, l, eps, r, r2, undef, l2);
 
-function bezier_min_z(v, steps = 100, z = inf, i = 0) = //! Calculate the minimum z coordinate of a Bezier curve from control points ```v```
+function bezier_min_z(v, steps = 100, z = inf, i = 0) = //! Calculate the minimum z coordinate of a Bezier curve from control points `v`
      i <= steps ? bezier_min_z(v, steps, min(z, bezier(i / steps, v).z), i + 1) : z;
 
-function adjust_bezier_z(v, z, eps = 0.001, r1 = 1, r2 = 1.5, z1, z2) = //! Adjust Bezier control points ```v``` to get the required minimum ```z```
+function adjust_bezier_z(v, z, eps = 0.001, r1 = 1, r2 = 1.5, z1, z2) = //! Adjust Bezier control points `v` to get the required minimum `z`
     let(z1 = z1 != undef ? z1 : bezier_min_z(adjust_bezier(v, r1)),
         z2 = z2 != undef ? z2 : bezier_min_z(adjust_bezier(v, r2))
        ) abs(z1 - z) < eps ? adjust_bezier(v, r1)

utils/catenary.scad

@@ -20,25 +20,25 @@
 //
 //! Catenary curve to model hanging wires, etc.
 //!
-//! Although the equation of the curve is simply ```y = a cosh(x / a)``` there is no explicit formula to calculate the constant ```a``` or the range of ```x``` given the
+//! Although the equation of the curve is simply `y = a cosh(x / a)` there is no explicit formula to calculate the constant `a` or the range of `x` given the
 //! length of the cable and the end point coordinates. See <https://en.wikipedia.org/wiki/Catenary#Determining_parameters>. The Newton-Raphson method is used to find
-//! ```a``` numerically, see <https://en.wikipedia.org/wiki/Newton%27s_method>.
+//! `a` numerically, see <https://en.wikipedia.org/wiki/Newton%27s_method>.
 //!
-//! The coordinates of the lowest point on the curve can be retrieved by calling ```catenary_points()``` with ```steps``` equal to zero.
+//! The coordinates of the lowest point on the curve can be retrieved by calling `catenary_points()` with `steps` equal to zero.
 //
 include <core/core.scad>
 use <maths.scad>
 
 function catenary(t, a) = let(u = argsinh(t)) a * [u, cosh(u)]; //! Parametric catenary function linear along the length of the curve.
-function catenary_s(d, a) = 2 * a * sinh(d / a); //! Length of a symmetric catenary with width ```2d```.
-function catenary_ds_by_da(d, a) = 2 * sinh(d / a) - 2 * d / a * cosh(d / a); //! First derivative of the length with respect to ```a```.
+function catenary_s(d, a) = 2 * a * sinh(d / a); //! Length of a symmetric catenary with width `2d`.
+function catenary_ds_by_da(d, a) = 2 * sinh(d / a) - 2 * d / a * cosh(d / a); //! First derivative of the length with respect to `a`.
 
-function catenary_find_a(d, l, a = 1, best_e = inf, best_a = 1) =  //! Find the catenary constant ```a```, given half the horizontal span and the length.
+function catenary_find_a(d, l, a = 1, best_e = inf, best_a = 1) =  //! Find the catenary constant `a`, given half the horizontal span and the length.
      assert(l > 2 * d, "Not long enough to span the gap") assert(d) let(error = abs(catenary_s(d, a) - l))
      error >= best_e && error < 0.0001 ? best_a
                                        : catenary_find_a(d, l, max(a - (catenary_s(d, a) - l) / catenary_ds_by_da(d, a), d / argsinh(1e99)), error, a);
 
-function catenary_points(l, x, y, steps = 100) = //! Returns a list of 2D points on the curve that goes from the origin to ```(x,y)``` and has length ```l```.
+function catenary_points(l, x, y, steps = 100) = //! Returns a list of 2D points on the curve that goes from the origin to `(x,y)` and has length `l`.
     let(
         d = x / 2,
         a = catenary_find_a(d, sqrt(sqr(l) - sqr(y))),   // Find a to get the correct length

utils/core/bom.scad

@@ -18,24 +18,24 @@
 //
 
 //
-//! Bill Of Materials generation via echo and the ```bom.py``` script. Also handles exploded assembly views and posing.
+//! Bill Of Materials generation via echo and the `bom.py` script. Also handles exploded assembly views and posing.
 //! Assembly instructions can precede the module definition that makes the assembly.
 //!
 //! Assembly views shown in the instructions can be large or small and this is deduced by looking at the size of the printed parts involved and if any routed
 //! parts are used.
-//! This heuristic isn't always correct, so the default can be overridden by setting the ```big``` parameter of ```assembly``` to ```true``` or ```false```.
+//! This heuristic isn't always correct, so the default can be overridden by setting the `big` parameter of `assembly` to `true` or `false`.
 //!
 //! The example below shows how to define a vitamin and incorporate it into an assembly with sub-assemblies and make an exploded view.
 //! The resulting flat BOM is shown but heirachical BOMs are also generated for real projects.
 //
 function bom_mode(n = 1) = $_bom >= n && (is_undef($on_bom) || $on_bom);  //! Current BOM mode, 0 = none, 1 = printed and routed parts and assemblies, 2 includes vitamins as well
-function exploded() = is_undef($exploded_parent) ? $exploded : 0;   //! Returns the value of ```$exploded``` if it is defined, else ```0```
+function exploded() = is_undef($exploded_parent) ? $exploded : 0;   //! Returns the value of `$exploded` if it is defined, else `0`
 function show_supports() = !$preview || exploded();                 //! True if printed support material should be shown
 
 module no_explode() let($exploded_parent = true) children();        //! Prevent children being exploded
 module no_pose() let($posed = true) children();                     //! Force children not to be posed even if parent is
 
-module explode(d, explode_children = false, offset = [0,0,0]) {     //! Explode children by specified Z distance or vector ```d```, option to explode grand children
+module explode(d, explode_children = false, offset = [0,0,0]) {     //! Explode children by specified Z distance or vector `d`, option to explode grand children
     v = is_list(d) ? d : [0, 0, d];
     o = is_list(offset) ? offset : [0, 0, offset];
     if($exploded && is_undef($exploded_parent) && norm(v)) {
@@ -55,7 +55,7 @@ module explode(d, explode_children = false, offset = [0,0,0]) {     //! Explode
         children();
 }
 
-module pose(a = [55, 0, 25], t = [0, 0, 0], exploded = undef)       //! Pose an STL or assembly for rendering to png by specifying rotation ```a``` and translation ```t```, ```exploded = true for``` just the exploded view or ```false``` for unexploded only.
+module pose(a = [55, 0, 25], t = [0, 0, 0], exploded = undef)       //! Pose an STL or assembly for rendering to png by specifying rotation `a` and translation `t`, `exploded = true for` just the exploded view or `false` for unexploded only.
     if(is_undef($pose) || !is_undef($posed) || (!is_undef(exploded) && exploded != !!exploded()))
         children();
     else
@@ -67,7 +67,7 @@ module pose(a = [55, 0, 25], t = [0, 0, 0], exploded = undef)       //! Pose an
                             translate(-t)
                                 children();
 
-module pose_hflip(exploded = undef)       //! Pose an STL or assembly for rendering to png by flipping around the Y axis, ```exploded = true for``` just the exploded view or ```false``` for unexploded only.
+module pose_hflip(exploded = undef)       //! Pose an STL or assembly for rendering to png by flipping around the Y axis, `exploded = true for` just the exploded view or `false` for unexploded only.
     if(is_undef($pose) || !is_undef($posed) || (!is_undef(exploded) && exploded != !!exploded()))
         children();
     else
@@ -75,7 +75,7 @@ module pose_hflip(exploded = undef)       //! Pose an STL or assembly for render
             hflip()
                 children();
 
-module pose_vflip(exploded = undef)       //! Pose an STL or assembly for rendering to png by flipping around the X axis, ```exploded = true for``` just the exploded view or ```false``` for unexploded only.
+module pose_vflip(exploded = undef)       //! Pose an STL or assembly for rendering to png by flipping around the X axis, `exploded = true for` just the exploded view or `false` for unexploded only.
     if(is_undef($pose) || !is_undef($posed) || (!is_undef(exploded) && exploded != !!exploded()))
         children();
     else
@@ -84,7 +84,7 @@ module pose_vflip(exploded = undef)       //! Pose an STL or assembly for render
                 children();
 
 
-module assembly(name, big = undef) {    //! Name an assembly that will appear on the BOM, there needs to a module named ```<name>_assembly``` to make it. ```big``` can force big or small assembly diagrams.
+module assembly(name, big = undef) {    //! Name an assembly that will appear on the BOM, there needs to a module named `<name>_assembly` to make it. `big` can force big or small assembly diagrams.
     if(bom_mode()) {
         args = is_undef(big) ? "" : str("(big=", big, ")");
         echo(str("~", name, "_assembly", args, "{"));
@@ -101,20 +101,20 @@ module assembly(name, big = undef) {    //! Name an assembly that will appear on
         echo(str("~}", name, "_assembly"));
 }
 
-module stl_colour(colour = pp1_colour, alpha = 1) { //! Colour an stl where it is placed in an assembly. ```alpha``` can be used to make it appear transparent.
+module stl_colour(colour = pp1_colour, alpha = 1) { //! Colour an stl where it is placed in an assembly. `alpha` can be used to make it appear transparent.
     $stl_colour = colour;
     color(colour, alpha)
         children();
 }
 
-module stl(name) {                      //! Name an stl that will appear on the BOM, there needs to a module named ```<name>_stl``` to make it
+module stl(name) {                      //! Name an stl that will appear on the BOM, there needs to a module named `<name>_stl` to make it
     if(bom_mode()) {
         colour = is_undef($stl_colour) ? pp1_colour : $stl_colour;
         echo(str("~", name, ".stl(colour='", colour, "')"));
     }
 }
 
-module dxf(name) {                      //! Name a dxf that will appear on the BOM, there needs to a module named ```<name>_dxf``` to make it
+module dxf(name) {                      //! Name a dxf that will appear on the BOM, there needs to a module named `<name>_dxf` to make it
     if(bom_mode()) {
         if(is_undef($dxf_colour))
             echo(str("~", name, ".dxf"));
@@ -123,9 +123,9 @@ module dxf(name) {                      //! Name a dxf that will appear on the B
     }
 }
 
-function value_string(value) = is_string(value) ? str("\"", value, "\"") : str(value); //! Convert ```value``` to a string or quote it if it is already a string
+function value_string(value) = is_string(value) ? str("\"", value, "\"") : str(value); //! Convert `value` to a string or quote it if it is already a string
 
-function arg(value, default, name = "") =   //! Create string for arg if not default, helper for ```vitamin()```
+function arg(value, default, name = "") =   //! Create string for arg if not default, helper for `vitamin()`
     value == default ? ""
                      : name ? str(", ", name, " = ", value_string(value))
                             : str(", ", value_string(value));

utils/core/global.scad

@@ -29,18 +29,18 @@ function mm(x)   = x;
 function cm(x)   = x * 10.0;                                                        //! cm to mm conversion
 function m(x)    = x * 1000.0;                                                      //! m to mm conversion
 
-function sqr(x) = x * x;                                                            //! Returns the square of ```x```
+function sqr(x) = x * x;                                                            //! Returns the square of `x`
 function echoit(x) = echo(x) x;                                                     //! Echo expression and return it, useful for debugging
 function no_point(str) = chr([for(c = str(str)) if(c == ".") ord("p") else ord(c)]);//! Replace decimal point in string with 'p'
-function in(list, x) = !!len([for(v = list) if(v == x) true]);                      //! Returns true if ```x``` is an element in the ```list```
-function Len(x) = is_list(x) ? len(x) : 0;                                          //! Returns the length of a list or 0 if ```x``` is not a list
+function in(list, x) = !!len([for(v = list) if(v == x) true]);                      //! Returns true if `x` is an element in the `list`
+function Len(x) = is_list(x) ? len(x) : 0;                                          //! Returns the length of a list or 0 if `x` is not a list
 function r2sides(r) = $fn ? $fn : ceil(max(min(360/ $fa, r * 2 * PI / $fs), 5));    //! Replicates the OpenSCAD logic to calculate the number of sides from the radius
 function r2sides4n(r) = floor((r2sides(r) + 3) / 4) * 4;                            //! Round up the number of sides to a multiple of 4 to ensure points land on all axes
 function limit(x, min, max) = max(min(x, max), min);                                //! Force x in range min <= x <= max
 
 module translate_z(z) translate([0, 0, z]) children();                              //! Shortcut for Z only translations
-module vflip() rotate([180, 0, 0]) children();                                      //! Invert children by doing a 180&deg; flip around the X axis
-module hflip() rotate([0, 180, 0]) children();                                      //! Invert children by doing a 180&deg; flip around the Y axis
+module vflip(flip=true) rotate([flip ? 180 : 0, 0, 0]) children();                  //! Invert children by doing a 180&deg; flip around the X axis
+module hflip(flip=true) rotate([0, flip ? 180: 0, 0]) children();                   //! Invert children by doing a 180&deg; flip around the Y axis
 module ellipse(xr, yr) scale([1, yr / xr]) circle4n(xr);                            //! Draw an ellipse
 
 function slice_str(str, start, end, s ="") = start >= end ? s : slice_str(str, start + 1, end, str(s, str[start])); // Helper for slice()
@@ -52,7 +52,14 @@ function slice(list, start = 0, end = undef) = let( //! Slice a list or string w
     ) is_string(list) ? slice_str(list, start, end) : [for(i = [start : 1 : end - 1]) list[i]];
 
 
-module extrude_if(h, center = true)                 //! Extrudes 2D object to 3D when ```h``` is nonzero, otherwise leaves it 2D
+module render_if(render = true, convexity = 2)      //! Renders an object if `render` is true, otherwise leaves it unrendered
+    if (render)
+        render(convexity = convexity)
+            children();
+    else
+        children();
+
+module extrude_if(h, center = true)                 //! Extrudes 2D object to 3D when `h` is nonzero, otherwise leaves it 2D
     if(h)
         linear_extrude(h, center = center, convexity = 2) // 3D
             children();
@@ -74,7 +81,7 @@ module semi_circle(r, d = undef)                    //! A semi circle in the pos
             square([2 * sq, sq]);
     }
 
-module right_triangle(width, height, h, center = true) //! A right angled triangle with the 90&deg; corner at the origin. 3D when ```h``` is nonzero, otherwise 2D
+module right_triangle(width, height, h, center = true) //! A right angled triangle with the 90&deg; corner at the origin. 3D when `h` is nonzero, otherwise 2D
     extrude_if(h, center = center)
         polygon(points = [[0,0], [width, 0], [0, height]]);
 

utils/core/polyholes.scad

@@ -22,6 +22,16 @@
 //! it gets the linear dimensions right. See <https://hydraraptor.blogspot.com/2011/02/polyholes.html>
 //!
 //! The module provides `poly_circle()`, `poly_cylinder()` and `poly_ring()` that is useful for making printed washers and pillars.
+//!
+//! `poly_cylinder()` has a `twist` parameter which can be set to make the polygon rotate each layer.
+//! This can be used to mitigate the number of sides being small and make small holes stronger and more round, but is quite slow due to the
+//! large increase in the number of facets.
+//! When set to 1 the polygons alternate each layer, when set higher the rotation takes `twist + 1` layers to repeat.
+//! A small additional rotation is added to make the polygon rotate one more side over the length of the hole to make it appear round when
+//! veiwed end on.
+//!
+//! When `twist` is set the resulting cylinder is extended by `eps` at each end so that the exact length of the hole can be used without
+//! leaving a scar on either surface.
 //
 function sides(r) = max(round(4 * r), 3);                                       //! Optimium number of sides for specified radius
 function corrected_radius(r, n = 0)   = r / cos(180 / (n ? n : sides(r)));      //! Adjusted radius to make flats lie on the circle
@@ -32,9 +42,26 @@ module poly_circle(r, sides = 0) { //! Make a circle adjusted to print the corre
     circle(r = corrected_radius(r,n), $fn = n);
 }
 
-module poly_cylinder(r, h, center = false, sides = 0, chamfer = false) {//! Make a cylinder adjusted to print the correct size
-    extrude_if(h, center)
-        poly_circle(r, sides);
+module poly_cylinder(r, h, center = false, sides = 0, chamfer = false, twist = 0) {//! Make a cylinder adjusted to print the correct size
+    if(twist) {
+        slices = ceil(h / layer_height);
+        twists = min(twist + 1, slices);
+        sides = sides ? sides : sides(r);
+        rot = 360 / sides / twists * (twists < slices ? (1 + 1 / slices) : 1);
+        if(center)
+            for(side = [0, 1])
+                mirror([0, 0, side])
+                    poly_cylinder(r = r, h = h / 2, sides = sides, twist = twist);
+        else
+            render(convexity = 5)
+                for(i = [0 : slices - 1])
+                    translate_z(i * layer_height - eps)
+                        rotate(rot * i)
+                            poly_cylinder(r = r, h = layer_height + 2 * eps, sides = sides);
+    }
+    else
+        extrude_if(h, center)
+            poly_circle(r, sides);
 
     if(h && chamfer)
         poly_cylinder(r + layer_height, center ? layer_height * 2 : layer_height, center, sides = sides ? sides : sides(r));

utils/core/rounded_rectangle.scad

@@ -20,14 +20,28 @@
 //
 //! Rectangle with rounded corners.
 //
-module rounded_square(size, r, center = true) //! Like ```square()``` but with with rounded corners
+module rounded_square(size, r, center = true) //! Like `square()` but with with rounded corners
 {
     $fn = r2sides4n(r);
     offset(r) offset(-r) square(size, center = center);
 }
 
-module rounded_rectangle(size, r, center = true, xy_center = true) //! Like ```cube()``` but corners rounded in XY plane and separate centre options for xy and z.
+module rounded_rectangle(size, r, center = true, xy_center = true) //! Like `cube()` but corners rounded in XY plane and separate centre options for xy and z.
 {
-    linear_extrude(size[2], center = center)
-        rounded_square([size[0], size[1]], r, xy_center);
+    linear_extrude(size.z, center = center)
+        rounded_square([size.x, size.y], r, xy_center);
+}
+
+module rounded_rectangle_xz(size, r, center = true, xy_center = true) //! Like `cube()` but corners rounded in XZ plane and separate centre options for xy and z.
+{
+    translate([xy_center ? 0 : size.x / 2, xy_center ? 0 : size.y / 2, center ? 0 : size.z / 2])
+        rotate([90, 0, 0])
+            rounded_rectangle([size.x, size.z, size.y], r, center = true, xy_center = true);
+}
+
+module rounded_rectangle_yz(size, r, center = true, xy_center = true) //! Like `cube()` but corners rounded in YX plane and separate centre options for xy and z.
+{
+    translate([xy_center ? 0 : size.x / 2, xy_center ? 0 : size.y / 2, center ? 0 : size.z / 2])
+        rotate([90, 0, 90])
+            rounded_rectangle([size.y, size.z, size.x], r, center = true, xy_center = true);
 }

utils/core/sphere.scad

@@ -20,7 +20,7 @@
 //! Redefines `sphere()` to always have a vertex on all six half axes I.e. vertices at the poles and the equator and `$fn` a multiple of four.
 //! This ensures `hull` and `minkowski` results have the correct dimensions when spheres are placed at the corners.
 
-module sphere(r = 1, d = undef) {                   //! Override ```sphere``` so that has vertices on all three axes. Has the advantage of giving correct dimensions when hulled
+module sphere(r = 1, d = undef) {                   //! Override `sphere` so that has vertices on all three axes. Has the advantage of giving correct dimensions when hulled
     R = is_undef(d) ? r : d / 2;
     rotate_extrude($fn = r2sides4n(R))
         rotate(-90)

utils/core/teardrops.scad

@@ -24,7 +24,7 @@
 //! Using teardrop_plus() or setting the plus option on other modules will elongate the teardrop vertically by the layer height, so when sliced the staircase tips
 //! do not intrude into the circle. See <https://hydraraptor.blogspot.com/2020/07/horiholes-2.html>
 //
-module teardrop(h, r, center = true, truncate = true, chamfer = 0, plus = false) { //! For making horizontal holes that don't need support material, set ```truncate = false``` to make traditional RepRap teardrops that don't even need bridging
+module teardrop(h, r, center = true, truncate = true, chamfer = 0, plus = false) { //! For making horizontal holes that don't need support material, set `truncate = false` to make traditional RepRap teardrops that don't even need bridging
     module teardrop_2d(r, truncate) {
         er = layer_height / 2 - eps;    // Extrustion edge radius
         R = plus ? r + er : r;          // Corrected radius

utils/dogbones.scad

@@ -23,24 +23,36 @@
 //
 include <../utils/core/core.scad>
 
-module dogbone_square(size, r = cnc_bit_r, center = true) //! Square with circles at the corners
+module dogbone_square(size, r = cnc_bit_r, center = true, x_offset, y_offset) //! Square with circles at the corners, with optional offsets
 {
+    x_offset = is_undef(x_offset) ? r / sqrt(2) : x_offset;
+    y_offset = is_undef(y_offset) ? r / sqrt(2) : y_offset;
+
     union() {
         square(size, center = center);
 
         if(r > 0) {
             origin = center ? [0, 0] : size / 2;
-            offset = r / sqrt(2);
 
             for(x = [-1, 1], y = [-1, 1])
-                translate(origin + [x * (size.x / 2 - offset), y * (size.y / 2 - offset)])
+                translate(origin + [x * (size.x / 2 - x_offset), y * (size.y / 2 - y_offset)])
                     drill(r, 0);
         }
     }
 }
 
-module dogbone_rectangle(size, r = cnc_bit_r, center = true, xy_center = true) //! Rectangle with cylinders at the corners
+module dogbone_rectangle(size, r = cnc_bit_r, center = true, xy_center = true, x_offset, y_offset) //! Rectangle with cylinders at the corners
 {
     extrude_if(h = size.z, center = center)
-        dogbone_square([size.x, size.y], r, xy_center);
+        dogbone_square([size.x, size.y], r, xy_center, x_offset, y_offset);
+}
+
+module dogbone_rectangle_x(size, r = cnc_bit_r, center = true, xy_center = true) //! Rectangle with cylinders at the corners, offset in the x direction
+{
+    dogbone_rectangle(size = size, r = r, center = center, x_offset = 0, y_offset = r);
+}
+
+module dogbone_rectangle_y(size, r = cnc_bit_r, center = true, xy_center = true) //! Rectangle with cylinders at the corners, offset in the y direction
+{
+    dogbone_rectangle(size = size, r = r, center = center, x_offset = r, y_offset = 0);
 }

utils/gears.scad

@@ -24,17 +24,17 @@
 //! <https://khkgears.net/new/gear_knowledge/gear_technical_reference/calculation_gear_dimensions.html>
 //! and <https://www.tec-science.com/mechanical-power-transmission/involute-gear/calculation-of-involute-gears/>
 //!
-//! ```involute_gear_profile()``` returns a polygon that can have the bore and spokes, etc, subtracted from it before linear extruding it to 3D.
-//! Helical gears can be made using ```twist``` and bevel gears using ```scale``` parameters of ```linear_extrude()```.
+//! `involute_gear_profile()` returns a polygon that can have the bore and spokes, etc, subtracted from it before linear extruding it to 3D.
+//! Helical gears can be made using `twist` and bevel gears using `scale` parameters of `linear_extrude()`.
 //!
 //! Gears with less than 19 teeth (when pressure angle is 20) are profile shifted to avoid undercutting the tooth root. 7 teeth is considered
 //! the practical minimum.
 //!
-//! The clearance between tip and root defaults to module / 6, but can be overridden by setting the ```clearance``` parameter.
+//! The clearance between tip and root defaults to module / 6, but can be overridden by setting the `clearance` parameter.
 //!
 //! The origin of the rack is the left end of the pitch line and its width is below the pitch line. I.e. it does not include the addendum.
 //!
-//! ```involute_worm_profile()``` returns a tooth profile that can be passed to ```thread()``` to make worms.
+//! `involute_worm_profile()` returns a tooth profile that can be passed to `thread()` to make worms.
 //
 include <core/core.scad>
 use <maths.scad>

utils/hanging_hole.scad

@@ -22,7 +22,7 @@
 //
 include <../utils/core/core.scad>
 
-module hanging_hole(z, ir, h = 100, h2 = 100) { //! Hole radius ```ir``` hanging at the specified ```z``` value above a void who's shape is given by a 2D child
+module hanging_hole(z, ir, h = 100, h2 = 100) { //! Hole radius `ir` hanging at the specified `z` value above a void who's shape is given by a 2D child
     module polyhole(r, h, n = 8) {
         if(h > 0)
             rotate(180 / n) {
@@ -35,7 +35,7 @@ module hanging_hole(z, ir, h = 100, h2 = 100) { //! Hole radius ```ir``` hanging
                         poly_cylinder(r - eps, h - layer_height);
             }
     }
-    assert(z % layer_height == 0, str(z));
+    assert(z - layer_height * floor(z / layer_height) < eps, str(z));
     infill_angle = z % (2 * layer_height) ? -45 : 45;
     below = min(z + eps, h2);
     big = 1000;

utils/horiholes.scad

@@ -20,7 +20,7 @@
 //
 //! Utilities for depicting the staircase slicing of horizontal holes made with [`teardrop_plus()`](#teardrops), see <https://hydraraptor.blogspot.com/2020/07/horiholes-2.html>
 //!
-//! ```horicylinder()``` makes cylinders that fit inside a round hole. Layers that are less than 2 filaments wide and layers that need more than a 45 degree overhang are omitted.
+//! `horicylinder()` makes cylinders that fit inside a round hole. Layers that are less than 2 filaments wide and layers that need more than a 45 degree overhang are omitted.
 //
 include <../utils/core/core.scad>
 

utils/layout.scad

@@ -22,11 +22,11 @@
 //
 include <../global_defs.scad>
 
-function layout_offset(widths, i, gap = 2) = //! Calculate the offset for the ```i```th item
+function layout_offset(widths, i, gap = 2) = //! Calculate the offset for the `i`th item
     i == 0 ? widths[0] / 2
            : layout_offset(widths, i - 1, gap) + widths[i - 1] / 2 + gap + widths[i] / 2;
 
-module layout(widths, gap = 2, no_offset = false) //! Layout children passing ```$i```
+module layout(widths, gap = 2, no_offset = false) //! Layout children passing `$i`
     translate([no_offset ? -widths[0] / 2 : 0, 0])
         for($i = [0 : 1 : len(widths) - 1])
             translate([layout_offset(widths, $i, gap), 0])

utils/maths.scad

@@ -33,7 +33,7 @@ function argcosh(x) = ln(x + sqrt(sqr(x) - 1)); //! inverse hyperbolic cosine
 function argtanh(x) = ln((1 + x) / (1 - x)) / 2;//! inverse hyperbolic tangent
 function argcoth(x) = ln((x + 1) / (x - 1)) / 2;//! inverse hyperbolic cotangent
 
-function translate(v) = let(u = is_list(v) ? len(v) == 2 ? [v.x, v.y, 0] //! Generate a 4x4 translation matrix, ```v``` can be ```[x, y]```, ```[x, y, z]``` or ```z```
+function translate(v) = let(u = is_list(v) ? len(v) == 2 ? [v.x, v.y, 0] //! Generate a 4x4 translation matrix, `v` can be `[x, y]`, `[x, y, z]` or `z`
                                                          : v
                                            : [0, 0, v])
                           [ [1, 0, 0, u.x],
@@ -41,7 +41,7 @@ function translate(v) = let(u = is_list(v) ? len(v) == 2 ? [v.x, v.y, 0] //! Gen
                             [0, 0, 1, u.z],
                             [0, 0, 0,   1] ];
 
-function rotate(a, v) = //! Generate a 4x4 rotation matrix, ```a``` can be a vector of three angles or a single angle around ```z```, or around axis ```v```
+function rotate(a, v) = //! Generate a 4x4 rotation matrix, `a` can be a vector of three angles or a single angle around `z`, or around axis `v`
     is_undef(v) ? let(av = is_list(a) ? a : [0, 0, a],
                       cx = cos(av[0]),
                       cy = cos(av[1]),
@@ -80,7 +80,7 @@ function rot2_z(a) = //! Generate a 2x2 matrix to rotate around z
         [ [ c, -s],
           [ s,  c] ];
 
-function scale(v) = let(s = is_list(v) ? v : [v, v, v]) //!  Generate a 4x4 matrix that scales by ```v```, which can be a vector of xyz factors or a scalar to scale all axes equally
+function scale(v) = let(s = is_list(v) ? v : [v, v, v]) //!  Generate a 4x4 matrix that scales by `v`, which can be a vector of xyz factors or a scalar to scale all axes equally
                         [
                           [s.x, 0,   0,   0],
                           [0,   s.y, 0,   0],
@@ -88,11 +88,11 @@ function scale(v) = let(s = is_list(v) ? v : [v, v, v]) //!  Generate a 4x4 matr
                           [0,   0,   0,   1]
                         ];
 
-function vec3(v) = [v.x, v.y, v.z]; //! Return a 3 vector with the first three elements of ```v```
-function vec4(v) = [v.x, v.y, v.z, 1]; //! Return a 4 vector with the first three elements of ```v```
+function vec3(v) = [v.x, v.y, v.z]; //! Return a 3 vector with the first three elements of `v`
+function vec4(v) = [v.x, v.y, v.z, 1]; //! Return a 4 vector with the first three elements of `v`
 function transform(v, m) = vec3(m * [v.x, v.y, v.z, 1]); //! Apply 4x4 transform to a 3 vector by extending it and cropping it again
 function transform_points(path, m) = [for(p = path) transform(p, m)]; //! Apply transform to a path
-function unit(v) = let(n = norm(v)) n ? v / n : v; //! Convert ```v``` to a unit vector
+function unit(v) = let(n = norm(v)) n ? v / n : v; //! Convert `v` to a unit vector
 
 function transpose(m) = [ for(j = [0 : len(m[0]) - 1]) [ for(i = [0 : len(m) - 1]) m[i][j] ] ]; //! Transpose an arbitrary size matrix
 

utils/offset.scad

@@ -24,7 +24,7 @@
 //! If `chamfer_base` is true then the bottom edge is made suitable for 3D printing by chamfering when the angle gets shallower than 45 degrees.
 include <../utils/core/core.scad>
 
-module offset_3D(r, chamfer_base = false) { //! Offset 3D shape by specified radius ```r```, positive or negative.
+module offset_3D(r, chamfer_base = false) { //! Offset 3D shape by specified radius `r`, positive or negative.
     module ball(r)
         if(chamfer_base)
             rotate_extrude()

utils/quadrant.scad

@@ -22,7 +22,7 @@
 //
 include <../utils/core/core.scad>
 
-module quadrant(w, r, center = false) { //! Draw a square with one rounded corner, can be centered on the arc centre, when ```center``` is ```true```.
+module quadrant(w, r, center = false) { //! Draw a square with one rounded corner, can be centered on the arc centre, when `center` is `true`.
     h = is_list(w) ? w.y : w;
     w = is_list(w) ? w.x : w;
     offset_w = center ? r - w : 0;

utils/rounded_cylinder.scad

@@ -40,7 +40,7 @@ module rounded_corner(r, h, r2, ir = 0) { //! 2D version
         }
 }
 
-module rounded_cylinder(r, h, r2, ir = 0, angle = 360) //! Rounded cylinder given radius ```r```, height ```h```, optional internal radius ```ir``` and optional ```angle```
+module rounded_cylinder(r, h, r2, ir = 0, angle = 360) //! Rounded cylinder given radius `r`, height `h`, optional internal radius `ir` and optional `angle`
 {
     rotate_extrude(angle = angle)
         rounded_corner(r, h, r2, ir);

utils/rounded_polygon.scad

@@ -48,7 +48,7 @@ function rounded_polygon_tangents(points) = //! Compute the straight sections ne
 function sumv(v, i = 0, sum = 0) = i == len(v) ? sum : sumv(v, i + 1, sum + v[i]);
 
 // the cross product of 2D vectors is the area of the parallelogram between them. We use the sign of this to decide if the angle is bigger than 180.
-function rounded_polygon_length(points, tangents) = //! Calculate the length given the point list and the list of tangents computed by ``` rounded_polygon_tangents```
+function rounded_polygon_length(points, tangents) = //! Calculate the length given the point list and the list of tangents computed by ` rounded_polygon_tangents`
     let(
       len = len(points),
       indices = [0 : len - 1],
@@ -60,7 +60,7 @@ function rounded_polygon_length(points, tangents) = //! Calculate the length giv
                                    v1 = p1 - c,
                                    v2 = p2 - c,
                                    r = abs(corner.z),
-                                   a = acos((v1 * v2) / sqr(r))) PI * (cross(v1,v2) <= 0 ? a : 360 - a) * r / 180]
+                                   a = acos((v1 * v2) / sqr(r))) r ? PI * (cross(v1, v2) <= 0 ? a : 360 - a) * r / 180 : 0]
      )
     sumv(concat(straights, arcs));
 

utils/rounded_right_triangle.scad

@@ -0,0 +1,46 @@
+//
+// NopSCADlib Copyright Chris Palmer 2018
+// nop.head@gmail.com
+// hydraraptor.blogspot.com
+//
+// This file is part of NopSCADlib.
+//
+// NopSCADlib is free software: you can redistribute it and/or modify it under the terms of the
+// GNU General Public License as published by the Free Software Foundation, either version 3 of
+// the License, or (at your option) any later version.
+//
+// NopSCADlib is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with NopSCADlib.
+// If not, see <https://www.gnu.org/licenses/>.
+//
+
+//
+//! Draw a 3D right triangle with rounded edges. Intended to be embedded in other parts. Can be optionally offset by the filleted amount.
+//
+include <../utils/core/core.scad>
+include <NopSCADlib/utils/core/rounded_rectangle.scad>
+
+module rounded_right_triangle(x, y, z, fillet, center = true, offset = false) { //! Draw a 3D right triangle with rounded edges.
+    fillet = max(fillet, eps);
+    size = [x + (offset ? 2 * fillet : 0), y + (offset ? 2 * fillet : 0), z];
+
+    translate([offset ? -2 * fillet : 0, offset ? -2 * fillet : 0, center ? 0 : size.z / 2])
+        hull() {
+            translate([0, fillet, size.z / 2])
+                rotate([90, 90, 0])
+                    rounded_rectangle([size.z, 2 * fillet, eps], fillet - eps, center = false, xy_center = false);
+            translate([0, size.y, size.z / 2])
+                rotate([90, 90, 0])
+                    rounded_rectangle([size.z, 2 * fillet, eps], fillet - eps, center = false, xy_center = false);
+            translate([fillet, 0, size.z / 2])
+                rotate([0, 90, 0])
+                    rounded_rectangle([size.z, 2 * fillet, eps], fillet - eps, center = false, xy_center = false);
+            translate([size.x, 0, size.z / 2])
+                rotate([0, 90, 0])
+                    rounded_rectangle([size.z, 2 * fillet, eps], fillet - eps, center = false, xy_center = false);
+        }
+}
+

utils/sector.scad

@@ -22,7 +22,7 @@
 //
 include <../utils/core/core.scad>
 
-module sector(r, start_angle, end_angle) { //! Create specified sector given radius ```r```, ```start_angle``` and ```end_angle```
+module sector(r, start_angle, end_angle) { //! Create specified sector given radius `r`, `start_angle` and `end_angle`
     R = r * sqrt(2) + 1;
 
     if(end_angle > start_angle)

utils/sweep.scad

@@ -21,7 +21,7 @@
 //! Utility to generate a polhedron by sweeping a 2D profile along a 3D path and utilities for generating paths.
 //!
 //! The initial orientation is the Y axis of the profile points towards the initial center of curvature, Frenet-Serret style.
-//! This means the first three points must not be colinear. Subsequent rotations use the minimum rotation method.
+//! Subsequent rotations use the minimum rotation method.
 //!
 //! The path can be open or closed. If closed sweep ensures that the start and end have the same rotation to line up.
 //! An additional twist around the path can be specified. If the path is closed this should be a multiple of 360.
@@ -172,10 +172,10 @@ function arc_points(r, a = [90, 0, 180], al = 90) = //! Generate the points of a
    let(sides = ceil(r2sides(r) * al / 360), tf = rotate(a))
     [for(i = [0 : sides]) let(t = i * al / sides) transform([r * sin(t), r * cos(t), 0], tf)];
 
-function before(path1, path2) =  //! Translate ```path1``` so its end meets the start of ```path2``` and then concatenate
+function before(path1, path2) =  //! Translate `path1` so its end meets the start of `path2` and then concatenate
     let(end = len(path1) - 1, offset = path2[0] - path1[end])
         concat([for(i = [0 : end - 1]) path1[i] + offset], path2);
 
-function after(path1, path2) =  //! Translate ```path2``` so its start meets the end of ```path1``` and then concatenate
+function after(path1, path2) =  //! Translate `path2` so its start meets the end of `path1` and then concatenate
     let(end1 = len(path1) - 1, end2 = len(path2) - 1, offset = path1[end1] - path2[0])
         concat(path1, [for(i = [1 : end2]) path2[i] + offset]);

utils/thread.scad

@@ -20,7 +20,7 @@
 //
 //! Utilities for making threads with sweep. They can be used to model screws, nuts, studding, leadscrews, etc, and also to make printed threads.
 //!
-//! The ends can be tapered, flat or chamfered by setting the ```top``` and ```bot``` parameters to -1 for tapered, 0 for a flat cut and positive to
+//! The ends can be tapered, flat or chamfered by setting the `top` and `bot` parameters to -1 for tapered, 0 for a flat cut and positive to
 //! specify a chamfer angle.
 //!
 //! Threads are by default solid, so the male version is wrapped around a cylinder and the female inside a tube. This can be suppressed to just get the helix, for
@@ -32,8 +32,8 @@
 //! a cylinder. To get around this a colour can be passed to thread that is used to colour the cylinder and then toned down to colour the helix.
 //!
 //! Making the ends requires a CGAL intersection, which make threads relatively slow. For this reason they are generally disabled when using the GUI but can
-//! be enabled by setting ```$show_threads``` to ```true```. When the tests are run, by default, threads are enabled only for things that feature them like screws.
-//! This behaviour can be changed by setting a ```NOPSCADLIB_SHOW_THREADS``` environment variable to ```false``` to disable all threads and ```true``` to enable all threads.
+//! be enabled by setting `$show_threads` to `true`. When the tests are run, by default, threads are enabled only for things that feature them like screws.
+//! This behaviour can be changed by setting a `NOPSCADLIB_SHOW_THREADS` environment variable to `false` to disable all threads and `true` to enable all threads.
 //! The same variable also affects the generation of assembly diagrams.
 //!
 //! Threads obey the $fn, $fa, $fs variables.

utils/tube.scad

@@ -28,11 +28,11 @@ module ring(or, ir) //! Create a ring with specified external and internal radii
             circle4n(ir);
         }
 
-module tube(or, ir, h, center = true) //! Create a tube with specified external and internal radii and height ```h```
+module tube(or, ir, h, center = true) //! Create a tube with specified external and internal radii and height `h`
     linear_extrude(h, center = center, convexity = 5)
         ring(or, ir);
 
-module woven_tube(or, ir, h, center= true, colour = grey(30), colour2, warp = 2, weft) {//! Create a woven tube with specified external and internal radii, height ```h```, colours, warp and weft
+module woven_tube(or, ir, h, center= true, colour = grey(30), colour2, warp = 2, weft) {//! Create a woven tube with specified external and internal radii, height `h`, colours, warp and weft
     colour2 = colour2 ? colour2 : colour * 0.8;
     weft = weft ? weft : warp;
     warp_count = max(floor(PI * or / warp), 0.5);
@@ -68,4 +68,3 @@ module woven_tube(or, ir, h, center= true, colour = grey(30), colour2, warp = 2,
         }
     }
 }
-

vitamins/axial.scad

@@ -74,7 +74,7 @@ module orientate_axial(length, height, pitch, wire_d) { // Orient horizontal or
    }
 }
 
-module ax_res(type, value, tol = 5, pitch = 0) { //! Through hole axial resistor. If ```pitch``` is zero the minimum is used. If below the minimum the resistor is placed vertical.
+module ax_res(type, value, tol = 5, pitch = 0) { //! Through hole axial resistor. If `pitch` is zero the minimum is used. If below the minimum the resistor is placed vertical.
     vitamin(str("ax_res(", type[0], ", ", value, arg(tol, 5, "tol"), "): Resistor ", value, " Ohms ", tol, "% ",ax_res_wattage(type), "W"));
 
     wire_d =  ax_res_wire(type);

vitamins/belt.scad

@@ -24,7 +24,7 @@
 //! To make the back of the belt run against a smooth pulley on the outside of the loop specify a negative pitch radius.
 //!
 //! By default the path is a closed loop but a gap length and position can be specified to make open loops.
-//! To draw the gap its XY position is specified by ```gap_pos```. ```gap_pos.z``` can be used to specify a rotation if the gap is not at the bottom of the loop.
+//! To draw the gap its XY position is specified by `gap_pos`. `gap_pos.z` can be used to specify a rotation if the gap is not at the bottom of the loop.
 //!
 //! Individual teeth are not drawn, instead they are represented by a lighter colour.
 //
@@ -54,7 +54,7 @@ module belt(type, points, gap = 0, gap_pos = undef, belt_colour = grey(20), toot
 
     tangents = rounded_polygon_tangents(points);
 
-    length = ceil((rounded_polygon_length(points, tangents) - gap) / pitch) * pitch;
+    length = ceil((rounded_polygon_length(points, tangents) - (is_list(gap) ? gap.x + gap.y : gap)) / pitch) * pitch;
 
     module shape() rounded_polygon(points, tangents);
 
@@ -65,7 +65,7 @@ module belt(type, points, gap = 0, gap_pos = undef, belt_colour = grey(20), toot
             translate([gap_pos.x, gap_pos.y])
                 rotate(is_undef(gap_pos.z) ? 0 : gap_pos.z)
                     translate([0, ph - thickness / 2])
-                        square([gap, thickness + eps], center = true);
+                        square(is_list(gap) ? [gap.x, gap.y + thickness + eps] : [gap, thickness + eps], center = true);
 
     color(belt_colour)
         linear_extrude(width, center = true)

vitamins/blower.scad

@@ -22,6 +22,8 @@
 //
 include <../utils/core/core.scad>
 use <../utils/rounded_cylinder.scad>
+use <../utils/quadrant.scad>
+use <screw.scad>
 
 function blower_length(type)      = type[2]; //! Length of enclosing rectangle
 function blower_width(type)       = type[3]; //! Width of enclosing rectangle
@@ -39,8 +41,87 @@ function blower_top(type)         = type[14]; //! Thickness of the top
 function blower_wall(type)        = type[15]; //! Side wall thickness
 function blower_lug(type)         = type[16]; //! Height of the lugs
 
+function blower_casing_is_square(type) = len(blower_screw_holes(type)) > 3; //! True for square radial fans, false for spiral shape radial blowers
+function blower_exit_offset(type) = blower_casing_is_square(type) ? blower_length(type) / 2 : blower_exit(type) / 2; //! Offset of exit's centre from the edge
+
 fan_colour = grey(20);
 
+module blower_fan(type, casing_is_square) {
+    module squarish(s, n) {
+        polygon([
+            for(i = [0 : n]) [i * s.x / n,  s.y + (i % 2) * eps],
+            for(i = [0 : n]) [s.x - i * s.x / n, (i % 2) * eps],
+        ]);
+    }
+
+    depth = blower_depth(type);
+    blade_ir = blower_hub(type) / 2 + 0.5; // slight gap between main part of blades and hub
+    blade_len = casing_is_square
+        ? (blower_bore(type) - 1) / 2 - blade_ir // fan constrained by bore hole
+        : blower_width(type) - blower_axis(type).x- blower_wall(type) - blade_ir; // fan extends to casing
+    blade_thickness = 0.75;
+    blade_count = 25;
+
+    base_offset = 1;
+    translate([blower_axis(type).x, blower_axis(type).y, blower_base(type) + base_offset])
+        linear_extrude(blower_hub_height(type) - 0.5 - blower_base(type) - base_offset, center = false, convexity = 4, twist = -30, slices = round(depth / 2))
+            for(i = [0 : blade_count - 1])
+                rotate((360 * i) / blade_count)
+                    translate([blade_ir, -blade_thickness / 2])
+                        squarish([blade_len, blade_thickness], round(blade_len / 2));
+}
+
+module blower_square(type) { //! Draw a square blower
+    width = blower_width(type);
+    depth = blower_depth(type);
+    wall = blower_wall(type);
+    hole_pitch = (blower_screw_holes(type)[1].x - blower_screw_holes(type)[0].x) / 2;
+    corner_radius = width / 2 - hole_pitch;
+    corner_inset = (width - blower_exit(type)) / 2;
+
+    module square_inset_corners(remove_center = false)
+        difference() {
+            //overall outside
+                square([width, width], center = false);
+
+            if (remove_center) {
+                // cut out the inside, leaving the corners
+                translate([corner_inset + wall, -eps])
+                    square([width - 2 * (wall + corner_inset), width - wall + eps], center = false);
+
+                translate([wall, corner_inset + wall])
+                    square([width - 2 * wall, width - 2 * (wall + corner_inset)], center = false);
+            } else {
+                // cut out the bore for the fan
+                translate(blower_axis(type))
+                    circle(d = blower_bore(type));
+            }
+            // corner inset
+            translate([width / 2, width / 2])
+            for(i = [0 : 3])
+                rotate(i * 90)
+                    translate([-width / 2 - eps, -width/ 2 - eps])
+                        quadrant(corner_inset, corner_inset - corner_radius);
+        }
+
+    base_height = blower_base(type);
+    linear_extrude(base_height)
+        difference () {
+            rounded_square([width, width], corner_radius, center = false);
+
+            blower_hole_positions(type)
+                circle(d = blower_screw_hole(type));
+        }
+
+    translate_z(base_height)
+        linear_extrude(depth - base_height)
+            square_inset_corners(remove_center = true);
+
+    translate_z(depth - base_height)
+        linear_extrude(blower_top(type))
+            square_inset_corners();
+}
+
 module blower(type) { //! Draw specified blower
     length = blower_length(type);
     width = blower_width(type);
@@ -70,55 +151,63 @@ module blower(type) { //! Draw specified blower
 
     vitamin(str("blower(", type[0], "): ", type[1]));
 
+    is_square = blower_casing_is_square(type); // Description starts with square!
     color(fan_colour) {
-        // screw lugs
-        linear_extrude(blower_lug(type), center = false)
-            for(hole = blower_screw_holes(type))
-                difference() {
-                    hull() {
+        if (is_square) {
+            blower_square(type);
+        } else {
+            // screw lugs
+            linear_extrude(blower_lug(type), center = false)
+                for(hole = blower_screw_holes(type))
+                    difference() {
+                        hull() {
+                            translate(hole)
+                                circle(d = blower_screw_hole(type) + 2 * blower_wall(type));
+
+                            translate(blower_axis(type))
+                                circle(d = blower_screw_hole(type) + 2 * blower_wall(type) + 7);
+                        }
                         translate(hole)
-                            circle(d = blower_screw_hole(type) + 2 * blower_wall(type));
+                            circle(d = blower_screw_hole(type));
 
-                        translate(blower_axis(type))
-                            circle(d = blower_screw_hole(type) + 2 * blower_wall(type) + 7);
-                    }
-                    translate(hole)
-                        circle(d = blower_screw_hole(type));
+                        shape(true);
+                }
 
-                    shape(true);
-               }
-        // rotor
-        translate(concat(blower_axis(type), [blower_base(type) + 1]))
-            rounded_cylinder(r = blower_hub(type) / 2, h = blower_hub_height(type) - blower_base(type) - 1, r2 = 1);
+            *%square([length, width]);
 
-        *%square([length, width]);
-
-        // base
-        linear_extrude(blower_base(type))
-            difference() {
-                shape();
-
-                translate(concat(blower_axis(type), [blower_base(type)]))
-                    circle(d = 2);
-           }
-        // sides
-        linear_extrude(depth)
-            difference() {
-                shape();
-
-                offset(-blower_wall(type))
-                    shape(true);
-           }
-
-        // top
-        translate_z(depth -blower_top(type))
-            linear_extrude(blower_top(type))
+            // base
+            linear_extrude(blower_base(type))
                 difference() {
                     shape();
 
                     translate(concat(blower_axis(type), [blower_base(type)]))
-                        circle(d = blower_bore(type));
-               }
+                        circle(d = 2);
+            }
+
+            // sides
+            linear_extrude(depth)
+                difference() {
+                    shape();
+
+                    offset(-blower_wall(type))
+                        shape(true);
+            }
+
+            // top
+            translate_z(depth -blower_top(type))
+                linear_extrude(blower_top(type))
+                    difference() {
+                        shape();
+
+                        translate(concat(blower_axis(type), [blower_base(type)]))
+                            circle(d = blower_bore(type));
+                }
+        }
+        // rotor
+        translate(concat(blower_axis(type), [blower_base(type) + 1]))
+            rounded_cylinder(r = blower_hub(type) / 2, h = blower_hub_height(type) - blower_base(type) - 1, r2 = 1);
+
+        blower_fan(type, is_square);
     }
 }
 

vitamins/blowers.scad

@@ -16,10 +16,16 @@
 // You should have received a copy of the GNU General Public License along with NopSCADlib.
 // If not, see <https://www.gnu.org/licenses/>.
 //
+//                                                   l     w   d   b     s              h   a            s    s                               e    h    b    t    w    l
+//                                                   e     i   e   o     c              u   x            c    c                               x    u    a    o    a    u
+//                                                   n     d   p   r     r              b   i            r    r                               i    b    s    p    l    g
+//                                                   g     t   t   e     e                  s            e    e                               t         e         l
+//                                                   t     h   h         w              d                w    w                                              t
+//                                                   h                                                   h    s                                         t         t
+RB5015 = ["RB5015", "Blower Runda RB5015",           51.3, 51, 15, 31.5, M4_cap_screw, 26, [27.3, 25.4], 4.5, [[4.3, 45.4], [47.3,7.4]],     20,   14,  1.5, 1.3, 1.2, 15];
+PE4020 = ["PE4020", "Blower Pengda Technology 4020", 40,   40, 20, 27.5, M3_cap_screw, 22, [21.5, 20  ], 3.2, [[37,3],[3,37],[37,37]],       29.3, 17,  1.7, 1.2, 1.3, 13];
+BL40x10 =["BL40x10","Square radial 4010",            40,   40,9.5, 27,   M2_cap_screw, 16, [24,   20  ], 2.4, [[2,2],[38,2],[2,38],[38,38]], 30  , 9.5, 1.5, 1.5, 1.1, 1.5];
 
-RB5015 = ["RB5015", "Blower Runda RB5015",           51.3, 51, 15, 31.5, M4_cap_screw, 26, [27.3, 25.4], 4.5, [[4.3, 45.4], [47.3,7.4]], 20, 14, 1.5, 1.3, 1.2, 15];
-PE4020 = ["PE4020", "Blower Pengda Technology 4020", 40,   40, 20, 27.5, M3_cap_screw, 22, [21.5, 20  ], 3.2, [[37,3],[3,37],[37,37]], 29.3, 17, 1.7, 1.2, 1.3, 13];
-
-blowers = [PE4020, RB5015];
+blowers = [BL40x10, PE4020, RB5015];
 
 use <blower.scad>

vitamins/camera.scad

@@ -29,7 +29,7 @@ function camera_lens(type)          = type[4]; //! Stack of lens parts, can be r
 function camera_connector_pos(type) = type[5]; //! The flex connector block for the camera itself's position
 function camera_connector_size(type)= type[6]; //! The flex connector block for the camera itself's size
 
-module camera_lens(type, offset = 0) //! Draw the lens stack, with optional offset for making a clearance hole
+module camera_lens(type, offset = 0, show_lens = true) //! Draw the lens stack, with optional offset for making a clearance hole
     color(grey(20))
         translate(camera_lens_offset(type))
             for(p = camera_lens(type)) {
@@ -39,24 +39,25 @@ module camera_lens(type, offset = 0) //! Draw the lens stack, with optional offs
                 if(size.x)
                     rounded_rectangle(size + [2 * offset, 2 * offset, round_to_layer(offset)], r, center = false);
                 else
-                    translate_z(size.y)
-                        rotate_extrude()
-                            difference() {
-                                square([r, size.z + round_to_layer(offset)]);
+                    if (show_lens)
+                        translate_z(size.y)
+                            rotate_extrude()
+                                difference() {
+                                    square([r, size.z + round_to_layer(offset)]);
 
-                                if(app)
-                                    translate([0, size.z])
-                                        hull() {
-                                            translate([0, -eps])
-                                                square([app.y, eps * 2]);
+                                    if(app)
+                                        translate([0, size.z])
+                                            hull() {
+                                                translate([0, -eps])
+                                                    square([app.y, eps * 2]);
 
-                                            translate([0, -app.z])
-                                                square([app.x, app.z]);
-                                        }
-                            }
+                                                translate([0, -app.z])
+                                                    square([app.x, app.z]);
+                                            }
+                                }
             }
 
-module camera(type) {           //! Draw specified PCB camera
+module camera(type, show_lens = true) {           //! Draw specified PCB camera
     vitamin(str("camera(", type[0], "): ", type[1]));
     pcb = camera_pcb(type);
 
@@ -64,7 +65,7 @@ module camera(type) {           //! Draw specified PCB camera
         pcb(pcb);
 
     translate_z(pcb_thickness(pcb)) {
-        camera_lens(type);
+        camera_lens(type, show_lens = show_lens);
 
         conn = camera_connector_size(type);
         if(conn) {

vitamins/component.scad

@@ -209,7 +209,7 @@ module al_clad_resistor_assembly(type, value, sleeved = true) { //* Draw alumini
 
 function TO220_thickness() = 1.5; //! Thickness of the tab of a TO220
 
-module  TO220(description, leads = 3, lead_length = 16) { //! Draw a TO220 package, use ```description``` to describe what it is
+module  TO220(description, leads = 3, lead_length = 16) { //! Draw a TO220 package, use `description` to describe what it is
     width = 10.2;
     inset = 1.5;
     hole = 3.3;

vitamins/fan.scad

@@ -122,7 +122,7 @@ module fan_hole_positions(type, z = undef) { //! Position children at the screw
                 children();
 }
 
-module fan_holes(type, poly = false, screws = true, h = 100) { //! Make all the holes for the fan, or just the aperture if ```screws``` is false. Set ```poly``` true for poly_holes.
+module fan_holes(type, poly = false, screws = true, h = 100) { //! Make all the holes for the fan, or just the aperture if `screws` is false. Set `poly` true for poly_holes.
     hole_pitch = fan_hole_pitch(type);
     screw = fan_screw(type);
 

vitamins/insert.scad

@@ -89,7 +89,7 @@ module insert(type) { //! Draw specified insert
     }
 }
 
-module insert_hole(type, counterbore = 0, horizontal = false) { //! Make a hole to take an insert, ```counterbore``` is the extra length for the screw
+module insert_hole(type, counterbore = 0, horizontal = false) { //! Make a hole to take an insert, `counterbore` is the extra length for the screw
     h = insert_hole_length(type);
 
     render(convexity = 2)

vitamins/inserts.scad

@@ -29,7 +29,7 @@
 //                          d         d          h    d    d
 //                                         d
 //
-F1BM2   = [ "F1BM2",    4.0, 3.6, 3.2, 2,   3.0,  1.0, 3.4, 3.1 ];
+F1BM2   = [ "F1BM2",   4.0, 3.6, 3.2, 2,   3.0,  1.0, 3.4, 3.1 ];
 F1BM2p5 = [ "F1BM2p5", 5.8, 4.6, 4.0, 2.5, 3.65, 1.6, 4.4, 3.9 ];
 F1BM3   = [ "F1BM3",   5.8, 4.6, 4.0, 3,   3.65, 1.6, 4.4, 3.9 ];
 F1BM4   = [ "F1BM4",   8.2, 6.3, 5.6, 4,   5.15, 2.3, 6.0, 5.55 ];

vitamins/light_strip.scad

@@ -21,7 +21,7 @@
 //! LED strip lights that can be cut to size.
 //!
 //! The definitions are for the full length but they can be cut to size by specifying how many segments,
-//! which can by calcuated using ```light_strip_segments(type, max_length)```.
+//! which can by calcuated using `light_strip_segments(type, max_length)`.
 //!
 //! The `light_strip_clip()` module makes a clip to go around the light that can be incorporated into a printed bracket to hold it.
 //

vitamins/mains_socket.scad

@@ -116,7 +116,7 @@ module mains_socket(type) { //! Draw specified 13A socket
             cylinder(r = screw_clearance_radius(screw), h = 100, center = true);
 
             translate_z(height)
-                screw_countersink(screw);
+                screw_countersink(screw, drilled = false);
         }
     }
 }

vitamins/microview.scad

@@ -20,7 +20,7 @@
 //
 //! Microview OLED display with on board AVR by geekammo / Sparkfun.
 //!
-//! ```microview()``` generates the model. ```microview(true)``` makes an object to cut out a panel aperture for it.
+//! `microview()` generates the model. `microview(true)` makes an object to cut out a panel aperture for it.
 //!
 //! Uses STL files copyright geekammo and licenced with MIT license, see [microview/LICENSE.txt](vitamins/microview/LICENSE.txt).
 //

vitamins/o_ring.scad

@@ -20,12 +20,12 @@
 //
 //! Nitrile rubber O-rings.
 //!
-//! Just a black torus specified by internal diameter, ```id``` and ```minor_d``` plus a BOM entry.
-//! Can be shown stretched by specifying the ```actual_id```.
+//! Just a black torus specified by internal diameter, `id` and `minor_d` plus a BOM entry.
+//! Can be shown stretched by specifying the `actual_id`.
 //
 include <../utils/core/core.scad>
 
-module O_ring(id, minor_d, actual_id = 0) { //! Draw O-ring with specified internal diameter and minor diameter. ```actual_id``` can be used to stretch it around something.
+module O_ring(id, minor_d, actual_id = 0) { //! Draw O-ring with specified internal diameter and minor diameter. `actual_id` can be used to stretch it around something.
     vitamin(str("O_ring(", id, ", ", minor_d, "): O-ring nitrile ", id, "mm x ", minor_d, "mm"));
 
     D = actual_id > id ? actual_id : id;            // allow it to be stretched

vitamins/rail.scad

@@ -40,18 +40,23 @@ function carriage_length(type)       = type[0]; //! Overall length
 function carriage_block_length(type) = type[1]; //! Length of the metal part
 function carriage_width(type)        = type[2]; //! Width of carriage
 function carriage_height(type)       = type[3]; //! Height of carriage
+function carriage_size(type)         = [ type[0], type[2], type[3] ]; //! Size of carriage
 function carriage_clearance(type)    = type[4]; //! Gap under the carriage
 function carriage_pitch_x(type)      = type[5]; //! Screw hole x pitch
 function carriage_pitch_y(type)      = type[6]; //! Screw hole y pitch
 function carriage_screw(type)        = type[7]; //! Carriage screw type
 function carriage_screw_depth(type)  = 2 * screw_radius(carriage_screw(type)); //! Carriage thread depth
 
+function rail_holes(type, length) = //! Number of holes in a rail given its `length`
+    floor((length - 2 * rail_end(type)) / rail_pitch(type)) + 1;
+
 module rail_hole_positions(type, length, first = 0, screws = 100, both_ends = true) { //! Position children over screw holes
     pitch = rail_pitch(type);
-    holes = floor((length - 2 * rail_end(type)) / pitch) + 1;
-    for(i = [first : holes - 1 - first])
-        if(i < screws || (holes - i <= screws && both_ends))
-            translate([i * pitch - length / 2 + (length - (holes -1) * pitch) / 2, 0, 0])
+    holes = rail_holes(type, length);
+    last = first + screws;
+    for(i = [first : holes - 1], j = holes - 1 - i)
+        if(i < last || both_ends && (j >= first && j < last))
+            translate([i * pitch - length / 2 + (length - (holes - 1) * pitch) / 2, 0])
                 children();
 }
 
@@ -104,24 +109,27 @@ module carriage(type, rail, end_colour = grey(20), wiper_colour = grey(20)) { //
 
     module carriage_end(type, end_w, end_h, end_l) {
         wiper_length = 0.5;
-        color(wiper_colour) translate_z(-end_l/2) linear_extrude(wiper_length)
+        color(wiper_colour) translate_z(-end_l / 2) linear_extrude(wiper_length)
             difference() {
-                translate([-end_w/2, carriage_clearance(type)])
+                translate([-end_w / 2, carriage_clearance(type)])
                     square([end_w, end_h]);
+
                 cutout();
             }
-        color(end_colour) translate_z(wiper_length-end_l/2) linear_extrude(end_l-wiper_length)
+        color(end_colour) translate_z(wiper_length-end_l / 2) linear_extrude(end_l - wiper_length)
             difference() {
-                translate([-end_w/2, carriage_clearance(type)])
+                translate([-end_w / 2, carriage_clearance(type)])
                     square([end_w, end_h]);
+
                 cutout();
             }
     }
 
-    translate([-(block_l+end_l)/2,0,0])
+    translate([-(block_l + end_l) / 2, 0])
         rotate([90, 0, 90])
             carriage_end(type, end_w, end_h, end_l);
-    translate([(block_l+end_l)/2,0,0])
+
+    translate([(block_l + end_l) / 2, 0])
         rotate([90, 0, -90])
             carriage_end(type, end_w, end_h, end_l);
 }
@@ -171,7 +179,6 @@ module rail_assembly(type, length, pos, carriage_end_colour = grey(20), carriage
 
     translate([pos, 0])
         carriage(rail_carriage(type), type,  carriage_end_colour, carriage_wiper_colour);
-
 }
 
 module rail_screws(type, length, thickness, screws = 100) { //! Place screws in the rail
@@ -187,6 +194,6 @@ module rail_screws(type, length, thickness, screws = 100) { //! Place screws in
             screw(end_screw, end_screw_len);
 
     translate_z(rail_screw_height(type, screw))
-        rail_hole_positions(type, length, index_screws, screws)
+        rail_hole_positions(type, length, index_screws, min(screws, rail_holes(type, length)) - 2 * index_screws)
             screw(screw, screw_len);
 }

vitamins/rails.scad

@@ -33,11 +33,11 @@ SSR15_carriage = [ 40.3, 23.3, 34, 24, 4.5, 0,  26, M4_cap_screw ];
 //
 //
 //                Wr  Hr   E    P   D    d    h
-MGN5 = [ "MGN5",  5,  3.6, 5,   15, 3.5, 2.4, 0.8, M2_cs_cap_screw, MGN5_carriage, M2_cs_cap_screw ]; // Screw holes too small for M2 heads
+MGN5 = [ "MGN5",  5,  3.6, 5,   15, 3.6, 2.4, 0.8, M2_cs_cap_screw, MGN5_carriage, M2_cs_cap_screw ]; // Screw holes too small for M2 heads
 MGN7 = [ "MGN7",  7,  5,   5,   15, 4.3, 2.4, 2.6, M2_cap_screw,    MGN7_carriage, M2_cs_cap_screw ];
 MGN9 = [ "MGN9",  9,  6,   7.5, 20, 6.0, 3.5, 3.5, M3_cap_screw,    MGN9_carriage, M3_cs_cap_screw ];
 MGN12= [ "MGN12", 12, 8,   10,  25, 6.0, 3.5, 4.5, M3_cap_screw,   MGN12_carriage, M3_cs_cap_screw ];
-MGN12H=[ "MGN12H",12, 8,    10, 25, 6.0, 3.5, 4.5, M3_cap_screw,   MGN12H_carriage,M3_cs_cap_screw ];
+MGN12H=[ "MGN12H",12, 8,   10,  25, 6.0, 3.5, 4.5, M3_cap_screw,   MGN12H_carriage,M3_cs_cap_screw ];
 MGN15= [ "MGN15", 15, 10,  10,  40, 6.0, 3.5, 5.0, M3_cap_screw,   MGN15_carriage, M3_cs_cap_screw ];
 SSR15= [ "SSR15", 15, 12.5,10,  60, 7.5, 4.5, 5.3, M4_cap_screw,   SSR15_carriage, M4_cs_cap_screw ];
 

vitamins/screw.scad

@@ -19,6 +19,8 @@
 
 //
 //! Machine screws and wood screws with various head styles.
+//!
+//! For an explanation of `screw_polysink()` see <https://hydraraptor.blogspot.com/2020/12/sinkholes.html>.
 //
 include <../utils/core/core.scad>
 
@@ -41,9 +43,13 @@ function screw_pilot_hole(type)       = type[11];    //! Pilot hole radius for w
 function screw_clearance_radius(type) = type[12];    //! Clearance hole radius
 function screw_nut_radius(type) = screw_nut(type) ? nut_radius(screw_nut(type)) : 0; //! Radius of matching nut
 function screw_boss_diameter(type) = max(washer_diameter(screw_washer(type)) + 1, 2 * (screw_nut_radius(type) + 3 * extrusion_width)); //! Boss big enough for nut trap and washer
-function screw_head_depth(type, d) = screw_head_height(type) ? 0 : screw_head_radius(type) - d / 2; //! How far a counter sink head will go into a straight hole diameter d
+function screw_head_depth(type, d = 0) =             //! How far a counter sink head will go into a straight hole diameter d
+    screw_head_height(type)
+        ? 0
+        : let(r = screw_radius(type)) screw_head_radius(type) - max(r, d / 2) + r / 5;
 
 function screw_longer_than(x) = x <=  5 ?  5 : //! Returns shortest screw length longer or equal to x
+                                x <=  6 ?  6 :
                                 x <=  8 ?  8 :
                                 x <= 10 ? 10 :
                                 x <= 12 ? 12 :
@@ -109,6 +115,27 @@ module screw(type, length, hob_point = 0, nylon = false) { //! Draw specified sc
                     cylinder(r = rad + eps, h = shank);
     }
 
+    module cs_head(socket_rad, socket_depth) {
+        head_t = rad / 5;
+        head_height = head_rad + head_t;
+
+        rotate_extrude()
+            difference() {
+                polygon([[0, 0], [head_rad, 0], [head_rad, -head_t], [0, -head_height]]);
+
+                translate([0, -socket_depth + eps])
+                    square([socket_rad, 10]);
+            }
+
+        translate_z(-socket_depth)
+            linear_extrude(socket_depth)
+                difference() {
+                    circle(socket_rad + 0.1);
+
+                    children();
+                }
+    }
+
     explode(length + 10) {
         if(head_type == hs_cap) {
             color(colour) {
@@ -201,63 +228,76 @@ module screw(type, length, hob_point = 0, nylon = false) { //! Draw specified sc
         }
 
         if(head_type == hs_cs) {
-            head_height = head_rad;
             socket_rad = 0.6 * head_rad;
             socket_depth = 0.3 * head_rad;
             socket_width = 1;
-            color(colour) {
-                rotate_extrude()
-                    difference() {
-                        polygon([[0, 0], [head_rad, 0], [0, -head_height]]);
+            color(colour)
+                cs_head(socket_rad, socket_depth) {
+                    square([2 * socket_rad, socket_width], center = true);
+                    square([socket_width, 2 * socket_rad], center = true);
+                }
 
-                        translate([0, -socket_depth + eps])
-                            square([socket_rad + 0.1, 10]);
-                    }
-
-                translate_z(-socket_depth)
-                    linear_extrude(socket_depth)
-                        difference() {
-                            circle(socket_rad + 0.1);
-
-                            square([2 * socket_rad, socket_width], center = true);
-                            square([socket_width, 2 * socket_rad], center = true);
-                        }
-            }
             shaft(socket_depth);
         }
 
         if(head_type == hs_cs_cap) {
-            head_height = head_rad;
-            color(colour) {
-                rotate_extrude()
-                    difference() {
-                        polygon([[0, 0], [head_rad, 0], [0, -head_height]]);
+            color(colour)
+                cs_head(socket_rad, socket_depth)
+                    circle(socket_rad, $fn = 6);
 
-                        translate([0, -socket_depth + eps])
-                            square([socket_rad, 10]);
-                    }
-
-                translate_z(-socket_depth)
-                    linear_extrude(socket_depth)
-                        difference() {
-                            circle(socket_rad + 0.1);
-
-                            circle(socket_rad, $fn = 6);
-                        }
-            }
             shaft(socket_depth);
         }
     }
 }
 
-module screw_countersink(type) { //! Countersink shape
+module screw_countersink(type, drilled = true) { //! Countersink shape
     head_type   = screw_head_type(type);
     head_rad    = screw_head_radius(type);
-    head_height = head_rad;
+    rad = screw_radius(type);
+    head_t = rad / 5;
+    head_height = head_rad + head_t;
 
     if(head_type == hs_cs || head_type == hs_cs_cap)
         translate_z(-head_height)
-             cylinder(h = head_height, r1 = 0, r2 = head_rad);
+            if(drilled)
+                cylinder(h = head_height + eps, r1 = 0, r2 = head_rad + head_t);
+            else
+                intersection() {
+                    cylinder(h = head_height + eps, r1 = 0, r2 = head_rad + head_t);
+
+                    cylinder(h = head_height + eps, r = head_rad + eps);
+                }
+}
+
+function screw_polysink_r(type, z) = //! Countersink hole profile corrected for rounded staircase extrusions.
+    let(rad = screw_radius(type),
+        head_t = rad / 5,
+        head_rad = screw_head_radius(type)
+    )
+    limit(head_rad + head_t - z + (sqrt(2) - 1) * layer_height / 2, screw_clearance_radius(type), head_rad);
+
+module screw_polysink(type, h = 100, alt = false) { //! A countersink hole made from stacked polyholes for printed parts
+    head_depth = screw_head_depth(type);
+    assert(head_depth, "Not a countersunk screw");
+    layers = ceil(head_depth / layer_height);
+    rmin = screw_clearance_radius(type);
+    sides = sides(rmin);
+    lh = layer_height + eps;
+    render(convexity = 5)
+        for(side = [0, 1]) mirror([0, 0, side]) {
+            for(i = [0 : layers - 1])
+                translate_z(i * layer_height) {
+                    r = screw_polysink_r(type, i * layer_height + layer_height / 2);
+                    if(alt)
+                        rotate(i % 2 == layers % 2 ? 180 / sides : 0)
+                            poly_cylinder(r = r, h = lh, center = false, sides = sides);
+                    else
+                        poly_cylinder(r = r, h = lh, center = false);
+                }
+
+            translate_z(layers * layer_height)
+                poly_cylinder(r = rmin, h = h / 2 - layers * layer_height, center = false);
+        }
 }
 
 module screw_and_washer(type, length, star = false, penny = false) { //! Screw with a washer which can be standard or penny and an optional star washer on top

vitamins/screws.scad

@@ -107,14 +107,14 @@ No6_screw        = ["No6", "No6 pan wood",      hs_pan, 3.5, 6.7, 2.2,    0,   0
 No6_cs_screw     = ["No6_cs", "No6 cs wood",    hs_cs,  3.5, 7.0, 0,      0,   0, 0,   M4_washer, false,    No6_pilot_radius, No6_clearance_radius];
 
 screw_lists = [
-[ M2_cap_screw, M2p5_cap_screw, M3_cap_screw,    M4_cap_screw, M5_cap_screw, M6_cap_screw, M8_cap_screw],
-[ 0,            0,              M3_low_cap_screw],
-[ 0,            0,              M3_hex_screw,    M4_hex_screw, M5_hex_screw, M6_hex_screw, M8_hex_screw],
-[ 0,            M2p5_pan_screw, M3_pan_screw,    M4_pan_screw, M5_pan_screw, M6_pan_screw, No632_pan_screw],
-[ 0,            No2_screw,      No4_screw,       No6_screw,    No6_cs_screw],
-[ 0,            M2_cs_cap_screw,M3_cs_cap_screw, M4_cs_cap_screw],
-[ 0,            M2_dome_screw,  M3_dome_screw,   M4_dome_screw],
-[ 0,            0,              M3_grub_screw,   M4_grub_screw]
+[ M2_cap_screw,    M2p5_cap_screw, M3_cap_screw,    M4_cap_screw, M5_cap_screw, M6_cap_screw, M8_cap_screw],
+[ 0,               0,              M3_low_cap_screw],
+[ M2_cs_cap_screw, 0,              M3_cs_cap_screw, M4_cs_cap_screw],
+[ M2_dome_screw,   0,              M3_dome_screw,   M4_dome_screw],
+[ 0,               0,              M3_hex_screw,    M4_hex_screw, M5_hex_screw, M6_hex_screw, M8_hex_screw],
+[ 0,               M2p5_pan_screw, M3_pan_screw,    M4_pan_screw, M5_pan_screw, M6_pan_screw, No632_pan_screw],
+[ No2_screw,       0,              No4_screw,       No6_screw,    No6_cs_screw],
+[ 0,               0,              M3_grub_screw,   M4_grub_screw]
 ];
 
 use <screw.scad>

vitamins/scs_bearing_block.scad

@@ -63,7 +63,7 @@ module scs_bearing_block(type) { //! Draw the specified SCS bearing block
     bearing = scs_bearing(type);
     clip = scs_circlip(type);
 
-    module right_trapezoid(base, top, height, h = 0, center = true) {//! A right angled trapezoid with the 90° corner at the origin. 3D when ```h``` is nonzero, otherwise 2D
+    module right_trapezoid(base, top, height, h = 0, center = true) {//! A right angled trapezoid with the 90° corner at the origin. 3D when `h` is nonzero, otherwise 2D
         extrude_if(h, center = center)
             polygon(points = [ [0,0], [base, 0], [top, height], [0, height] ]);
     }

vitamins/sheet.scad

@@ -27,14 +27,22 @@
 //!
 //! The "Colour" parameter is a quad-array: [R, G, B, Alpha], or can be a named colour, see [OpenSCAD_User_Manual](https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/The_OpenSCAD_Language#color).
 //!
-//! For speed sheets should be modelled in 2D by subtracting holes from 2D templates made by ```sheet_2D()``` and then extruded to 3D with ```render_2D_sheet()```.
-//! Note that modules that drill holes will return a 2D object if ```h``` is set to 0 to facilitate this.
+//! For speed sheets should be modelled in 2D by subtracting holes from 2D templates made by `sheet_2D()` and then extruded to 3D with `render_2D_sheet()`.
+//! Note that modules that drill holes will return a 2D object if `h` is set to 0 to facilitate this.
+//!
+//! If 3D features are needed, for example countersinks, then sheets can be modelled in 3D using `sheet()` and then coloured with `render_sheet()`.
+//!
+//! When woven sheets (e.g. carbon fibre) are rendered it is necessary to specify the dimensions again to `render_sheet()` or `render_2D_sheet()`.
 //
 include <../utils/core/core.scad>
 
 function sheet_thickness(type) = type[2]; //! Thickness
 function sheet_colour(type)    = type[3]; //! Colour
 function sheet_is_soft(type)   = type[4]; //! Is soft enough for wood screws
+function sheet_is_woven(type)  = !is_undef(type[5]); //! Is a woven sheet, eg carbon fiber
+function sheet_warp(type)      = type[5]; //! Wovern sheet warp
+function sheet_weft(type)      = type[6]; //! Wovern sheet weft
+function sheet_colour2(type)   = type[7]; //! Second colour for a woven sheet
 
 module corner(r) {
     if(r > 0)
@@ -78,12 +86,66 @@ module sheet(type, w, d, corners = [0, 0, 0, 0]) //! Draw specified sheet
     linear_extrude(sheet_thickness(type), center = true)
         sheet_2D(type, w, d, corners);
 
-module render_sheet(type, colour = false) //! Render a sheet in the correct colour after holes have been subtracted
-    color(colour ? colour : sheet_colour(type))
-        render() children();
+module render_sheet(type, colour = false, colour2 = false, w = undef, d = undef) { //! Render a sheet in the correct colour after holes have been subtracted
+    woven = sheet_is_woven(type);
+    t = sheet_thickness(type);
+    colour = colour ? colour : sheet_colour(type);
+    colour2 = colour2 ? colour2 : sheet_colour2(type);
+    let($dxf_colour = colour)
+        color(woven ? colour2 : colour)
+            render()
+                scale([1, 1, woven ? (t - 2 * eps) / t : 1])
+                    children();
 
-module render_2D_sheet(type, colour = false) //! Extrude a 2D sheet template and give it the correct colour
-    let($dxf_colour = colour ? colour : sheet_colour(type))
-        color($dxf_colour)
-            linear_extrude(sheet_thickness(type), center = true)
+    if(woven)
+        for(side = [-1, 1], z = side * (t - eps) / 2)
+            translate_z(z)
+                woven_sheet(type, eps, colour, colour2, w, d)
+                    projection(cut = true)
+                        translate_z(-z)
+                            not_on_bom()
+                                children();
+}
+
+module render_2D_sheet(type, colour = false, colour2 = false, w = undef, d = undef) { //! Extrude a 2D sheet template and give it the correct colour
+    colour = colour ? colour : sheet_colour(type);
+    colour2 = colour2 ? colour2 : sheet_colour2(type);
+    let($dxf_colour = colour)
+        if(sheet_is_woven(type))
+            woven_sheet(type, sheet_thickness(type), colour, colour2, w, d)
                 children();
+        else
+            color($dxf_colour)
+                linear_extrude(sheet_thickness(type), center = true)
+                    children();
+}
+
+module woven_sheet(type, thickness, colour, colour2, w, d) { // Create a woven 2D sheet with specified thickness and colours
+    warp = sheet_warp(type);
+    weft = sheet_weft(type);
+    warp_doublet_count = assert(!is_undef(w) && !is_undef(d), "Must specify the dimensions to render woven sheets") ceil(w / (2 * warp));
+    weft_count = ceil(d / weft);
+
+    module chequerboard(odd = 0)
+        translate([-w / 2, -d / 2])
+            for (y = [0 : weft_count - 1], x = [0 : warp_doublet_count - 1])
+                translate([warp * (2 * x + ((y + odd) % 2)), weft * y])
+                    square([warp, weft]);
+
+    color(colour)
+        linear_extrude(thickness)
+            intersection() {
+                chequerboard();
+                children();
+            }
+
+    if(thickness > eps)
+        color(colour2)
+            linear_extrude(thickness)
+                intersection() {
+                    chequerboard(1);
+
+                    not_on_bom()
+                        children();
+                }
+}

vitamins/sheets.scad

@@ -22,7 +22,7 @@
 //
 
 //
-//         [ Code, Description, Thickness, Color, Soft]
+//         [ Code, Description, Thickness, Color, Soft, Warp, Weft, Color2]
 //
 mdf_colour = "#BEA587"; // sampled from a photo
 
@@ -38,14 +38,18 @@ PMMA8     = [ "PMMA8",     "Sheet acrylic",           8, [1,   1,   1,   0.5  ],
 PMMA10    = [ "PMMA10",    "Sheet acrylic",          10, [1,   1,   1,   0.5  ], false];   // ~3/8"
 glass2    = [ "glass2",    "Sheet glass",             2, [1,   1,   1,   0.25 ], false];
 DiBond    = [ "DiBond",    "Sheet DiBond",            3, [0.2, 0.2, 0.2, 1    ], false];
-DiBond6   = [ "DiBond6",   "Sheet DiBond",            6, "RoyalBlue",            false];
+DiBond6   = [ "DiBond6",   "Sheet DiBond",            6, [0.2, 0.2, 0.2, 1    ], false];
 Cardboard = [ "Cardboard", "Corrugated cardboard",    5, [0.8, 0.6, 0.3, 1    ], false];
 FoilTape  = [ "FoilTape",  "Aluminium foil tape",   0.05,[0.9, 0.9, 0.9, 1    ], false];
 Foam20    = [ "Foam20",    "Foam sponge",             20,[0.3, 0.3, 0.3, 1    ], true];
 AL6       = [ "AL6",       "Aluminium tooling plate", 6, [0.9, 0.9, 0.9, 1    ], false];
 AL8       = [ "AL8",       "Aluminium tooling plate", 8, [0.9, 0.9, 0.9, 1    ], false];
 Steel06   = [ "Steel06",   "Sheet mild steel",       0.6,"silver"              , false];
+CF1 =       [ "CF1",       "Sheet carbon fiber",      1, grey(30),               false,  2,  2,  grey(25)];
+CF2 =       [ "CF2",       "Sheet carbon fiber",      2, grey(30),               false,  2,  2,  grey(25)];
+CF3 =       [ "CF3",       "Sheet carbon fiber",      3, grey(30),               false,  2,  2,  grey(25)];
 
-sheets = [MDF6, MDF10, MDF12, MDF19, PMMA2, PMMA3, PMMA6, PMMA8, PMMA10, glass2, DiBond, DiBond6, Cardboard, FoilTape, Foam20, AL6, AL8, Steel06];
+
+sheets = [CF1, CF2, CF3, MDF6, MDF10, MDF12, MDF19, PMMA2, PMMA3, PMMA6, PMMA8, PMMA10, glass2, DiBond, DiBond6, Cardboard, FoilTape, Foam20, AL6, AL8, Steel06];
 
 use <sheet.scad>