Suggestion for improving PROBE_CALIBRATE usability

One thing that’s always bothered me immensely about klipper is that it’s necessary to set a negative position_min on [stepper_z] when calibrating a probe, it’s an accident waiting to happen (ADHD people will nod in agreement when i say: once that probe is calibrated, nobody remembers that negative position_min is still there in the config). We know when we’re calibrating, we know the actual Z is unknown at this point (that’s why we’re calibrating), so why are we still enforcing limits if we only have an inaccurate representation of the actual kinematic position? Why are we raising the risk of accidents? It seems like the intention is “always enforce” leads to less accidents, which normally would be true, but when we’re then suggesting people set unsafe limits on their axes (however temporarily), all that goes out the window.

I suggest changing TEST_Z so that it ignores the Z limit. My approach to this would be the following:

  1. Add an optional “triggering_axes” parameter to CommandError (or extend it as MoveError) in klipper/klippy/gcode.py:8

  2. Change existing kinematic implementations to aggregate rail indexes with offending limits, translate it to axes (xyz) and pass it along to the existing move.move_error call which would then pass it to the exception in klipper/klippy/toolhead.py:58

  3. Modify klipper/klippy/extras/manual_probe.py:166 to check the axes on e, if ‘z’ and only ‘z’, ignore else finalize and raise as usual.

What do you think?

3 Likes

I can relate to what you are saying here (and I believe most if not all users will also).

Having said that, I personally haven’t evaluated the implications (positive or not) of your proposed solution yet.

1 Like

Thanks for the feedback regardless!

As @pedrolamas stated: Without judging the implementation logic, I generally agree.

In fact it would solve two issues:

  • Users not setting a negative Z offset and thus running into “Move out of range” (something quite common actually)
  • Users setting -5 to get the tuning done and finally something like -0.3 would be sufficient and pose less danger of crashing into the bed

Edit:
Just spitballing, since it is not my field of expertise. Would it work to:

  • Ignore the Z limitation during probing
  • Dynamically assign a negative Z value depending on the loaded mesh, i.e. min(probed values) - 0.01
1 Like

First off, I’m not sure what the title “Suggestion for improving PROBE_CALIBRATE usability” has to do with having a position_min in the printer.cfg.

Secondly, I’ve always seen it as protection against there being something wonky (that being the technical term) in gcode. I agree with @Sineos that it should probably be changed to something like -0.3 as part of a successful PROBE_CALIBRATE.

If you’re looking for suggestions to improve PROBE_CALIBRATE, something that I’ve always wanted to see is moving the toolhead up 5+ mm after ACCEPTing the value so there’s no danger of striking anything (or scraping an unleveled bed) when restarting the printer.

  • Dynamically assign a negative Z value depending on the loaded mesh, i.e. min(probed values) - 0.01

I didn’t think of this, but i guess you’re right. Doesn’t it seem kinda strange that bed_mesh needs a negative [stepper_z] position_min as well? I mean, you’re trying to adapt the kinematics to real world Z0 not go below actual Z0. Changing that is way more complicated though, IIRC. It may be doable to adjust the kinematic limits dynamically based on the loaded mesh like you suggest, but it would require new functionality on the kinematics classes. Would have to look at code to see what that would look like.

First off, I’m not sure what the title “Suggestion for improving PROBE_CALIBRATE usability” has to do with having a position_min in the printer.cfg .

How does it not? Usability relates to ease of use, requiring not one but 2 config changes each time you want to run a gcode command (specifically PROBE_CALIBRATE) is the opposite of that. It’s also not easy to reason about as a newcomer.

Secondly, I’ve always seen it as protection against there being something wonky (that being the technical term) in gcode.

Yes that’s why the boundary checks are there, those stay. They are much less effective if you change position_min to say -5 (as recommended in the z_offset calibration klipper docs), and then forget to change it back. My proposal is to ignore the z boundary check during the TEST_Z command exclusively (or rather - ignore the error if only Z is beyond limits - the boundary check still runs). The checks would still function as normal in all other scenarios.

