$slop used incorrectly for threading and screws, or $slop doesn't work at small scales

[coryrc]

Describe the bug

Following the $slop calibration does not result in properly-sized holes for #6-32 holes or M7 nuts.

I have a Bambu A1 Mini, using PETG, and am printing some self-tap and clearance holes for #6-32 screws. I have the following diameters:

$slop	self-tap dia	self-tap measured	clearance dia	clearance measured
0.00	2.94	unk	3.91	unk
0.04	3.1	~3.0	unk	unk
0.08	unk	unk	4.23	3.9
0.22	3.81	3.67	4.79	4.45

In both cases, the calibrated $slop value resulted in holes far too big.

Yesterday I printed the slop tester and calculated 0.22 for slop. Using the raw threading.scad and with a printed M7 buttress thread and $slop = 0.22, I created working nut and screws printed vertically. Some numbers from that print:

$slop	nut innermost diameter	nut innermost measured
0.00	5.53	unk
0.22	6.38	6.22

However this just happened to work, because the tol_gap for a normal M7 in the screws.scad library would be about 0.8, which is passed to screw() as shaft_undersize=-0.8 so a normal fit would be 6.33mm innermost diameter and setting $slop = 0.22 coincidentally got a working value. (The threading.scad library does not have any tolerance adjustment besides $slop). Had I correctly compensated diameter for fit, then the nut would have been far too large.

This also resulted in holes too big having followed the calibration procedure and applying it.

Code To Reproduce Bug

module clamp_block() {
    diff() cube([1.9,6.5,12],anchor=BOT+RIGHT) {
        position(TOP+RIGHT) cube([2,6.3,1.9], anchor=TOP+LEFT);
        tag("remove") up(tapping_hole_z) position(BOTTOM) screw_hole(screw_info("#6-32"), tolerance="tight", l=10, orient=LEFT, $slop=0.22);
    }
}
module tapping_hole() {
    screw_hole(screw_info("#6-32"), tolerance="self tap", l=10, orient=LEFT, $slop=get_slop()/2);
}

// Has #6-32 Clearance hole
translate([-8.8,1.3,0]) recolor("blue") clamp_block();
// Has #6-32 tapping hole
difference() {
    translate([-5.7,1.3,0]) flatten_block();
    translate([-7,1.3,4]) tapping_hole();
}
// M7x1.0 Buttress-threaded nut
fwd(18.6)
buttress_threaded_nut(nutwidth=10,id=7,h=6,pitch=1,shape="square",orient=DOWN,anchor=BOT, $slop=0.22);

Printed in PETG, 0.2mm layer, 0.4mm nozzle.

Expected behavior

Following the documentation at https://github.com/BelfrySCAD/BOSL2/wiki/screws.scad and https://github.com/BelfrySCAD/BOSL2/wiki/threading.scad should yield holes with the intended diameter, or at least warn when the instructions are incorrect for certain edge cases.

Additional context
Add any other context about the problem here.

• OpenSCAD Version: 2025.02.19 (git 91070a09f)
• Other libraries used: BOSL2 master downloaded 2025-2-23 I believe

[adrianVmariano]

That $slop value of 0.22 is huge. I have used 0.05 on my Prusa mk3s. And with the screws in screws.scad, they already have clearance created by the screw tolerances. Whether the slop tester correctly predicts the slop, well, that I don't know. It could be that at different sized holes, and especially for small circles, the printer's over-extrusion is not the consistent. However, when I printed the slop tester, it clearly indicates that 0.05 is where I get a slip fit. At 0.2 it's a very sloppy, loose, fit.

It does appear that the slop tester isn't consistent with how screw sizing is done, because if I'm reading the code right, it creates a 2*slop adjustment to the hole width where as the screws code does it to the radius.

[coryrc]

It could be that at different sized holes, and especially for small circles, the printer's over-extrusion is not the consistent.

I think so. I'm going to make something to measure this on my printer and share it soon.

