Allow Zero Endstops (e.g., for CNC) (#21120)
Co-authored-by: Scott Lahteine <thinkyhead@users.noreply.github.com>
This commit is contained in:
parent
19c38f1a8a
commit
e6bf89e82b
|
@ -1118,8 +1118,8 @@ bool unified_bed_leveling::g29_parameter_parsing() {
|
|||
}
|
||||
|
||||
// If X or Y are not valid, use center of the bed values
|
||||
if (!WITHIN(sx, X_MIN_BED, X_MAX_BED)) sx = X_CENTER;
|
||||
if (!WITHIN(sy, Y_MIN_BED, Y_MAX_BED)) sy = Y_CENTER;
|
||||
if (!COORDINATE_OKAY(sx, X_MIN_BED, X_MAX_BED)) sx = X_CENTER;
|
||||
if (!COORDINATE_OKAY(sy, Y_MIN_BED, Y_MAX_BED)) sy = Y_CENTER;
|
||||
|
||||
if (err_flag) return UBL_ERR;
|
||||
|
||||
|
|
|
@ -319,9 +319,13 @@ inline bool look_for_lines_to_connect() {
|
|||
s.x = _GET_MESH_X( i ) + (INTERSECTION_CIRCLE_RADIUS - (CROSSHAIRS_SIZE)); // right edge
|
||||
e.x = _GET_MESH_X(i + 1) - (INTERSECTION_CIRCLE_RADIUS - (CROSSHAIRS_SIZE)); // left edge
|
||||
|
||||
LIMIT(s.x, X_MIN_POS + 1, X_MAX_POS - 1);
|
||||
s.y = e.y = constrain(_GET_MESH_Y(j), Y_MIN_POS + 1, Y_MAX_POS - 1);
|
||||
LIMIT(e.x, X_MIN_POS + 1, X_MAX_POS - 1);
|
||||
#if HAS_ENDSTOPS
|
||||
LIMIT(s.x, X_MIN_POS + 1, X_MAX_POS - 1);
|
||||
s.y = e.y = constrain(_GET_MESH_Y(j), Y_MIN_POS + 1, Y_MAX_POS - 1);
|
||||
LIMIT(e.x, X_MIN_POS + 1, X_MAX_POS - 1);
|
||||
#else
|
||||
s.y = e.y = _GET_MESH_Y(j);
|
||||
#endif
|
||||
|
||||
if (position_is_reachable(s.x, s.y) && position_is_reachable(e.x, e.y))
|
||||
print_line_from_here_to_there(s, e);
|
||||
|
@ -339,9 +343,13 @@ inline bool look_for_lines_to_connect() {
|
|||
s.y = _GET_MESH_Y( j ) + (INTERSECTION_CIRCLE_RADIUS - (CROSSHAIRS_SIZE)); // top edge
|
||||
e.y = _GET_MESH_Y(j + 1) - (INTERSECTION_CIRCLE_RADIUS - (CROSSHAIRS_SIZE)); // bottom edge
|
||||
|
||||
s.x = e.x = constrain(_GET_MESH_X(i), X_MIN_POS + 1, X_MAX_POS - 1);
|
||||
LIMIT(s.y, Y_MIN_POS + 1, Y_MAX_POS - 1);
|
||||
LIMIT(e.y, Y_MIN_POS + 1, Y_MAX_POS - 1);
|
||||
#if HAS_ENDSTOPS
|
||||
s.x = e.x = constrain(_GET_MESH_X(i), X_MIN_POS + 1, X_MAX_POS - 1);
|
||||
LIMIT(s.y, Y_MIN_POS + 1, Y_MAX_POS - 1);
|
||||
LIMIT(e.y, Y_MIN_POS + 1, Y_MAX_POS - 1);
|
||||
#else
|
||||
s.x = e.x = _GET_MESH_X(i);
|
||||
#endif
|
||||
|
||||
if (position_is_reachable(s.x, s.y) && position_is_reachable(e.x, e.y))
|
||||
print_line_from_here_to_there(s, e);
|
||||
|
@ -826,7 +834,7 @@ void GcodeSuite::G26() {
|
|||
#if IS_KINEMATIC
|
||||
// Check to make sure this segment is entirely on the bed, skip if not.
|
||||
if (!position_is_reachable(p) || !position_is_reachable(q)) continue;
|
||||
#else
|
||||
#elif HAS_ENDSTOPS
|
||||
LIMIT(p.x, X_MIN_POS + 1, X_MAX_POS - 1); // Prevent hitting the endstops
|
||||
LIMIT(p.y, Y_MIN_POS + 1, Y_MAX_POS - 1);
|
||||
LIMIT(q.x, X_MIN_POS + 1, X_MAX_POS - 1);
|
||||
|
|
|
@ -202,7 +202,7 @@ void GcodeSuite::M48() {
|
|||
if (verbose_level > 3)
|
||||
SERIAL_ECHOLNPAIR_P(PSTR("Moving inward: X"), next_pos.x, SP_Y_STR, next_pos.y);
|
||||
}
|
||||
#else
|
||||
#elif HAS_ENDSTOPS
|
||||
// For a rectangular bed just keep the probe in bounds
|
||||
LIMIT(next_pos.x, X_MIN_POS, X_MAX_POS);
|
||||
LIMIT(next_pos.y, Y_MIN_POS, Y_MAX_POS);
|
||||
|
|
|
@ -1195,3 +1195,10 @@
|
|||
#define TOUCH_ORIENTATION TOUCH_LANDSCAPE
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if ANY(USE_XMIN_PLUG, USE_YMIN_PLUG, USE_ZMIN_PLUG, USE_XMAX_PLUG, USE_YMAX_PLUG, USE_ZMAX_PLUG)
|
||||
#define HAS_ENDSTOPS 1
|
||||
#define COORDINATE_OKAY(N,L,H) WITHIN(N,L,H)
|
||||
#else
|
||||
#define COORDINATE_OKAY(N,L,H) true
|
||||
#endif
|
||||
|
|
|
@ -2016,39 +2016,41 @@ static_assert(hbm[Z_AXIS] >= 0, "HOMING_BUMP_MM.Z must be greater than or equal
|
|||
&& !(ENABLED(A##_MULTI_ENDSTOPS) && WITHIN(A##2_USE_ENDSTOP, _##P##MAX_, _##P##MIN_)) )
|
||||
#define _AXIS_PLUG_UNUSED_TEST(A) (_PLUG_UNUSED_TEST(A,X) && _PLUG_UNUSED_TEST(A,Y) && _PLUG_UNUSED_TEST(A,Z))
|
||||
|
||||
// At least 3 endstop plugs must be used
|
||||
#if _AXIS_PLUG_UNUSED_TEST(X)
|
||||
#error "You must enable USE_XMIN_PLUG or USE_XMAX_PLUG."
|
||||
#endif
|
||||
#if _AXIS_PLUG_UNUSED_TEST(Y)
|
||||
#error "You must enable USE_YMIN_PLUG or USE_YMAX_PLUG."
|
||||
#endif
|
||||
#if _AXIS_PLUG_UNUSED_TEST(Z)
|
||||
#error "You must enable USE_ZMIN_PLUG or USE_ZMAX_PLUG."
|
||||
#endif
|
||||
|
||||
// Delta and Cartesian use 3 homing endstops
|
||||
#if NONE(IS_SCARA, SPI_ENDSTOPS)
|
||||
#if X_HOME_DIR < 0 && DISABLED(USE_XMIN_PLUG)
|
||||
#error "Enable USE_XMIN_PLUG when homing X to MIN."
|
||||
#elif X_HOME_DIR > 0 && DISABLED(USE_XMAX_PLUG)
|
||||
#error "Enable USE_XMAX_PLUG when homing X to MAX."
|
||||
#elif Y_HOME_DIR < 0 && DISABLED(USE_YMIN_PLUG)
|
||||
#error "Enable USE_YMIN_PLUG when homing Y to MIN."
|
||||
#elif Y_HOME_DIR > 0 && DISABLED(USE_YMAX_PLUG)
|
||||
#error "Enable USE_YMAX_PLUG when homing Y to MAX."
|
||||
// A machine with endstops must have a minimum of 3
|
||||
#if HAS_ENDSTOPS
|
||||
#if _AXIS_PLUG_UNUSED_TEST(X)
|
||||
#error "You must enable USE_XMIN_PLUG or USE_XMAX_PLUG."
|
||||
#endif
|
||||
#if _AXIS_PLUG_UNUSED_TEST(Y)
|
||||
#error "You must enable USE_YMIN_PLUG or USE_YMAX_PLUG."
|
||||
#endif
|
||||
#if _AXIS_PLUG_UNUSED_TEST(Z)
|
||||
#error "You must enable USE_ZMIN_PLUG or USE_ZMAX_PLUG."
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Z homing direction and plug usage flags
|
||||
#if Z_HOME_DIR < 0 && NONE(USE_ZMIN_PLUG, HOMING_Z_WITH_PROBE)
|
||||
#error "Enable USE_ZMIN_PLUG when homing Z to MIN."
|
||||
#elif Z_HOME_DIR > 0 && ENABLED(USE_PROBE_FOR_Z_HOMING)
|
||||
#error "Z_HOME_DIR must be -1 when homing Z with the probe."
|
||||
#elif BOTH(HOMING_Z_WITH_PROBE, Z_MULTI_ENDSTOPS)
|
||||
#error "Z_MULTI_ENDSTOPS is incompatible with USE_PROBE_FOR_Z_HOMING."
|
||||
#elif Z_HOME_DIR > 0 && DISABLED(USE_ZMAX_PLUG)
|
||||
#error "Enable USE_ZMAX_PLUG when homing Z to MAX."
|
||||
// Delta and Cartesian use 3 homing endstops
|
||||
#if NONE(IS_SCARA, SPI_ENDSTOPS)
|
||||
#if X_HOME_DIR < 0 && DISABLED(USE_XMIN_PLUG)
|
||||
#error "Enable USE_XMIN_PLUG when homing X to MIN."
|
||||
#elif X_HOME_DIR > 0 && DISABLED(USE_XMAX_PLUG)
|
||||
#error "Enable USE_XMAX_PLUG when homing X to MAX."
|
||||
#elif Y_HOME_DIR < 0 && DISABLED(USE_YMIN_PLUG)
|
||||
#error "Enable USE_YMIN_PLUG when homing Y to MIN."
|
||||
#elif Y_HOME_DIR > 0 && DISABLED(USE_YMAX_PLUG)
|
||||
#error "Enable USE_YMAX_PLUG when homing Y to MAX."
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// Z homing direction and plug usage flags
|
||||
#if Z_HOME_DIR < 0 && NONE(USE_ZMIN_PLUG, HOMING_Z_WITH_PROBE)
|
||||
#error "Enable USE_ZMIN_PLUG when homing Z to MIN."
|
||||
#elif Z_HOME_DIR > 0 && ENABLED(USE_PROBE_FOR_Z_HOMING)
|
||||
#error "Z_HOME_DIR must be -1 when homing Z with the probe."
|
||||
#elif BOTH(HOMING_Z_WITH_PROBE, Z_MULTI_ENDSTOPS)
|
||||
#error "Z_MULTI_ENDSTOPS is incompatible with USE_PROBE_FOR_Z_HOMING."
|
||||
#elif Z_HOME_DIR > 0 && DISABLED(USE_ZMAX_PLUG)
|
||||
#error "Enable USE_ZMAX_PLUG when homing Z to MAX."
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if BOTH(HOME_Z_FIRST, USE_PROBE_FOR_Z_HOMING)
|
||||
|
|
|
@ -446,10 +446,8 @@ uint8_t L64XX_Marlin::get_user_input(uint8_t &driver_count, L64XX_axis_t axis_in
|
|||
position_max = X_center + displacement;
|
||||
echo_min_max('X', position_min, position_max);
|
||||
if (false
|
||||
#ifdef X_MIN_POS
|
||||
#if HAS_ENDSTOPS
|
||||
|| position_min < (X_MIN_POS)
|
||||
#endif
|
||||
#ifdef X_MAX_POS
|
||||
|| position_max > (X_MAX_POS)
|
||||
#endif
|
||||
) {
|
||||
|
@ -463,10 +461,8 @@ uint8_t L64XX_Marlin::get_user_input(uint8_t &driver_count, L64XX_axis_t axis_in
|
|||
position_max = Y_center + displacement;
|
||||
echo_min_max('Y', position_min, position_max);
|
||||
if (false
|
||||
#ifdef Y_MIN_POS
|
||||
#if HAS_ENDSTOPS
|
||||
|| position_min < (Y_MIN_POS)
|
||||
#endif
|
||||
#ifdef Y_MAX_POS
|
||||
|| position_max > (Y_MAX_POS)
|
||||
#endif
|
||||
) {
|
||||
|
@ -480,10 +476,8 @@ uint8_t L64XX_Marlin::get_user_input(uint8_t &driver_count, L64XX_axis_t axis_in
|
|||
position_max = Z_center + displacement;
|
||||
echo_min_max('Z', position_min, position_max);
|
||||
if (false
|
||||
#ifdef Z_MIN_POS
|
||||
#if HAS_ENDSTOPS
|
||||
|| position_min < (Z_MIN_POS)
|
||||
#endif
|
||||
#ifdef Z_MAX_POS
|
||||
|| position_max > (Z_MAX_POS)
|
||||
#endif
|
||||
) {
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -284,27 +284,51 @@ void do_z_clearance(const float &zclear, const bool z_trusted=true, const bool r
|
|||
* Homing and Trusted Axes
|
||||
*/
|
||||
constexpr uint8_t xyz_bits = _BV(X_AXIS) | _BV(Y_AXIS) | _BV(Z_AXIS);
|
||||
extern uint8_t axis_homed, axis_trusted;
|
||||
|
||||
void homeaxis(const AxisEnum axis);
|
||||
void set_axis_is_at_home(const AxisEnum axis);
|
||||
void set_axis_never_homed(const AxisEnum axis);
|
||||
uint8_t axes_should_home(uint8_t axis_bits=0x07);
|
||||
bool homing_needed_error(uint8_t axis_bits=0x07);
|
||||
|
||||
FORCE_INLINE bool axis_was_homed(const AxisEnum axis) { return TEST(axis_homed, axis); }
|
||||
FORCE_INLINE bool axis_is_trusted(const AxisEnum axis) { return TEST(axis_trusted, axis); }
|
||||
FORCE_INLINE bool axis_should_home(const AxisEnum axis) { return (axes_should_home() & _BV(axis)) != 0; }
|
||||
FORCE_INLINE bool no_axes_homed() { return !axis_homed; }
|
||||
FORCE_INLINE bool all_axes_homed() { return xyz_bits == (axis_homed & xyz_bits); }
|
||||
FORCE_INLINE bool homing_needed() { return !all_axes_homed(); }
|
||||
FORCE_INLINE bool all_axes_trusted() { return xyz_bits == (axis_trusted & xyz_bits); }
|
||||
FORCE_INLINE void set_axis_homed(const AxisEnum axis) { SBI(axis_homed, axis); }
|
||||
FORCE_INLINE void set_axis_unhomed(const AxisEnum axis) { CBI(axis_homed, axis); }
|
||||
FORCE_INLINE void set_axis_trusted(const AxisEnum axis) { SBI(axis_trusted, axis); }
|
||||
FORCE_INLINE void set_axis_untrusted(const AxisEnum axis) { CBI(axis_trusted, axis); }
|
||||
FORCE_INLINE void set_all_homed() { axis_homed = axis_trusted = xyz_bits; }
|
||||
FORCE_INLINE void set_all_unhomed() { axis_homed = axis_trusted = 0; }
|
||||
#if HAS_ENDSTOPS
|
||||
/**
|
||||
* axis_homed
|
||||
* Flags that each linear axis was homed.
|
||||
* XYZ on cartesian, ABC on delta, ABZ on SCARA.
|
||||
*
|
||||
* axis_trusted
|
||||
* Flags that the position is trusted in each linear axis. Set when homed.
|
||||
* Cleared whenever a stepper powers off, potentially losing its position.
|
||||
*/
|
||||
extern uint8_t axis_homed, axis_trusted;
|
||||
void homeaxis(const AxisEnum axis);
|
||||
void set_axis_never_homed(const AxisEnum axis);
|
||||
uint8_t axes_should_home(uint8_t axis_bits=0x07);
|
||||
bool homing_needed_error(uint8_t axis_bits=0x07);
|
||||
FORCE_INLINE void set_axis_unhomed(const AxisEnum axis) { CBI(axis_homed, axis); }
|
||||
FORCE_INLINE void set_axis_untrusted(const AxisEnum axis) { CBI(axis_trusted, axis); }
|
||||
FORCE_INLINE void set_all_unhomed() { axis_homed = axis_trusted = 0; }
|
||||
FORCE_INLINE void set_axis_homed(const AxisEnum axis) { SBI(axis_homed, axis); }
|
||||
FORCE_INLINE void set_axis_trusted(const AxisEnum axis) { SBI(axis_trusted, axis); }
|
||||
FORCE_INLINE void set_all_homed() { axis_homed = axis_trusted = xyz_bits; }
|
||||
#else
|
||||
constexpr uint8_t axis_homed = xyz_bits, axis_trusted = xyz_bits; // Zero-endstop machines are always homed and trusted
|
||||
FORCE_INLINE void homeaxis(const AxisEnum axis) {}
|
||||
FORCE_INLINE void set_axis_never_homed(const AxisEnum) {}
|
||||
FORCE_INLINE uint8_t axes_should_home(uint8_t=0x07) { return false; }
|
||||
FORCE_INLINE bool homing_needed_error(uint8_t=0x07) { return false; }
|
||||
FORCE_INLINE void set_axis_unhomed(const AxisEnum axis) {}
|
||||
FORCE_INLINE void set_axis_untrusted(const AxisEnum axis) {}
|
||||
FORCE_INLINE void set_all_unhomed() {}
|
||||
FORCE_INLINE void set_axis_homed(const AxisEnum axis) {}
|
||||
FORCE_INLINE void set_axis_trusted(const AxisEnum axis) {}
|
||||
FORCE_INLINE void set_all_homed() {}
|
||||
#endif
|
||||
|
||||
FORCE_INLINE bool axis_was_homed(const AxisEnum axis) { return TEST(axis_homed, axis); }
|
||||
FORCE_INLINE bool axis_is_trusted(const AxisEnum axis) { return TEST(axis_trusted, axis); }
|
||||
FORCE_INLINE bool axis_should_home(const AxisEnum axis) { return (axes_should_home() & _BV(axis)) != 0; }
|
||||
FORCE_INLINE bool no_axes_homed() { return !axis_homed; }
|
||||
FORCE_INLINE bool all_axes_homed() { return xyz_bits == (axis_homed & xyz_bits); }
|
||||
FORCE_INLINE bool homing_needed() { return !all_axes_homed(); }
|
||||
FORCE_INLINE bool all_axes_trusted() { return xyz_bits == (axis_trusted & xyz_bits); }
|
||||
|
||||
#if ENABLED(NO_MOTION_BEFORE_HOMING)
|
||||
#define MOTION_CONDITIONS (IsRunning() && !homing_needed_error())
|
||||
|
@ -360,7 +384,6 @@ FORCE_INLINE void set_all_unhomed() { axis_homed = axis_tr
|
|||
/**
|
||||
* position_is_reachable family of functions
|
||||
*/
|
||||
|
||||
#if IS_KINEMATIC // (DELTA or SCARA)
|
||||
|
||||
#if HAS_SCARA_OFFSET
|
||||
|
@ -390,14 +413,14 @@ FORCE_INLINE void set_all_unhomed() { axis_homed = axis_tr
|
|||
|
||||
// Return true if the given position is within the machine bounds.
|
||||
inline bool position_is_reachable(const float &rx, const float &ry) {
|
||||
if (!WITHIN(ry, Y_MIN_POS - fslop, Y_MAX_POS + fslop)) return false;
|
||||
if (!COORDINATE_OKAY(ry, Y_MIN_POS - fslop, Y_MAX_POS + fslop)) return false;
|
||||
#if ENABLED(DUAL_X_CARRIAGE)
|
||||
if (active_extruder)
|
||||
return WITHIN(rx, X2_MIN_POS - fslop, X2_MAX_POS + fslop);
|
||||
return COORDINATE_OKAY(rx, X2_MIN_POS - fslop, X2_MAX_POS + fslop);
|
||||
else
|
||||
return WITHIN(rx, X1_MIN_POS - fslop, X1_MAX_POS + fslop);
|
||||
return COORDINATE_OKAY(rx, X1_MIN_POS - fslop, X1_MAX_POS + fslop);
|
||||
#else
|
||||
return WITHIN(rx, X_MIN_POS - fslop, X_MAX_POS + fslop);
|
||||
return COORDINATE_OKAY(rx, X_MIN_POS - fslop, X_MAX_POS + fslop);
|
||||
#endif
|
||||
}
|
||||
inline bool position_is_reachable(const xy_pos_t &pos) { return position_is_reachable(pos.x, pos.y); }
|
||||
|
|
|
@ -564,10 +564,10 @@ class Planner {
|
|||
#if ENABLED(SKEW_CORRECTION)
|
||||
|
||||
FORCE_INLINE static void skew(float &cx, float &cy, const float &cz) {
|
||||
if (WITHIN(cx, X_MIN_POS + 1, X_MAX_POS) && WITHIN(cy, Y_MIN_POS + 1, Y_MAX_POS)) {
|
||||
if (COORDINATE_OKAY(cx, X_MIN_POS + 1, X_MAX_POS) && COORDINATE_OKAY(cy, Y_MIN_POS + 1, Y_MAX_POS)) {
|
||||
const float sx = cx - cy * skew_factor.xy - cz * (skew_factor.xz - (skew_factor.xy * skew_factor.yz)),
|
||||
sy = cy - cz * skew_factor.yz;
|
||||
if (WITHIN(sx, X_MIN_POS, X_MAX_POS) && WITHIN(sy, Y_MIN_POS, Y_MAX_POS)) {
|
||||
if (COORDINATE_OKAY(sx, X_MIN_POS, X_MAX_POS) && COORDINATE_OKAY(sy, Y_MIN_POS, Y_MAX_POS)) {
|
||||
cx = sx; cy = sy;
|
||||
}
|
||||
}
|
||||
|
@ -575,10 +575,10 @@ class Planner {
|
|||
FORCE_INLINE static void skew(xyz_pos_t &raw) { skew(raw.x, raw.y, raw.z); }
|
||||
|
||||
FORCE_INLINE static void unskew(float &cx, float &cy, const float &cz) {
|
||||
if (WITHIN(cx, X_MIN_POS, X_MAX_POS) && WITHIN(cy, Y_MIN_POS, Y_MAX_POS)) {
|
||||
if (COORDINATE_OKAY(cx, X_MIN_POS, X_MAX_POS) && COORDINATE_OKAY(cy, Y_MIN_POS, Y_MAX_POS)) {
|
||||
const float sx = cx + cy * skew_factor.xy + cz * skew_factor.xz,
|
||||
sy = cy + cz * skew_factor.yz;
|
||||
if (WITHIN(sx, X_MIN_POS, X_MAX_POS) && WITHIN(sy, Y_MIN_POS, Y_MAX_POS)) {
|
||||
if (COORDINATE_OKAY(sx, X_MIN_POS, X_MAX_POS) && COORDINATE_OKAY(sy, Y_MIN_POS, Y_MAX_POS)) {
|
||||
cx = sx; cy = sy;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -92,8 +92,8 @@ public:
|
|||
*/
|
||||
static bool can_reach(const float &rx, const float &ry) {
|
||||
return position_is_reachable(rx - offset_xy.x, ry - offset_xy.y)
|
||||
&& WITHIN(rx, min_x() - fslop, max_x() + fslop)
|
||||
&& WITHIN(ry, min_y() - fslop, max_y() + fslop);
|
||||
&& COORDINATE_OKAY(rx, min_x() - fslop, max_x() + fslop)
|
||||
&& COORDINATE_OKAY(ry, min_y() - fslop, max_y() + fslop);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -206,8 +206,8 @@ public:
|
|||
#if IS_KINEMATIC
|
||||
return HYPOT2(x, y) <= sq(probe_radius(default_probe_xy_offset));
|
||||
#else
|
||||
return WITHIN(x, _min_x(default_probe_xy_offset) - fslop, _max_x(default_probe_xy_offset) + fslop)
|
||||
&& WITHIN(y, _min_y(default_probe_xy_offset) - fslop, _max_y(default_probe_xy_offset) + fslop);
|
||||
return COORDINATE_OKAY(x, _min_x(default_probe_xy_offset) - fslop, _max_x(default_probe_xy_offset) + fslop)
|
||||
&& COORDINATE_OKAY(y, _min_y(default_probe_xy_offset) - fslop, _max_y(default_probe_xy_offset) + fslop);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
@ -10,6 +10,14 @@ restore_configs
|
|||
opt_set MOTHERBOARD BOARD_TEENSY31_32
|
||||
exec_test $1 $2 "Teensy3.1 with default config" "$3"
|
||||
|
||||
#
|
||||
# Zero endstops, as with a CNC
|
||||
#
|
||||
restore_configs
|
||||
opt_set MOTHERBOARD BOARD_TEENSY31_32
|
||||
opt_disable USE_XMIN_PLUG USE_YMIN_PLUG USE_ZMIN_PLUG
|
||||
exec_test $1 $2 "Teensy3.1 with Zero Endstops" "$3"
|
||||
|
||||
#
|
||||
# Test many features together
|
||||
#
|
||||
|
|
Loading…
Reference in a new issue