If you’re looking for suggestions to improve PROBE_CALIBRATE , something that I’ve always wanted to see is moving the toolhead up 5+ mm after ACCEPTing the value so there’s no danger of striking anything (or scraping an unleveled bed) when restarting the printer.

Yep, agree. Not really the point i wanted to discuss though, but we can continue that in a separate thread. Should i make the title more specific?

Isn’t this inevitable?
A bed is:

  • never 100% level
  • always has “valleys” and “mountains”

If you’d like to avoid going into the negative, you would have to identify the absolute minimum spot over the entire bed’s surface and declare it as Z=0.

Or do a mesh first and always home exactly on the min(probed values) location

Both feels kind of strange IMO

2 Likes

Sorry, what are the two config changes? I thought there was only one after PROBE_CALIBRATE and that was taken care of by SAVE_CONFIG.

I put in the suggestion because if you are suggesting to make a single or multiple changes to a function it’s always a good idea to get all the requirements so they can be put together at once rather than sometime afterward someone saying, I wish I knew you were making changes because I would like…

Yes, because of the way it’s implemented, it’s inevitable. Your bed mesh is a 2D map of where actual Z0 is. When you move your toolhead to a random point with a bed mesh active, the gcode position is still 0, not -0.231 (that’s the kinematic position - causing the error). That’s why i think it’s illogical. The same thing can be said about skew profiles for example, you’re trying to teach the software about the physical properties of your printer, that shouldn’t cause errors because it’s checking against boundaries that do not take these physical properties into account.

If the checks ran on gcode instructions instead of internal compensation implementations, this would be a non issue. But currently the checks are done against both internal and external input. Internal behavior should be covered via tests and static typing, not runtime checks imo. But that’s a software architecture discussion for another day i guess.

If you’d like to avoid going into the negative, you would have to identify the absolute minimum spot over the entire bed’s surface and declare it as Z=0.

The bed_mesh module attempts to approximate actual z0 for all points within the mesh, that’s our z0. Running boundary checks against the adjustments necessary to fix a flawed model (because it assumes perfection, nothing is 100% flat), doesn’t make sense to me. Maybe an adjustment threshold makes sense to make sure calibration results aren’t completely abnormal, but that goes in both directions, not just below 0.

Or do a mesh first and always home exactly on the min(probed values) location
Both feels kind of strange IMO

Agree on the latter example.

Sorry, what are the two config changes? I thought there was only one after PROBE_CALIBRATE and that was taken care of by SAVE_CONFIG .

That’s how it should be, the change i’m suggesting will actually accomplish that. In reality, you cannot run probe_calibrate without setting position_min to a negative value that’s less than the eventual (still uncalibrated and unknown) z_offset. So the user is advised to modify his config before run PROBE_CALIBRATE. See the last paragraph in Bed leveling - Klipper documentation (klipper3d.org).

There’s actually no mention of setting it back to 0, which kinda illustrates my point.

I put in the suggestion because if you are suggesting to make a single or multiple changes to a function it’s always a good idea to get all the requirements so they can be put together at once rather than sometime afterward someone saying, I wish I knew you were making changes because I would like…

That’s a different part of the code, should be a separate change, discussion and PR. What i’m suggesting (for a different problem) can be achieved with minimal code changes and potential side effects. I don’t want to change the scope of that, it’s much harder for a reviewer to consider the consequences of multiple changes like that in one big PR.

Your proposed changes would result in PROBE_CALIBRATE ignoring the error, but the toolhead still wont actually descend. So, PROBE_CALIBRATE wont report an error, it would just come up with completely bogus results. I can’t see any utility in that.

You also can’t simply bypass all the error checks (and descend no matter what is requested) because the current code (kin.check_move()) is integral to the kinematic code - specifically several kinematics (eg, delta) have to verify the coordinates in advance to ensure you don’t get divide by zero errors (or other completely non-sensical results).

