andrey
/
Marlin_FB4S
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Update UBL mesh boundaries to accomidate beds centered at 0, 0 (#8012)

pull/1/head
Thomas Moore 7 years ago
committed by Roxy-3D
parent
6cb26c98c8
commit
67cc29cd3c
31 changed files with 1860 additions and 248 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 68
      Marlin/Configuration_adv.h
  2. 68
      Marlin/src/config/default/Configuration_adv.h
  3. 68
      Marlin/src/config/examples/AlephObjects/TAZ4/Configuration_adv.h
  4. 68
      Marlin/src/config/examples/Anet/A6/Configuration_adv.h
  5. 68
      Marlin/src/config/examples/Anet/A8/Configuration_adv.h
  6. 68
      Marlin/src/config/examples/BQ/Hephestos/Configuration_adv.h
  7. 68
      Marlin/src/config/examples/BQ/Hephestos_2/Configuration_adv.h
  8. 68
      Marlin/src/config/examples/BQ/WITBOX/Configuration_adv.h
  9. 68
      Marlin/src/config/examples/Cartesio/Configuration_adv.h
  10. 68
      Marlin/src/config/examples/Creality/CR-10/Configuration_adv.h
  11. 68
      Marlin/src/config/examples/Felix/Configuration_adv.h
  12. 68
      Marlin/src/config/examples/Folger Tech/i3-2020/Configuration_adv.h
  13. 68
      Marlin/src/config/examples/Infitary/i3-M508/Configuration_adv.h
  14. 68
      Marlin/src/config/examples/Malyan/M150/Configuration_adv.h
  15. 68
      Marlin/src/config/examples/Mks/Sbase/Configuration_adv.h
  16. 68
      Marlin/src/config/examples/RigidBot/Configuration_adv.h
  17. 68
      Marlin/src/config/examples/SCARA/Configuration_adv.h
  18. 68
      Marlin/src/config/examples/Sanguinololu/Configuration_adv.h
  19. 68
      Marlin/src/config/examples/TinyBoy2/Configuration_adv.h
  20. 68
      Marlin/src/config/examples/Velleman/K8200/Configuration_adv.h
  21. 68
      Marlin/src/config/examples/Velleman/K8400/Configuration_adv.h
  22. 68
      Marlin/src/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h
  23. 68
      Marlin/src/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h
  24. 68
      Marlin/src/config/examples/delta/generic/Configuration_adv.h
  25. 68
      Marlin/src/config/examples/delta/kossel_mini/Configuration_adv.h
  26. 68
      Marlin/src/config/examples/delta/kossel_pro/Configuration_adv.h
  27. 68
      Marlin/src/config/examples/delta/kossel_xl/Configuration_adv.h
  28. 68
      Marlin/src/config/examples/gCreate/gMax1.5+/Configuration_adv.h
  29. 68
      Marlin/src/config/examples/makibox/Configuration_adv.h
  30. 68
      Marlin/src/config/examples/tvrrug/Round2/Configuration_adv.h
  31. 68
      Marlin/src/config/examples/wt150/Configuration_adv.h

68
Marlin/Configuration_adv.h
View File

@ -674,19 +674,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/default/Configuration_adv.h
View File

@ -674,19 +674,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/AlephObjects/TAZ4/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Anet/A6/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Anet/A8/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/BQ/Hephestos/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/BQ/Hephestos_2/Configuration_adv.h
View File

@ -670,19 +670,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/BQ/WITBOX/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Cartesio/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Creality/CR-10/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Felix/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Folger Tech/i3-2020/Configuration_adv.h
View File

@ -674,19 +674,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Infitary/i3-M508/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Malyan/M150/Configuration_adv.h
View File

@ -670,19 +670,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Mks/Sbase/Configuration_adv.h
View File

@ -694,19 +694,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/RigidBot/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/SCARA/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Sanguinololu/Configuration_adv.h
View File

@ -662,19 +662,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/TinyBoy2/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Velleman/K8200/Configuration_adv.h
View File

@ -683,19 +683,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/Velleman/K8400/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/delta/FLSUN/auto_calibrate/Configuration_adv.h
View File

@ -675,19 +675,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/delta/FLSUN/kossel_mini/Configuration_adv.h
View File

@ -675,19 +675,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/delta/generic/Configuration_adv.h
View File

@ -675,19 +675,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/delta/kossel_mini/Configuration_adv.h
View File

@ -675,19 +675,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/delta/kossel_pro/Configuration_adv.h
View File

@ -680,19 +680,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/delta/kossel_xl/Configuration_adv.h
View File

@ -675,19 +675,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/gCreate/gMax1.5+/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/makibox/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/tvrrug/Round2/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

68
Marlin/src/config/examples/wt150/Configuration_adv.h
View File

@ -673,19 +673,71 @@
// @section leveling
#if ENABLED(DELTA) && !defined(DELTA_PROBEABLE_RADIUS)
#define DELTA_PROBEABLE_RADIUS DELTA_PRINTABLE_RADIUS
#elif IS_SCARA && !defined(SCARA_PRINTABLE_RADIUS)
#define SCARA_PRINTABLE_RADIUS (SCARA_LINKAGE_1 + SCARA_LINKAGE_2)
#endif
// Default mesh area is an area with an inset margin on the print area.
// Below are the macros that are used to define the borders for the mesh area,
// made available here for specialized needs, ie dual extruder setup.
#if ENABLED(MESH_BED_LEVELING)
#define MESH_MIN_X MESH_INSET
#define MESH_MAX_X (X_BED_SIZE - (MESH_INSET))
#define MESH_MIN_Y MESH_INSET
#define MESH_MAX_Y (Y_BED_SIZE - (MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (MESH_INSET))
#elif IS_SCARA
#define MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + MESH_INSET)
#define MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#define MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define MESH_MIN_X (max(MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define MESH_MIN_Y (max(MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define MESH_MAX_X (min(X_BED_SIZE - (MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define MESH_MAX_Y (min(Y_BED_SIZE - (MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define MESH_MIN_X (max(X_MIN_POS + MESH_INSET, 0))
#define MESH_MIN_Y (max(Y_MIN_POS + MESH_INSET, 0))
#define MESH_MAX_X (min(X_MAX_POS - (MESH_INSET), X_BED_SIZE))
#define MESH_MAX_Y (min(Y_MAX_POS - (MESH_INSET), Y_BED_SIZE))
#endif
#endif
#elif ENABLED(AUTO_BED_LEVELING_UBL)
#define UBL_MESH_MIN_X UBL_MESH_INSET
#define UBL_MESH_MAX_X (X_BED_SIZE - (UBL_MESH_INSET))
#define UBL_MESH_MIN_Y UBL_MESH_INSET
#define UBL_MESH_MAX_Y (Y_BED_SIZE - (UBL_MESH_INSET))
#if ENABLED(DELTA)
// Probing points may be verified at compile time within the radius
// using static_assert(HYPOT2(X2-X1,Y2-Y1)<=sq(DELTA_PRINTABLE_RADIUS),"bad probe point!")
// so that may be added to SanityCheck.h in the future.
#define UBL_MESH_MIN_X (X_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (DELTA_PROBEABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + DELTA_PROBEABLE_RADIUS - (UBL_MESH_INSET))
#elif IS_SCARA
#define UBL_MESH_MIN_X (X_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MIN_Y (Y_CENTER - (SCARA_PRINTABLE_RADIUS) + UBL_MESH_INSET)
#define UBL_MESH_MAX_X (X_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#define UBL_MESH_MAX_Y (Y_CENTER + SCARA_PRINTABLE_RADIUS - (UBL_MESH_INSET))
#else
// Boundaries for Cartesian probing based on set limits
#if ENABLED(BED_CENTER_AT_0_0)
#define UBL_MESH_MIN_X (max(UBL_MESH_INSET, 0) - (X_BED_SIZE) / 2)
#define UBL_MESH_MIN_Y (max(UBL_MESH_INSET, 0) - (Y_BED_SIZE) / 2)
#define UBL_MESH_MAX_X (min(X_BED_SIZE - (UBL_MESH_INSET), X_BED_SIZE) - (X_BED_SIZE) / 2)
#define UBL_MESH_MAX_Y (min(Y_BED_SIZE - (UBL_MESH_INSET), Y_BED_SIZE) - (Y_BED_SIZE) / 2)
#else
#define UBL_MESH_MIN_X (max(X_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MIN_Y (max(Y_MIN_POS + UBL_MESH_INSET, 0))
#define UBL_MESH_MAX_X (min(X_MAX_POS - (UBL_MESH_INSET), X_BED_SIZE))
#define UBL_MESH_MAX_Y (min(Y_MAX_POS - (UBL_MESH_INSET), Y_BED_SIZE))
#endif
#endif
// If this is defined, the currently active mesh will be saved in the
// current slot on M500.

Write Preview
Loading…
Cancel
Save