It does appear that the slop tester isn't consistent with how screw sizing is done, because if I'm reading the code right, it creates a 2*slop adjustment to the hole width where as the screws code does it to the radius.

screws.scad explicitly mentions thread diameter is affected by 4*$slop and clearance/self-tap holes are driven off that measurement. The code takes 4*$slop and applies it to internal holes, though I can't see how it affects the call to threaded_rod() that follows. You added the 4*$slop in this PR, but I can't find the motivation or why 4* was chosen.

The slop tester is a square and not a circle, which might also make it worse.

[adrianVmariano]

Maybe @revarbat can comment on this, since he's the one who designed the $slop system. I'm pretty sure that I followed his guidance in how $slop behaved for screws.

What do you mean about "how it affects the call to threaded_rod"? All the threaded_rod calls apply $slop if internal=true.

There's the other question which is: is your printer really so bad that you get a snug fit on the tester with $slop=0.22? Why would overextrusion be different for circles than squares? Unless the tight fit you get is entirely a result of extra overextrusion in the corners?

[coryrc]

What do you mean about "how it affects the call to threaded_rod"? All the threaded_rod calls apply $slop if internal=true.

Uh, right, I forgot. So non-threaded measurements -- clearance/tap holes and shanks, shoulders, and heads -- use 4*$slop because they all use islop which is set as 4*get_slop(), but the threads use 2*get_slop() because threading.scad calculates it itself.

I would think they should be the same if you were, as in my case, intending to use a metal machined screw with fairly tight tolerances; but with your low slop value it may not have been noticeable.

There's the other question which is: is your printer really so bad that you get a snug fit on the tester with $slop=0.22?

My flow rate is a bit higher than normal (1.045), but it's what was best using the top surface calibration with Orca Slicer. I also inadvertently printed the slop test with random seams which may have added excessive slop; I'm going to reprint and will update and document.

Even so, I updated my chart in the first post. With $slop=0.08 I get exactly the intended clearance hole size. If the clearance hole was using 2*get_slop() instead of 4*get_slop(), then the appropriate slop would be 0.16 which is getting pretty close to my "measured" value.

I'm also going to print the following to try to fit a curve to model hole size => actual hole size and whether it is dependent on hole diameter and/or orientation.

include <BOSL2/std.scad>

// Inputs
holes = 8;
start_dia = 0.5;
exponent = 1.75;
$fn=48;

module params() {
    lines = [str("holes = ", holes),
             str("start_dia = ", start_dia),
             str("exponent = ", exponent),
             str("$fn = ", $fn),
             ];
    size = 3;
    union(){ for (i = [0 : len(lines)-1])
      translate([0 , 0, -i * (size + 2) - size ]) text3d(lines[i], 1, size, orient=RIGHT,spin=90, anchor=TOP+LEFT);
    }
}

//params();

// Computations
function hole_dia(index) = start_dia*exponent^index;
function sum(v) = [for(p=v) 1]*v;
function hole_dia_through(index) = sum([for (i=[0:index]) hole_dia(i)]);
// 4mm between hole edges + 4mm on each end
width = hole_dia_through(holes-1) + 4*(holes+1);
// 4mm above and below biggest hole
height = hole_dia(holes-1) + 8;
depth = hole_dia(holes-1)+8;

module test_vertical_cylinders(index, _height=height, on_ground=false) {
    hole = hole_dia(index);
    right(hole/2) fwd(hole/2) cylinder(h=_height,d=hole,anchor=TOP)
        if(hole < (depth-8)/2) position(on_ground? BOT : TOP) fwd(hole+4) cube([hole,hole,2],anchor=on_ground? BOT : TOP);
    if (index>0) right(hole+4) test_vertical_cylinders(index-1, _height, on_ground);
}

fwd(10) up(3) test_vertical_cylinders(holes-1, _height=3, on_ground=true);

module test_horizontal_cylinders(index, _height=height) {
    hole = hole_dia(index);
    echo(hole);
    left(hole/2) up(hole/2) cylinder(h=_height,d=hole,anchor=TOP, orient=FWD);
    if(hole < (height-8)/2) left(hole/2) up(hole*1.5+4) yrot(45) cube([hole,min(_height,3),hole],anchor=FRONT);
    if (index>0) left(hole+4) test_horizontal_cylinders(index-1, _height);
}

