Lesson 8: Advanced Parametric Design and Interlocking Features

Estimated time: 90-120 minutes

Learning Objectives

• Design parametric walls with precise clearances for stackable assemblies¹
• Create interlocking features (rims, tabs, snap-fits) for assembly without fasteners²
• Apply chamfers for edge finishing and print quality³
• Manage tolerance stack-up in complex parametric designs¹

Materials

• 3dMake project scaffold with src/main.scad
• Calipers for measuring clearances and wall thickness
• Printer for test prints (recommended for validation)

Related Project: Work through stackable_bins.scad to apply tolerance design in a multi-part assembly with interlocking features.

Understanding Tolerance and Clearance

In 3D printing, tolerance refers to the acceptable variation in printed dimensions. When designing parts that must fit together, you must account for:

• Printer accuracy (~0.1-0.3 mm typical)
• Material shrinkage (PLA: ~0.3-0.5%)
• Cumulative tolerance when multiple parts fit together

For stackable bins with interlocking rims:

bin_outer = 80 mm
rim_clearance = 0.6 mm  (small space between stack and rim below)
rim_inner = bin_outer - 2*wall - 2*rim_clearance

Step-by-step Tasks

Task 1: Design a Parametric Stackable Bin

Create a storage bin with walls, a removable lid, and interlocking features:

// Stackable Storage Bin - Advanced Parametric Design
// Features: walls, interlocking rim, chamfered edges, optional dividers

// === PARAMETERS ===
bin_w = 80;         // mm - width
bin_d = 120;        // mm - depth
bin_h = 60;         // mm - height
wall = 2;           // mm - wall thickness (structural)
rim = 3;            // mm - interlock rim height
chamfer = 2;        // mm - edge chamfer
stack_clear = 0.6;  // mm - clearance between stacking parts

// Derived parameters
inner_w = bin_w - 2*wall;
inner_d = bin_d - 2*wall;
rim_inner_w = bin_w - 2*(wall + stack_clear);
rim_inner_d = bin_d - 2*(wall + stack_clear);

// === MODULES ===

// Outer shell of the bin
module outer_shell() {
  cube([bin_w, bin_d, bin_h]);
}

// Inner cavity (creates walls by subtracting)
module inner_cavity() {
  translate([wall, wall, wall])
    cube([inner_w, inner_d, bin_h - wall]);
}

// Main bin body (hollow box)
module body() {
  difference() {
    outer_shell();
    inner_cavity();
  }
}

// Outer rim (sits on top of bin, inside rim of bin below)
module rim_outer() {
  translate([0, 0, bin_h])
    cube([bin_w, bin_d, rim]);
}

// Inner rim cutout (where the bin below's rim sits)
module rim_inner() {
  translate([wall + stack_clear, wall + stack_clear, bin_h])
    cube([rim_inner_w, rim_inner_d, rim]);
}

// Rim assembly (outer + inner cutout)
module rim_assembly() {
  difference() {
    rim_outer();
    rim_inner();
  }
}

// Chamfer edges for better print quality
module chamfered_edges() {
  difference() {
    children();
    // Top edge chamfer
    translate([-1, -1, bin_h - chamfer])
      cube([bin_w + 2, bin_d + 2, chamfer + 1]);
  }
}

// === ASSEMBLE ===
union() {
  chamfered_edges() {
    body();
  }
  rim_assembly();
}

Task 2: Test Stackability

After printing the first bin:

1. Print a second identical bin
2. Stack one on top of the other and verify:
   • Does the rim insert smoothly into the rim below?
   • Can you stack 3 bins without binding?
   • Does the stack remain stable without tipping?

Document:

• Any friction or resistance (good for stability)
• Gaps or looseness (adjust stack_clear if needed)

Task 3: Design Variants for Different Storage Needs

Create three different bin sizes using the same parametric code:

// Small bin (desk organization)
bin_w = 60;
bin_d = 80;
bin_h = 40;

// OR

// Medium bin (general storage)
// bin_w = 80;
// bin_d = 120;
// bin_h = 60;

// OR

// Large bin (bulk storage)
// bin_w = 120;
// bin_d = 160;
// bin_h = 80;

