Merge pull request #187 from EmperorArthur/simplify_baseplate

Fix Baseplate Not Rendering & Generate Baseplate From Profile

generic-helpers.scad

@@ -7,15 +7,60 @@ function clp(x,a,b) = min(max(x,a),b);
 
 function is_even(number) = (number%2)==0;
 
-module rounded_rectangle(length, width, height, rad) {
+/**
-    linear_extrude(height)
+ * @brief Create `square`, with rounded corners.
-    offset(rad)
+ * @param size Same as `square`.  See details for differences.
-    offset(-rad)
+ * @param radius Radius of the corners. 0 is the same as just calling `square`
-    square([length,width], center = true);
+ * @param center Same as `square`.
+ * @details "size" accepts both the standard number or a 2d vector the same as `square`.
+ *          However, if passed a 3d vector, this will apply a `linear_extrude` to the resulting shape.
+ */
+module rounded_square(size, radius, center = false) {
+    assert(is_num(size) ||
+        (is_list(size) && (
+            (len(size) == 2 && is_num(size.x) && is_num(size.y)) ||
+            (len(size) == 3 && is_num(size.x) && is_num(size.y) && is_num(size.z))
+        ))
+    );
+    assert(is_num(radius) && radius >= 0 && is_bool(center));
+
+    // Make sure something is produced.
+    if (is_num(size)) {
+        assert((size/2) > radius);
+    } else {
+        assert((size.x/2) > radius && (size.y/2 > radius));
+        if (len(size) == 3) {
+            assert(size.z > 0);
+        }
+    }
+
+    if (is_list(size) && len(size) == 3) {
+        linear_extrude(size.z)
+        _internal_rounded_square_2d(size, radius, center);
+    } else {
+        _internal_rounded_square_2d(size, radius, center);
+    }
 }
 
-module rounded_square(length, height, rad) {
+/**
-    rounded_rectangle(length, length, height, rad);
+ * @brief Internal module. Do not use. May be changed/removed at any time.
+ */
+module _internal_rounded_square_2d(size, radius, center) {
+    diameter = 2*radius;
+    if (is_list(size)) {
+        offset(radius)
+        square([size.x-diameter, size.y-diameter], center = center);
+    } else {
+        offset(radius)
+        square(size-diameter, center = center);
+    }
+}
+
+/**
+ * @deprecated Use rounded_square(...)
+ */
+module rounded_rectangle(length, width, height, rad) {
+    rounded_square([length, width, height], rad, center=true);
 }
 
 module copy_mirror(vec=[0,1,0]) {
@@ -56,7 +101,7 @@ unity_matrix = [
  * @param vector A 2d or 3d vectorm
  * @returns Magnitude of the vector.
  */
- function vector_magnitude(vector) =
+function vector_magnitude(vector) =
     sqrt(vector.x^2 + vector.y^2 + (len(vector) == 3 ? vector.z^2 : 0));
 
 /**
@@ -121,6 +166,8 @@ function affine_translate(vector) = [
  *        Centered on origin.
  */
 module sweep_rounded(width=10, length=10) {
+    assert(width > 0 && length > 0);
+
     half_width = width/2;
     half_length = length/2;
     path_points = [

gridfinity-rebuilt-baseplate.scad

@@ -18,9 +18,9 @@ $fs = 0.25;
 
 /* [General Settings] */
 // number of bases along x-axis
-gridx = 5;
+gridx = 1;
 // number of bases along y-axis
-gridy = 5;
+gridy = 1;
 
 /* [Screw Together Settings - Defaults work for M3 and 4-40] */
 // screw diameter
@@ -48,11 +48,11 @@ fity = 0; // [-1:0.1:1]
 /* [Styles] */
 
 // baseplate styles
-style_plate = 0; // [0: thin, 1:weighted, 2:skeletonized, 3: screw together, 4: screw together minimal]
+style_plate = 3; // [0: thin, 1:weighted, 2:skeletonized, 3: screw together, 4: screw together minimal]
 
 
 // hole styles
-style_hole = 2; // [0:none, 1:countersink, 2:counterbore]
+style_hole = 0; // [0:none, 1:countersink, 2:counterbore]
 
 /* [Magnet Hole] */
 // Baseplate will have holes for 6mm Diameter x 2mm high magnets.
@@ -67,64 +67,163 @@ hole_options = bundle_hole_options(refined_hole=false, magnet_hole=enable_magnet
 // ===== IMPLEMENTATION ===== //
 
 color("tomato")
-gridfinityBaseplate(gridx, gridy, l_grid, distancex, distancey, style_plate, hole_options, style_hole, fitx, fity);
+gridfinityBaseplate([gridx, gridy], l_grid, [distancex, distancey], style_plate, hole_options, style_hole, [fitx, fity]);
-
 
 // ===== CONSTRUCTION ===== //
 
-module gridfinityBaseplate(gridx, gridy, length, dix, diy, sp, hole_options, sh, fitx, fity) {
+/**
+ * @brief Create a baseplate.
+ * @param grid_size_bases Number of Gridfinity bases.
+ *        2d Vector. [x, y].
+ *        Set to [0, 0] to auto calculate using min_size_mm.
+ * @param length X,Y size of a single Gridfinity base.
+ * @param min_size_mm Minimum size of the baseplate. [x, y]
+ *                    Extra space is filled with solid material.
+ *                    Enables "Fit to Drawer."
+ * @param sp Baseplate Style
+ * @param hole_options
+ * @param sh Style of screw hole allowing the baseplate to be mounted to something.
+ * @param fit_offset Determines where padding is added.
+ */
+module gridfinityBaseplate(grid_size_bases, length, min_size_mm, sp, hole_options, sh, fit_offset = [0, 0]) {
 
-    assert(gridx > 0 || dix > 0, "Must have positive x grid amount!");
+    assert(is_list(grid_size_bases) && len(grid_size_bases) == 2,
-    assert(gridy > 0 || diy > 0, "Must have positive y grid amount!");
+        "grid_size_bases must be a 2d list");
+    assert(is_list(min_size_mm) && len(min_size_mm) == 2,
+        "min_size_mm must be a 2d list");
+    assert(is_list(fit_offset) && len(fit_offset) == 2,
+        "fit_offset must be a 2d list");
+    assert(grid_size_bases.x > 0 || min_size_mm.x > 0,
+        "Must have positive x grid amount!");
+    assert(grid_size_bases.y > 0 || min_size_mm.y > 0,
+        "Must have positive y grid amount!");
 
-    gx = gridx == 0 ? floor(dix/length) : gridx;
+    additional_height = calculate_offset(sp, hole_options[1], sh);
-    gy = gridy == 0 ? floor(diy/length) : gridy;
-    dx = max(gx*length-bp_xy_clearance, dix);
-    dy = max(gy*length-bp_xy_clearance, diy);
 
-    off = calculate_offset(sp, hole_options[1], sh);
+    // Final height of the baseplate. In mm.
+    baseplate_height_mm = additional_height + BASEPLATE_LIP_MAX.y;
 
-    offsetx = dix < dx ? 0 : (gx*length-bp_xy_clearance-dix)/2*fitx*-1;
+    // Final size in number of bases
-    offsety = diy < dy ? 0 : (gy*length-bp_xy_clearance-diy)/2*fity*-1;
+    grid_size = [for (i = [0:1])
+        grid_size_bases[i] == 0 ? floor(min_size_mm[i]/length) : grid_size_bases[i]];
+
+    // Final size of the base before padding. In mm.
+    grid_size_mm = concat(grid_size * length, [baseplate_height_mm]);
+
+    // Final size, including padding. In mm.
+    size_mm = [
+        max(grid_size_mm.x, min_size_mm.x),
+        max(grid_size_mm.y, min_size_mm.y),
+        baseplate_height_mm
+    ];
+
+    // Amount of padding needed to fit to a specific drawer size. In mm.
+    padding_mm = size_mm - grid_size_mm;
+
+    is_padding_needed = padding_mm != [0, 0, 0];
+
+    //Convert the fit offset to percent of how much will be added to the positive axes.
+    // -1 : 1 -> 0 : 1
+    fit_percent_positive = [for (i = [0:1]) (fit_offset[i] + 1) / 2];
+
+    padding_start_point = -grid_size_mm/2 -
+        [
+            padding_mm.x * (1 - fit_percent_positive.x),
+            padding_mm.y * (1 - fit_percent_positive.y),
+            -grid_size_mm.z/2
+        ];
+
+    corner_points = [
+        padding_start_point + [size_mm.x, size_mm.y, 0],
+        padding_start_point + [0, size_mm.y, 0],
+        padding_start_point,
+        padding_start_point + [size_mm.x, 0, 0],
+    ];
+
+    echo(str("Number of Grids per axes (X, Y)]: ", grid_size));
+    echo(str("Final size (in mm): ", size_mm));
+    if (is_padding_needed) {
+        echo(str("Padding +X (in mm): ", padding_mm.x * fit_percent_positive.x));
+        echo(str("Padding -X (in mm): ", padding_mm.x * (1 - fit_percent_positive.x)));
+        echo(str("Padding +Y (in mm): ", padding_mm.y * fit_percent_positive.y));
+        echo(str("Padding -Y (in mm): ", padding_mm.y * (1 - fit_percent_positive.y)));
+    }
+
+    screw_together = sp == 3 || sp == 4;
+    minimal = sp == 0 || sp == 4;
 
     difference() {
-        translate([offsetx,offsety,h_base])
+        union() {
-        mirror([0,0,1])
+            // Baseplate itself
-        rounded_rectangle(dx, dy, h_base+off, r_base);
+            pattern_linear(grid_size.x, grid_size.y, length) {
+                // Single Baseplate piece
+                difference() {
+                    if (minimal) {
+                        square_baseplate_lip(additional_height);
+                    } else {
+                        solid_square_baseplate(additional_height);
+                    }
 
-        gridfinityBase(gx, gy, length, 1, 1, bundle_hole_options(), 0.5, false);
+                    // Bottom/through pattern for the solid baseplates.
+                    if (sp == 1) {
+                        cutter_weight();
+                    } else if (sp == 2 || sp == 3) {
+                        translate([0,0,-TOLLERANCE])
+                        linear_extrude(additional_height + (2 * TOLLERANCE))
+                        profile_skeleton();
+                    }
 
-        translate([offsetx,offsety,h_base-0.6])
+                    // Add holes to the solid baseplates.
-        rounded_rectangle(dx*2, dy*2, h_base*2, r_base);
+                    hole_pattern(){
+                        // Manget hole
+                        translate([0, 0, additional_height+TOLLERANCE])
+                        mirror([0, 0, 1])
+                        block_base_hole(hole_options);
 
-        pattern_linear(gx, gy, length) {
+                        translate([0,0,-TOLLERANCE])
-            render(convexity = 6) {
+                        if (sh == 1) {
+                            cutter_countersink();
+                        } else if (sh == 2) {
+                            cutter_counterbore();
+                        }
+                    }
+                }
+            }
 
-                if (sp == 1)
+            // Padding
-                    translate([0,0,-off])
+            if (is_padding_needed) {
-                    cutter_weight();
+                render()
-                else if (sp == 2 || sp == 3)
+                difference() {
-                    linear_extrude(10*(h_base+off), center = true)
+                    translate(padding_start_point)
-                    profile_skeleton();
+                    cube(size_mm);
-                else if (sp == 4)
-                    translate([0,0,-5*(h_base+off)])
-                    rounded_square(length-2*r_c2-2*r_c1, 10*(h_base+off), r_fo3);
 
-
+                    translate([
-                hole_pattern(){
+                        -grid_size_mm.x/2,
-                    mirror([0, 0, 1])
+                        -grid_size_mm.y/2,
-                    block_base_hole(hole_options);
+                        0
-
+                    ])
-                    translate([0,0,-off-TOLLERANCE])
+                    cube(grid_size_mm);
-                    if (sh == 1) cutter_countersink();
-                    else if (sh == 2) cutter_counterbore();
                 }
             }
         }
-        screw_together = sp == 3 || sp == 4;
-        if (screw_together) cutter_screw_together(gx, gy, off);
-    }
 
+        // Round the outside corners (Including Padding)
+        for(i = [0:len(corner_points) - 1]) {
+                point = corner_points[i];
+                translate([
+                point.x + (BASEPLATE_OUTSIDE_RADIUS * -sign(point.x)),
+                point.y + (BASEPLATE_OUTSIDE_RADIUS * -sign(point.y)),
+                0
+            ])
+            rotate([0, 0, i*90])
+            square_baseplate_corner(additional_height, true);
+        }
+
+        if (screw_together) {
+            translate([0, 0, additional_height/2])
+            cutter_screw_together(grid_size.x, grid_size.y, length);
+        }
+    }
 }
 
 function calculate_offset(style_plate, enable_magnet, style_hole) =
@@ -182,23 +281,115 @@ module cutter_counterbore(){
     }
 }
 
-module profile_skeleton() {
+/**
-    l = l_grid-2*r_c2-2*r_c1;
+ * @brief Added or removed from the baseplate to square off or round the corners.
-    minkowski() {
+ * @param height Baseplate's height, excluding lip and clearance height.
-        difference() {
+ * @param subtract If the corner should be scaled to allow subtraction.
-            square([l-2*r_skel+2*d_clear,l-2*r_skel+2*d_clear], center = true);
+ */
-            pattern_circular(4)
+module square_baseplate_corner(height=0, subtract=false) {
-            translate([l_grid/2-d_hole_from_side,l_grid/2-d_hole_from_side,0])
+    assert(height >= 0);
-            minkowski() {
+    assert(is_bool(subtract));
-                square([l,l]);
+
-                circle(MAGNET_HOLE_RADIUS+r_skel+2);
+    subtract_ammount = subtract ? TOLLERANCE : 0;
-           }
+
-        }
+    translate([0, 0, -subtract_ammount])
-        circle(r_skel);
+    linear_extrude(height + BASEPLATE_LIP_MAX.y + (2 * subtract_ammount))
+    difference() {
+        square(BASEPLATE_OUTSIDE_RADIUS + subtract_ammount , center=false);
+        // TOLLERANCE needed to prevent a gap
+        circle(r=BASEPLATE_OUTSIDE_RADIUS - TOLLERANCE);
     }
 }
 
-module cutter_screw_together(gx, gy, off) {
+/**
+ * @brief Outer edge/lip of the baseplate.
+ * @details Includes clearance to ensure the base touches the lip
+ *          instead of the bottom.
+ * @param height Baseplate's height excluding lip and clearance height.
+ * @param width How wide a single baseplate is.  Only set if deviating from the standard!
+ * @param length How long a single baseplate is.  Only set if deviating from the standard!
+ */
+module baseplate_lip(height=0, width=l_grid, length=l_grid) {
+    assert(height >= 0);
+
+    // How far, in the +x direction,
+    // the lip needs to be from it's [0, 0] point
+    // such that when swept by 90 degrees to produce a corner,
+    // the outside edge has the desired radius.
+    translation_x = BASEPLATE_OUTSIDE_RADIUS - BASEPLATE_LIP_MAX.x;
+
+    additional_height = height + BASEPLATE_CLEARANCE_HEIGHT;
+
+    sweep_rounded(width-2*BASEPLATE_OUTSIDE_RADIUS, length-2*BASEPLATE_OUTSIDE_RADIUS)
+    translate([translation_x, additional_height, 0])
+    polygon(concat(BASEPLATE_LIP, [
+        [0, -additional_height],
+        [BASEPLATE_LIP_MAX.x, -additional_height],
+        [BASEPLATE_LIP_MAX.x, 0]
+    ]));
+}
+
+/**
+ * @brief Outer edge/lip of the baseplate, with square corners.
+ * @details Needed to prevent gaps when joining multiples together.
+ * @param height Baseplate's height excluding lip and clearance height.
+ * @param size Width/Length of a single baseplate.  Only set if deviating from the standard!
+ */
+module square_baseplate_lip(height=0, size = l_grid) {
+    assert(height >= 0 && size/2 >= BASEPLATE_OUTSIDE_RADIUS);
+
+    corner_center_distance = size/2 - BASEPLATE_OUTSIDE_RADIUS;
+
+    render(convexity = 2) // Fixes ghosting in preview
+    union() {
+        baseplate_lip(height, size, size);
+        pattern_circular(4)
+        translate([corner_center_distance, corner_center_distance, 0])
+        square_baseplate_corner(height);
+    }
+}
+
+/**
+ * @brief A single baseplate with square corners, a solid inner section, lip and the set clearance height.
+ * @param height Baseplate's height excluding lip and clearance height.
+ * @param size Width/Length of a single baseplate.  Only set if deviating from the standard!
+ * @details A height of zero is the equivalent of just calling square_baseplate_lip()
+ */
+module solid_square_baseplate(height=0, size = l_grid) {
+    assert(height >= 0 && size > 0);
+
+    union() {
+        square_baseplate_lip(height, size);
+        if (height > 0) {
+            linear_extrude(height)
+            square(size - BASEPLATE_OUTSIDE_RADIUS, center=true);
+        }
+    }
+}
+
+/**
+ * @brief 2d Cutter to skeletonize the baseplate.
+ * @param size Width/Length of a single baseplate.  Only set if deviating from the standard!
+ * @example difference(){
+ *              cube(large_number);
+ *              linear_extrude(large_number+TOLLERANCE)
+ *              profile_skeleton();
+ *          }
+ */
+module profile_skeleton(size=l_grid) {
+    l = size - 2*BASEPLATE_LIP_MAX.x;
+
+    offset(r_skel)
+    difference() {
+        square(l-2*r_skel, center = true);
+
+        hole_pattern()
+        offset(MAGNET_HOLE_RADIUS+r_skel+2)
+        square([l,l]);
+    }
+}
+
+module cutter_screw_together(gx, gy, size = l_grid) {
 
     screw(gx, gy);
     rotate([0,0,90])
@@ -206,10 +397,10 @@ module cutter_screw_together(gx, gy, off) {
 
     module screw(a, b) {
         copy_mirror([1,0,0])
-        translate([a*l_grid/2, 0, -off/2])
+        translate([a*size/2, 0, 0])
-        pattern_linear(1, b, 1, l_grid)
+        pattern_linear(1, b, 1, size)
         pattern_linear(1, n_screws, 1, d_screw_head + screw_spacing)
         rotate([0,90,0])
-        cylinder(h=l_grid/2, d=d_screw, center = true);
+        cylinder(h=size/2, d=d_screw, center = true);
     }
 }

gridfinity-spiral-vase.scad

@@ -161,7 +161,7 @@ module gridfinityBaseVase() {
         intersection() {
             block_base_blank(0);
             translate([0,0,-h_base-1])
-            rounded_rectangle(l_grid-0.5-0.005, l_grid-0.5-0.005, h_base*10, r_fo1+0.001);
+            rounded_square([l_grid-0.5-0.005, l_grid-0.5-0.005, h_base*10], r_fo1+0.001, center=true);
         }
         translate([0,0,0.01])
         difference() {
@@ -219,13 +219,17 @@ module block_magnet_blank(o = 0, half = true) {
 module block_base_blank(o = 0) {
     mirror([0,0,1]) {
         hull() {
-            rounded_square(l_grid-o-0.05-2*r_c2-2*r_c1, h_base, r_fo3);
+            linear_extrude(h_base)
-            rounded_square(l_grid-o-0.05-2*r_c2, h_base-r_c1, r_fo2);
+            rounded_square(l_grid-o-0.05-2*r_c2-2*r_c1, r_fo3, center=true);
+            linear_extrude(h_base-r_c1)
+            rounded_square(l_grid-o-0.05-2*r_c2, r_fo2, center=true);
         }
         hull() {
-            rounded_square(l_grid-o-0.05-2*r_c2, r_c2, r_fo2);
+            linear_extrude(r_c2)
+            rounded_square(l_grid-o-0.05-2*r_c2, r_fo2, center=true);
             mirror([0,0,1])
-            rounded_square(l_grid-o-0.05, d_bottom, r_fo1);
+            linear_extrude(d_bottom)
+            rounded_square(l_grid-o-0.05, r_fo1, center=true);
         }
     }
 }
@@ -523,7 +527,7 @@ module transform_scoop() {
 
 module block_vase(h = d_height*2) {
     translate([0,0,-0.1])
-    rounded_rectangle(gridx*l_grid-0.5-nozzle, gridy*l_grid-0.5-nozzle, h, r_base+0.01-nozzle/2);
+    rounded_square([gridx*l_grid-0.5-nozzle, gridy*l_grid-0.5-nozzle, h], r_base+0.01-nozzle/2, center=true);
 }
 
 module profile_x(x_f = 3) {

standard.scad

@@ -88,8 +88,11 @@ h_lip = 3.548;
 d_wall2 = r_base-r_c1-d_clear*sqrt(2);
 d_magic = -2*d_clear-2*d_wall+d_div;
 
-// Stacking Lip
+
+// ****************************************
+// Stacking Lip Constants
 // Based on https://gridfinity.xyz/specification/
+// ****************************************
 stacking_lip_inner_slope_height_mm = 0.7;
 stacking_lip_wall_height_mm = 1.8;
 stacking_lip_outer_slope_height_mm = 1.9;
@@ -106,8 +109,40 @@ stacking_lip_support_wall_height_mm = 1.2;
 stacking_lip_support_height_mm =
     stacking_lip_support_wall_height_mm + d_wall2;
 
-
+// ****************************************
 // Baseplate constants
+// Based on https://gridfinity.xyz/specification/
+// ****************************************
+BASEPLATE_OUTSIDE_RADIUS = 8 / 2;
+
+// Polygon describing the raw baseplate lip.
+// Does NOT include clearance height.
+BASEPLATE_LIP = [
+    [0, 0], // Innermost bottom point
+    [0.7, 0.7], // Up and out at a 45 degree angle
+    [0.7, (0.7+1.8)], // Straight up
+    [(0.7+2.15), (0.7+1.8+2.15)], // Up and out at a 45 degree angle
+    [(0.7+2.15), 0], // Straight down
+    [0, 0] //Back to start
+];
+
+// Height of the baseplate lip.
+// This ads clearance height to the polygon
+// that ensures the base makes contact with the baseplate lip.
+BASEPLATE_LIP_HEIGHT = 5;
+
+// The minimum height between the baseplate lip and anything below it.
+// Needed to make sure the base always makes contact with the baseplate lip.
+BASEPLATE_CLEARANCE_HEIGHT = BASEPLATE_LIP_HEIGHT - BASEPLATE_LIP[3].y;
+assert(BASEPLATE_CLEARANCE_HEIGHT > 0, "Negative clearance doesn't make sense.");
+
+// Maximum [x,y] values/size of the baseplate lip.
+// Includes clearance height!
+BASEPLATE_LIP_MAX = [BASEPLATE_LIP[3].x, BASEPLATE_LIP_HEIGHT];
+
+// ****************************************
+// Weighted Baseplate
+// ****************************************
 
 // Baseplate bottom part height (part added with weigthed=true)
 bp_h_bot = 6.4;
@@ -121,6 +156,9 @@ bp_rcut_width = 8.5;
 bp_rcut_length = 4.25;
 // Baseplate bottom cutout rounded thingy depth
 bp_rcut_depth = 2;
+
+// ****************************************
+
 // Baseplate clearance offset
 bp_xy_clearance = 0.5;
 // radius of cutout for skeletonized baseplate