//test_horizontal_cylinders(holes-1);

module test_block() {
    diff() cube([width, depth, height]) {
        tag("remove") fwd(4) right(4) position(TOP+LEFT+BACK) test_vertical_cylinders(holes-1);
        tag("remove") up(4) left(4) position(RIGHT+FRONT+BOT) test_horizontal_cylinders(holes-1, _height=depth/exponent);
        tag("remove") down(1) back(1) position(RIGHT+FRONT+TOP) params();
    }
}

test_block();

[adrianVmariano]

Look more carefully: threading.scad sets the RADIUS to use 2*get_slop() which means the diameter is 4*$slop. There is a guy who posted a thing about "polyholes" where he allegedly worked out a formula for how to produce properly sized holes at different scales, but when I tested it on my printer, it didn't seem to work. A problem with making the slop model more complicated here is that (1) we break existing code in a subtle way and (2) the complicated model may only work for your printer. At least with a simple linear model it's easy to understand and adjust as needed. We need to hear from @revarbat about why the 4 multiplier.

[revarbat]

In general, you look at the cross section of the object you want to insert into another, and use one $slop for each place they would touch along a given axis. That should give a snug fitting. If you need a loose fitting, you add 2*$slop instead. Since screws need to rotate within their threaded hole counterpart, the diameter of said threaded hole gets adjusted by 4*$slop.

That's the theory, at least. This seemed to work for the large parts of my printable printer (30mm 8pitch), but I never tried to make small (3mm) threaded holes. I always assumed that was beyond the resolution of my printer.

[adrianVmariano]

What does "snug" mean? I could probably force the test piece together with $slop=0, but I wouldn't be able to get it apart again without a hammer. At 0.05 it slides together easily with no play.

A clearance hole for a screw, if it is to receive a metal screw, would presumably need only two $slop factors, because the metal screws is presumably not oversized. You'd only need the full four factors if you wanted to mate a printed screw with a printed hole. But also, in the case of screws, the objects themselves have built-in clearance. It's not like trying to fit a 5mm object in a 5mm hole.

[coryrc]

Data

Here are my modeled and measured dimensions with $fn=48:

Modeled	Horizontal Hole ID	Vertical Hole ID	Vertical Cyl OD	Horizontal Diamond Side	Vertical Square Inside	Vertical Square Outside (flats)
0.500	0.5?	0	0.86	unk	0	0.8?
0.875	0.87?	0	1.1	0.73?	0	1.2?
1.53	1.42	0.8?	1.46	1.5	1.3	1.7
2.68	2.5	2.2	2.6	2.5	2.6	2.7
4.69	4.4	4.5	4.7	4.7	4.7	4.7
8.21	8.0	8.0	8.1	8.1	8.2	8.1
14.4	14.2	14.2	14.2	unk	unk	unk
25.1	24.9	24.9	24.9	unk	unk	unk
33.1	unk	unk	unk	unk	unk	33.1 (Y)
94.0	unk	unk	unk	unk	unk	93.8 (X)

Interpretations

Above a certain diameter (~8mm), ID and OD of cylinders/holes shrink a fixed amount (0.2mm). A fixed $slop value would work for all holes and orientations; but we should be adding something to the OD of bolts in screws.scad so the bolts actually match the intended size.

As diameter shrinks, the ID continues to be a fixed amount smaller, but the OD becomes accurate.

As diameter shrinks further, vertical holes go non-linear and collapse (polyholes documents why; I could retry the print after enabling polyholes). Horizontal holes eventually stabilize at an accurate ID (~2mm) down as small as I could see.

Conclusions

It seems $slop as currently implement (a fixed value) is accurate above a certain hole size. I'd like to update the documentation to note that below some hole size it's likely to need tweaking on a hole-by-hole basis, if you all are alright with that.