Task 4: Add Optional Internal Dividers

Enhance the design with parametric dividers:

// Optional: Parametric dividers
num_dividers = 2;        // Number of internal compartments
divider_thickness = 1.5; // mm

module dividers() {
  for (i = [1 : num_dividers]) {
    y_pos = wall + (i * inner_d / (num_dividers + 1));
    translate([wall, y_pos, wall])
      cube([inner_w, divider_thickness, bin_h - 2*wall]);
  }
}

// Add to union:
// dividers();

Task 5: Document Tolerance Sensitivity

Create a testing matrix to understand how variations affect fit:

Test Configuration Matrix:
========================================
Config | stack_clear | wall | Result
========================================
A      | 0.4 mm      | 2.0  | Tight - hard to stack
B      | 0.6 mm      | 2.0  | Ideal - smooth fit
C      | 0.8 mm      | 2.0  | Loose - unstable
D      | 0.6 mm      | 2.5  | Better - stronger walls
========================================

After printing and testing, record observations about fit quality.

Advanced Topics: Snap-Fit Connectors and Multi-Part Assemblies

As you progress beyond simple stacking, you may want to create assemblies where parts connect without fasteners. This section covers snap-fit and interlocking designs.

Designing Snap-Fit Clips

A snap-fit clip works by:

1. Creating a flexible arm that bends outward to release
2. Providing a catch (usually a small notch or undercut) that locks into place
3. Balancing flexibility (easy to insert/remove) with durability (survives many cycles)

Here’s a simple snap-fit connector:

// Simple snap-fit clip for connecting parts
module snap_fit_base() {
  // Main mounting block
  cube([20, 40, 15]);
}

module snap_fit_arm(thickness = 1.5, deflection = 0.5) {
  // Flexible arm that bends to insert/release
  // thickness: how thick the arm is (0.8-2.0 mm typical)
  // deflection: how far it must bend to insert (0.3-1.0 mm typical)
  
  translate([0, 0, 15]) {
    // Thin vertical arm
    cube([thickness, 35, 12]);
    
    // Catch hook (small bump on end)
    translate([-1, 30, 10])
      cube([3, 5, 2]);  // Notch for mating part to lock onto
  }
}

// Test the snap-fit assembly
union() {
  snap_fit_base();
  translate([3, 0, 0]) snap_fit_arm();
}

Key parameters to test:

• thickness (1.0-2.0 mm): Thicker = stronger but harder to flex
• Arm length: Longer = more flexible but weaker
• Catch geometry: Size and shape determine how securely parts lock

Tolerance for Snap-Fits

Unlike stackable bins, snap-fit parts need tighter tolerances because they must flex on insertion:

Recommended tolerances for snap-fit:
- Arm thickness tolerance: +/-0.2 mm (tighter than bins)
- Catch gap (clearance): 0.3-0.5 mm (smaller than stacking clearance)
- Insertion force: Should be noticeable but not require tools

If too loose: Parts fall apart
If too tight: Parts won't insert or break on insertion

Multi-Part Assemblies: Coordinating Multiple Components

For more complex assemblies (like the Miniature Assembly in later projects), you need to:

1. Define a global coordinate system where all parts know their positions
2. Use modular design so each part can be printed, tested, and refined independently
3. Document assembly order so users know which parts fit together first

Here’s a pattern for a multi-part assembly:

// Multi-part assembly pattern

// === ASSEMBLY PARAMETERS ===
assembly_id = "miniature_furniture";  // Unique name for this assembly
part_scale = 1.0;                     // Scale entire assembly if needed

// === PARTS ===

module part_base() {
  cube([60, 40, 5]);
}

module part_support_left() {
  translate([5, 0, 5])
    cube([3, 40, 25]);
}

module part_support_right() {
  translate([52, 0, 5])
    cube([3, 40, 25]);
}

module part_shelf() {
  translate([8, 5, 18])
    cube([44, 30, 2]);
}

// === ASSEMBLY ===

// Complete assembly (print individual parts separately first)
module furniture_assembly() {
  part_base();
  part_support_left();
  part_support_right();
  part_shelf();
}