You also really do want to configure limits even for manual homing tools, because many common printers mount an endstop near the z=0 position - an inadvertent command can easily rip that endstop off the printer. So, I think there is value in allowing the user to specify a “don’t rip the endstop off my printer” limit, that is not easily lifted by various software tools (which are often complex and may move in ways the user is not immediately expecting).

I’m guessing what you actually want is to implement two sets of error limits - the “definitely don’t rip the endstop off my my printer” limit and a “regular printing moves should not travel to this position” limit. It’s certainly possible to implement that.

FWIW, I would not recommend enabling an additional check like that by default, and I suspect few users would enable it by choice. The issue is, users really hate getting an error message. I fear it would be a bunch of development time that users would not utilize (and most guides would recommend against). For what it is worth, we see a notable number of users willing to disable the “don’t burn my house down checks” because they don’t want to get an error - I’m pretty sure the “maybe I didn’t want to move there error” wont be popular.

Another approach to solving the high-level problem described here is with documentation. As a corollary, in the past we’ve seen a number of users confused by the max_temp safety check - some users thought it was the “maximum temperature that it is normal to print at” and then complained when the printer shutdown due to minor temperature overshoot. We’ve had to explain that max_temp is instead “the maximum temperature that could ever be possibly valid, and beyond which is obviously incorrect and indicates that something has gone drastically wrong”. Similarly, the min_position is not the “minimum position that one would normal command the printer to” and is instead “the minimum position that indicates something has obviously gone wrong and we don’t ever want to move to because it will damage the printer”. As such, for example, after configuring it for PROBE_CALIBRATE you do not reconfigure it - as it is a statement about the extreme limits of the printer hardware and it is not a statement about normal printing positions.

Cheers,
-Kevin

4 Likes

Thanks for the detailed response, Kevin. I have to admit, it leaves me confused, likely due to some detail, I do not fully grasp.
Maybe to explain my understanding:

  1. I’m using a probe for bed meshing and end-stop
  2. I set position_min: -5 for the Z stepper
  3. BED_MESH_CALIBRATE yields probed points in the range of -0.3 and +0.2

With this setup, Klipper can now:

  • Compensate for my uneven bed, utilizing up to 0.3mm in negative Z direction
  • Move up to Z=-5, which would result in a crash

I could now modify my settings to position_min: -0.31, still allowing Klipper to do the mesh compensation but mitigating a potential “crash depth” from 5mm to 0.31mm.

Another approach would be to leave position_min: 0 and Klipper would dynamically allocate the needed head-room for mesh compensation according to the minimum value of the loaded mesh, i.e. -0.31mm.

This would have the advantage that Klipper disallows to manually crash the Z axis by 5mm and would relieve the users from having to specify a negative position_min only for bed_mesh purposes.

What am I missing?

1 Like

Sorry i think some things got mixed up here as we got sidetracked with the move checking in general (such as the case of bed_mesh actually needing a negative position_min in case points on the bed is lower than homed z=0). Apologize the lengthy reply here, but i feel like the point of this thread has been misunderstood.

I’ll clear it up:

  1. i do not want to bypass limit checking in general, nor do i think that’s a good idea in any sense of the imagination.
  2. I want to avoid requiring the user edit his config to add potentially dangerous limits (apropos your example of ripping off endstops - for Z that is probably the least expensive disaster i can think of) to simply run PROBE_CALIBRATE. All probes will trigger before the nozzle (obviously), so i will in all situations have to go into negative z to calibrate my probe. This is the extent of this proposition. Nothing more, everything else should function the same. Sorry the discussion got sidetracked.

Your proposed changes would result in PROBE_CALIBRATE ignoring the error, but the toolhead still wont actually descend. So, PROBE_CALIBRATE wont report an error, it would just come up with completely bogus results. I can’t see any utility in that.

Obviously that’s not the behavior i was looking for, i can’t see any utility in that either. You’re of course right that move() would stop execution when the error is raised in klippy/toolhead.py#L458.