[coryrc]

is your printer really so bad that you get a snug fit on the tester with $slop=0.22? Why would overextrusion be different for circles than squares? Unless the tight fit you get is entirely a result of extra overextrusion in the corners?

Your last guess was correct, my corners have significant overshoot like this person. Looking at my collected data, for a 14.4mm round hole my $slop would be about 0.05 just like yours (I can just barely jam my test cylinder into the matching hole with $slop=0).

Look more carefully: threading.scad sets the RADIUS to use 2*get_slop() which means the diameter is 4*$slop.

D'oh. I get it now.

here is a guy who posted a thing about "polyholes" where he allegedly worked out a formula for how to produce properly sized holes at different scales

I see, polyholes and horiholes. So the size and shape of every hole is dependent on diameter, orientation, nozzle width, and layer height. Whew!

That should give a snug fitting. If you need a loose fitting, you add 2*$slop instead. Since screws need to rotate within their threaded hole counterpart, the diameter of said threaded hole gets adjusted by 4*$slop.

I'm sorry, I don't follow why rotating implies an additional doubling.

This seemed to work for the large parts of my printable printer (30mm 8pitch), but I never tried to make small (3mm) threaded holes.

I think this makes sense with the data I collected.

[adrianVmariano]

I wonder if the slop tester should be modified to have rounded corners on the plug portion.

Yeah, polyholes and horiholes are complicated, and don't seem to be generally accepted practice. It seems like some of what horiholes is supposed to accomplish is done by creating a small corner on the bottom of your horizontal hole. (The hole needs to be teardrop shaped to be printable.) And I also found polyholes uncompelling because for all of the fancy theory behind them, it didn't actually work on my printer.

Also you are getting undersized cylinders. My slop tester is measuring about 10.03mm x 10.00mm, so I'm not seeing that undersizing that you are. For larger objects you are getting the same size for both holes and cylinders. Is this due to PET shrinkage? My print is in PLA. I have no clue how different materials may vary with respect to printing accuracy.

We haven't yet heard from @revarbat about what a "snug" fit is. If a snug fit means that you can insert the part while encountering a small but nonzero resistance then that would be too tight for screws. Rotating means loose enough to move freely. But the whole screw business is complicated by the existence of a separate tolerance system for screws. You only need screw related parts to print at their exact modeled size, not to print with extra clearance, because clearance is built in already. There's also the issue of mixed materials that I previously noted, where a clearance hole gets 4*$slop but doesn't need it because it's mating to a metal screw that is correctly sized.

Another point: if you get a snug fit at $slop=0.2 you presumably don't need a 0.4 clearance for a freely turning fit. Probably 0.25 would suffice. The use of doubling to capture that seems questionable.

If you would like the either submit updates to the documentation, or perhaps an updated slop test fixture, I would welcome either one. But it does seem important to clearly identify the story here, as it's not clear that your printing experience matches mine. Perhaps you avoid absolute statements about the behavior of holes---maybe other printers are different than yours---but draw attention to the possibility that things could get messy when the holes are small. Does material make a significant difference? Might be interesting to include a test fixture for vertical and horizontal holes that people could test with drill bits---probably would need a metric and USA version. Also holes should use circum=true which doesn't matter at high $fn but would for smaller $fn, which will probably be used in practice.

[revarbat]

The term "snug" is for this purpose defined as "As snug as the fit of the plug in your $slop test print when you have it inserted into the hole corresponding to your chosen $slop value." ie: it should be insertable without applying high pressure, and it should be removable without breaking.

[adrianVmariano]

But "snug" is tighter than desired for screws?

[revarbat]

The theory is that the screw hole should be increased by 2*$slop for BOTH sides, as that will make it loose enough that you can screw in your screw without breaking your screw head off along a layer.

(Assuming both a printed screw and screwhole.)

[revarbat]

The concept of making a hole with plastic that can be screwed into with a metal bolt, having its threads biting into the plastic, is not (AFAIK) addressed by $slop, or by tolerances in the threading library at all.