// Export individual parts by uncommenting one at a time:
// part_base();
// part_support_left();
// part_support_right();
// part_shelf();

// Or export the full assembly:
furniture_assembly();

Best practices for multi-part designs:

1. Print and test parts individually before assembling
2. Add small alignment features (pins, notches) to guide assembly
3. Document which parts go together and the order
4. Include spare parts (print 2-3 copies of small connecting pieces)
5. Test the full assembly on a test print before final production

Assembly Documentation

For any multi-part project, create a simple assembly guide:

Miniature Furniture Assembly Guide

Parts:
- Base (60 x 40 x 5 mm, prints in ~20 min)
- Support Left (3 x 40 x 25 mm, prints in ~5 min)
- Support Right (3 x 40 x 25 mm, prints in ~5 min)
- Shelf (44 x 30 x 2 mm, prints in ~15 min)

Assembly Steps:
1. Prepare all four parts and test fit manually
2. Glue or snap supports to base (supports on left and right edges)
3. Slide shelf onto supports
4. Check that shelf is level and square

Quality Checks:
- Shelf should not wobble or flex excessively
- All parts should be free of support marks or defects
- Shelf should hold light objects without sagging

Advanced: Chamfers and Surface Finish

Chamfers improve print quality by:

1. Reducing stress concentration at edges
2. Improving layer adhesion at sharp transitions
3. Making parts easier to remove from the build platform

// More sophisticated chamfer (chamfered corner)
module chamfer_corner(size, radius) {
  difference() {
    children();
    translate([size-radius, size-radius, size-radius])
      rotate([45, 0, 0]) cube([radius*2, radius*2, radius*2]);
  }
}

Checkpoint

• After task 1, you have a single parametric bin
• After task 2, you’ve verified stackability
• After task 4, you have optional dividers working
• After task 5, you’ve documented tolerance data

Quiz - Lesson 3dMake.8 (10 questions)

1. What is the purpose of the stack_clear parameter in stackable bin design¹?
2. Why is wall thickness a critical parameter in structural parts¹?
3. Explain what “tolerance stack-up” means and why it matters in multi-part assemblies¹.
4. How does chamfering improve print quality³?
5. What parameter would you adjust to make bins stack with more friction for stability¹?
6. True or False: Thin walls always print faster than thick walls.
7. Describe the difference between the outer rim and inner rim in the stackable bin design¹.
8. Why might you use num_dividers as a parameter instead of hard-coding divider positions¹?
9. How would you measure whether your printed bin matches the designed dimensions¹?
10. What design considerations apply when stacking more than 3 bins vertically¹?

Extension Problems (10)

1. Create five bin variants (small, medium, large, tall, shallow) using parametric logic; print and stack them¹.
2. Add parametric rounded corners using minkowski() to improve structural integrity³.
3. Design a custom divider system: parameterize number, position, and thickness; test strength¹.
4. Conduct a tolerance study: print bins with stack_clear values of 0.4, 0.6, 0.8 mm; document fit quality¹.
5. Create a modular stacking system with connecting clips or latches; test assembly and disassembly².
6. Build a complete storage system: design multiple bin sizes with standard stackability and create an assembly guide.
7. Develop a manufacturing specification document: tolerance ranges, material recommendations, quality acceptance criteria.
8. Design a labeling system: add parametric label holders or embossed areas for identifying bin contents.
9. Create a structural analysis guide: identify stress concentration points and propose reinforcement strategies.
10. Write comprehensive bin design documentation: parameters, variants, assembly, stackability testing, tolerance management, maintenance, and accessibility features.

References

1. 3DMake GitHub - Stackable Bins Example - https://github.com/tdeck/3dmake/blob/main/docs/examples.md ↩ ↩2 ↩3 ↩4 ↩5 ↩6 ↩7 ↩8 ↩9 ↩10 ↩11 ↩12 ↩13

2. Engineering Tolerance in 3D Printing - https://www.sculpteo.com/en/blog/2021/06/17/tolerance-3d-printing/ ↩ ↩2

3. OpenSCAD Manual - Minkowski (chamfers/rounding) - https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Transformations#minkowski ↩ ↩2 ↩3