How about reusing verify_no_manual_probe to sidestep kin.check_move() errors where z is the offending axis (refer to my initial suggestion) generated in toolhead.move()?

I’m guessing what you actually want is to implement two sets of error limits - the “definitely don’t rip the endstop off my my printer” limit and a “regular printing moves should not travel to this position” limit. It’s certainly possible to implement that.

No that’s not what i want. The “definitely don’t rip the endstop off my printer” should be position_min, and that should be 0. Not -5. Not -0.3. 0. In case of Z there’s only one general situation where you want to go below actual zero (if we ignore that bed_mesh, z_thermal_adjust etc needs negative zero to work as well - another topic of discussion), and that’s when you don’t actually know where Z0 is yet, such as before you have calibrated your probe or your endstop. I know some printers allow moving the toolhead outside the plate and may have some utility in negative Z when in that position, but that’s the exception, not the rule. It would still be possible to do this with a negative position_min, however that seems more appropriately handled by a different mechanism, but we don’t have to discuss that here as that case i not affected.

Would you not agree that it’s in general not safe to have a negative position_min on Z? Toolheads costs several hundreds of dollars today, and many performance oriented printers have Z drives powerful enough to break expensive things, especially when we’re talking large volume printers. Just a flexplate for a 500mm printer costs over $100.

FWIW, I would not recommend enabling an additional check like that by default, and I suspect few users would enable it by choice.

I’m assuming you’re referring to disabling all kinematic checks in general, in which case i agree (also never suggested such a thing). If you’re referring to disabling kinematics check for Z specifically, and only during probe calibration, then i very much disagree, and would love to know how you came to that conclusion.

The issue is, users really hate getting an error message.

I guess, but that’s not at all the issue, that was never the concern. The issue is when you need to calibrate your probe when provisioning your printer, you need to edit your config and restart your machine twice (not counting SAVE_CONFIG), not only that, but it’s for non obvious reasons that you have to dig up in the bed leveling docs. It’s not only a poor user experience, it’s a significant risk if the user forgets to reset position_min to 0 (and they do forget, more than you know).

For what it is worth, we see a notable number of users willing to disable the “don’t burn my house down checks” because they don’t want to get an error - I’m pretty sure the “maybe I didn’t want to move there error” wont be popular.

This is continuing down i sidetrack i never intended or suggested.

Another approach to solving the high-level problem described here is with documentation.

Generally you don’t solve poor illogical user experiences by making the user read more documents. That’s the last resort. If you have to explain an interaction scenario, you’ve failed as a UX designer (i say that having had to explain multiple designs in the past, and will have to explain and fix multiple designs in the future, nothing is perfect).

in the past we’ve seen a number of users confused by the max_temp safety check - some users thought it was the “maximum temperature that it is normal to print at” and then complained when the printer shutdown due to minor temperature overshoot. We’ve had to explain that max_temp is instead “the maximum temperature that could ever be possibly valid, and beyond which is obviously incorrect and indicates that something has gone drastically wrong”.

Not comparable. Again i’m not talking about the error, i’m talking about all the hoops you have to jump through to calibrate a probe and not set yourself up for disaster.

Similarly, the min_position is not the “minimum position that one would normal command the printer to” and is instead “the minimum position that indicates something has obviously gone wrong and we don’t ever want to move to because it will damage the printer”

I mean you just said it right there. By that logic, why are we telling users to set their [stepper_z] position_min to a negative value to run PROBE_CALIBRATE?

As such, for example, after configuring it for PROBE_CALIBRATE you do not reconfigure it - as it is a statement about the extreme limits of the printer hardware and it is not a statement about normal printing positions.

If i need to set it to -5 to calibrate my probe and end up with a z_offset of 5 in my config, then running G28 and G0 Z-5 will break my hotend. No? [probe] reports z_offset as position_endstop, that means when it triggers, the nozzle makes contact at kinematic Z0. I can still move to Z-5, that breaks things.

2 Likes

Lots of good points in this thread.
BTW- Hi, Dave here, I’m new

Klipper is a bit doc lacking, but some is to be expected from growing pains, i.e. when I setup my USB Acel, Docs all outlined using a 2040 w/ SPI and several steps I was able to skip. Thats to be expected.
However, the few but large frustrations I have had is because some things are just not intuitive. You hit the nail on the head there miklschmidt. Those are usually compounded by the Klipper Doc Modis Operandi of " do these things…, then THIS…, and continue on with… large subject topic" with no links, no description, no further details at all on the “THIS”. Meanwhile I’m yelling at my computer like a monkey "YES. THAT… Thats what I want to do! HOW ???.

I’m chuckling a bit because I just had this exact conversation about these exact points in this topic with another engineer about 2 days ago.

The ‘out of bounds’ thing does seem to be common and speaking firsthand as a user first, when you don’t figure it out after a few attempts because it’s not intuitive or even logical it seems, you start playing the “throw everything until something sticks” game. Using inflated values, often bypassing or ignoring the safety checks which defeats the entire purpose anyway. This isn’t just me, this is human nature for some of us. We want to try everything before asking for help. It can be a number of reasons why but that’s beside the point.

I had run into a couple other safety check issues myself; the temps weren’t rising quick enough to do a PID tune on a stock printer. Another in relation to the slicers value of overall filament extruded vs. Klipper or something to that affect. The common theme seems to be overly secure defaults, which in the world of security and cyber security, usually means very insecure. Because it’s going to be bypassed by the user. I could probably give dozens if not hundreds of real-life examples on that. Hell now that I think about it, some might even by mine, anyway moving on.

My printer has a mag-reed style switch and probe. The Mag switch hits at something like 5mm nozzle tip to bed, the probe is around 3.5mm from trigger to tip-to-bed.

When I originally setup Klipper I had taken those measurements and plugged in what I thought would be logical values based on that. Essentially, how far is the tip from the bed when the switch triggers, How much should the printer be allowed to go beyond the trigger point. because what other info do we possibly need, and that’s how it’s been done on my other printers and in Marlin. That did not work. The example config wasn’t working either, I wasn’t alone when I started Googling for an answer. A younger version of myself would have probably said “fine, you can go a million billion beyond the trigger, just f’n start a print already so I can babystep exact figures”.

The probe setting in general isn’t intuitive and if you argue that then my counter argument is

??? 1.598 ???
– - + ++

All the while I’m thinking where did it just pull that number from, and why does it look just as confused as I am right now.

Thanks for the feedback. I’m a bit confused as well. I don’t understand the alternate proposals.

The position_min today is implemented as a restriction on where the software will command the Z carriage along the Z rail. It is implemented that way because Klipper only knows the Z carriage position and only directly controls the Z carriage position. (Things are a little more complex on delta and other unusual kinematics, but the core idea remains the same - the restriction is on the carriages not on the bed position.)

So, for example, if one sets position_endstop: 230 and sets position_min: -1 then the software will avoid commanding the Z carriage more than 231mm from where the carriage was when the endstop triggered. Similarly, if position_endstop: 0 and position_min: -2 then the software will avoid commanding more than 2mm of travel on the carriage.

It would be great if Klipper could implement a restriction on the distance between the bed and the nozzle. (Something like, “never let the nozzle get within 0.1mm of the bed”.) Unfortunately, no common printer hardware is capable of directly monitoring that distance and Klipper is not capable of directly controlling that distance.

The carriage restrictions are important because many common printers place a Z endstop on the Z rail near the bed. So, for example, one might specify position_endstop: 0 and position_min: -1. This indicates that the software may go 1mm further past the endstop trigger point. This is valid for many switches, as they can safely be depressed a mm or so beyond their trigger point. Going 4-5mm though would likely permanently damage them.

If I’m understanding some of the proposals here, they involve disabling distance checks on PROBE_CALIBRATE and/or TESTZ. This would not be a good idea, because movements generated by these commands can still permanently damage an endstop. That is, in the example above with position_endstop: 0 and position_min: -1, a PROBE_CALIBRATE that commands 4mm of descent on the stepper is likely to damage the endstop.

I’m not sure what is being proposed here. As before, we could implement the existing “carriage check” along with a new “estimated bed distance check during normal printing”, but I’m being told that is not what is being proposed.

Cheers,
-Kevin

If I’m understanding some of the proposals here, they involve disabling distance checks on PROBE_CALIBRATE and/or TESTZ. This would not be a good idea, because movements generated by these commands can still permanently damage an endstop. That is, in the example above with position_endstop: 0 and position_min: -1, a PROBE_CALIBRATE that commands 4mm of descent on the stepper is likely to damage the endstop.

Valid concern, and easily addressable (which is all in the OP as it stands). So the following conditions have to be met before the kin.check_move() error is ignored in toolhead.move() during probe calibration:

  1. A manual probe is in progress (See verify_no_manual_probe)
  2. Offending axis have to be the axis where the probe that is being calibrated is assigned as a virtual endstop - and only that axis.

These two checks ensure that:

  1. Move out of bounds errors are only ignored during an active manual probe procedure.
  2. We’re not enforcing invalid limits of the axis (an uncalibrated probe = uncalibrated position_endstop = invalid position_min.)
  3. We know there’s no endstop that can be ripped off on that axis (the endstop is the probe that is being calibrated).

Does that address your concern?

I’m not sure what is being proposed here. As before, we could implement the existing “carriage check” along with a new “estimated bed distance check during normal printing”, but I’m being told that is not what is being proposed.

I’ll try defining what i laid out in the OP as succinctly as i can.

The problem
Users have to specify a negative position_min when calibrating a probe that’s also used as an endstop (extremely common, all the 7 printers i’ve owned had Z axes that work this way), this is a problem for the following reasons:

important preface: This is seen described from the users perspective, assume no knowledge of klipper internals:

  1. It’s not intuitive, the minimum position on Z should intuitively be 0, that’s when the nozzle contacts the bed. This is ubiquitous in 3d printing. It is also how it’s explained in several places in the klipper documentation, i can provide sources if needed.
  2. It’s an extra step in the calibration process, with no benefits.
  3. After probe_calibration, the negative position_min is still in the config. The user’s axis is now fully allowed to travel beyond the safe limits of their printer. G0 Z-5 means broken hotend / toolhead, indentation in print surface, bent bed plate and other expensive situations. This is what i characterized previously as the “disaster” that the user has been instructed to set themselves up for. The user never intended this to happen - they want the printer to yell at them if they accidentally try to move beyond bed/nozzle contact - as much as it is possible given imperfect bed shapes, probe drift and what have we.
  4. (related to 3) The status quo is that we not only actively tell users to effectively disable the position_min: 0 limit - it’s a requirement to run PROBE_CALIBRATE, it will unexpectedly fail otherwise. There is nothing as frustrating as damaging your sparkly new hardware before you’ve even seen plastic coming out of it. It’s still frustrating if it happens months later.
  5. The bed_level documentation says position_min: -2. This is not enough for several probe types on the market. The user now has to edit the config a second time.
  6. The Move out of bounds error (which in normal circumstances are good) they’re getting doesn’t make much sense unless they know what’s going on under the hood (what you, Kevin, just explained in abstract and principal terms). In the user’s mind, there is no bounds on Z yet. They haven’t calibrated it.
  7. The position_min limit is arbitrary until the probe has been calibrated. The odds that it is correct on first run are astronomically small - there is simply no point in enforcing it during calibration provided that probe is used as a virtual endstop pin for that axis.
  8. The documentation does not tell the user to reset position_min to 0 even though the probe will cause the axis’ endstop_position to be equal to it’s z_offset. That means: z=0 equals nozzle/bed contact according to last calibration. Even if it did, it’s very easy to forget.

Feel free to counter or supplement these points.

My proposed solution, adapted to address your (Kevin’s) concerns

  1. Add an optional “triggering_axes” parameter to CommandError (or extend it as MoveError) in klipper/klippy/gcode.py:8
  2. Change all kinematic classes’ implementation of check_move() to aggregate rail indexes with offending limits, translate it to axes (xyz) and pass it along to the existing move.move_error call which would then pass it to the exception in klipper/klippy/toolhead.py:58
  3. Modify toolhead.move() to wrap the kin.check_move() call in a try/catch clause and check the axes on the error instance, if present. If the offending axis matches the axis for which the probe of a currently in progress manual_probe procedure (the inverse of verify_no_manual_probe) is used as the virtual_endstop - ignore the error and proceed with adding the move to the move_queue.

I’m not aware if there are any other steps that run kin.check_move() again when the move is flushed, if that’s the case, i would have to look at that too.

Currently known side effects of proposed solution

  1. Besides PROBE_CALIBRATE, ManualProbeHelper is also used for calibrating axis twist compensation, which means AXIS_TWIST_COMPENSATION_CALIBRATE will be affected. This my or may not be desired. If we want to avoid that i will find a way.

Feel free to critique the implementation and suggest alternative ways to accomplish this goal without major changes to klippers internal behavior. However, if y’all think there’s a deeper flaw with how the boundary checks are implemented (i don’t currently think that’s the case, even if i may have other architectural preferences), i will be happy to discuss that in another thread.

DIsclaimer
This is not intended to modify the behavior of any moves outside of an active manual_probe procedure. It’s not intended to address similar inconviences with bed_mesh, z_tilt, skew, z_thermal_adjust or any other Z correcting functionality. This only addresses probe calibration for virtual endstops, which is a very clear cut case where this boundary check serves no purpose and worsens the user experience.

I hope this makes it clear what i intended with this thread. I’m not saying there aren’t other areas with similar challenges worth discussing, i’m saying those are more complicated, and i prefer fixing one problem at a time. I do not think there’s any inherent problem in the boundary checks, but PROBE_CALIBRATE for virtual_endstops is one very clear exception, unless there’s something significant i’m missing. So far nothing has been brought up to counter this claim. 100% of my users who use probes, use them as virtual_endstops. I currently have over 26.000 image downloads.

Thank you for coming to my TED talk :joy:

I think it’s worth adding a software movement limitation feature.
During printing, this will determine the print volume.
During homing or probing or other special movements, this will be temporarily changed.
Something like software endstops in Marlin (M211) but configurable in runtime

So similar to what kevin described in his first reply?

I’m guessing what you actually want is to implement two sets of error limits - the “definitely don’t rip the endstop off my my printer” limit and a “regular printing moves should not travel to this position” limit. It’s certainly possible to implement that.

I would call that “physical limits” (when stuff breaks, or axis is physically obstructed) vs “virtual limits” (what is valid in terms of g-code instructions), if we want to make that distinction. I can certainly see the logic and potential use cases for that, but unfortunately not for the problem i’ve defined in this thread.

I’m very hesitant to solve what (to the user) seems like unintended behavior that is already complex to understand (see my description of “the problem”), by introducing more user facing complexity. I am also unsure how it would solve the problem with the probe calibration procedure for virtual endstops where one for obvious reasons is unable to define a physical limit at all (that limit is found via PROBE_CALIBRATE). Can you explain how another limit would change the procedure from what it is currently, and how it addresses each of the points i laid out?

It may be a potential solution for other scenarios which i would love to discuss some other time, but that is outside my intended scope of this thread.

Interesting discussion, but speaking for myself (I’m clinically diagnosed with ASD and ADHD), I don’t really see how this is a problem?

I’ve been running custom Klipper machines for several years, and not once has forgetting about this setting caused me an issue.

Maybe I’m just lucky. :man_shrugging: