Skip to content

Commit e0f73f5

Browse files
thinkyheadthinkyhead
authored
🧑‍💻 Macros *_AXIS_ANY/ALL/NONE (#28275)
1 parent a73b08e commit e0f73f5

6 files changed

Lines changed: 73 additions & 60 deletions

File tree

‎Marlin/src/core/types.h‎

Lines changed: 47 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,11 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
5252
#define MAIN_AXIS_NAMES_LC NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w)
5353
#define NUM_AXIS_CALL(G) do { NUM_AXIS_CODE(G(X_AXIS), G(Y_AXIS), G(Z_AXIS), G(I_AXIS), G(J_AXIS), G(K_AXIS), G(U_AXIS), G(V_AXIS), G(W_AXIS)); } while(0)
5454
#define STR_AXES_MAIN NUM_AXIS_GANG("X", "Y", "Z", STR_I, STR_J, STR_K, STR_U, STR_V, STR_W)
55+
#define NUM_AXIS_ANY(x, y, z, i, j, k, u, v, w) (false \
56+
NUM_AXIS_GANG(|| (x), || (y), || (z), || (i), || (j), || (k), || (u), || (v), || (w)))
57+
#define NUM_AXIS_ALL(x, y, z, i, j, k, u, v, w) ((NUM_AXES > 0) \
58+
NUM_AXIS_GANG(&& (x), && (y), && (z), && (i), && (j), && (k), && (u), && (v), && (w)))
59+
#define NUM_AXIS_NONE(V...) !NUM_AXIS_ANY(V)
5560

5661
#define LOGICAL_AXIS_GANG(N,V...) NUM_AXIS_GANG(V) GANG_ITEM_E(N)
5762
#define LOGICAL_AXIS_CODE(N,V...) NUM_AXIS_CODE(V) CODE_ITEM_E(N)
@@ -71,6 +76,11 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
7176
#define LOGICAL_AXIS_MAP_LC(F) MAP(F, LOGICAL_AXIS_NAMES_LC)
7277
#define LOGICAL_AXIS_CALL(G) do { LOGICAL_AXIS_CODE(G(E_AXIS), G(X_AXIS), G(Y_AXIS), G(Z_AXIS), G(I_AXIS), G(J_AXIS), G(K_AXIS), G(U_AXIS), G(V_AXIS), G(W_AXIS)); } while(0)
7378
#define STR_AXES_LOGICAL LOGICAL_AXIS_GANG("E", "X", "Y", "Z", STR_I, STR_J, STR_K, STR_U, STR_V, STR_W)
79+
#define LOGICAL_AXIS_ANY(e, x, y, z, i, j, k, u, v, w) (false \
80+
LOGICAL_AXIS_GANG(|| (e), || (x), || (y), || (z), || (i), || (j), || (k), || (u), || (v), || (w)))
81+
#define LOGICAL_AXIS_ALL(e, x, y, z, i, j, k, u, v, w) ((LOGICAL_AXES > 0) \
82+
LOGICAL_AXIS_GANG(&& (e), && (x), && (y), && (z), && (i), && (j), && (k), && (u), && (v), && (w)))
83+
#define LOGICAL_AXIS_NONE(V...) !LOGICAL_AXIS_ANY(V)
7484

7585
#define NUM_AXIS_PAIRED_LIST(V...) LIST_N(DOUBLE(NUM_AXES), V)
7686
#define LOGICAL_AXIS_PAIRED_LIST(EA,EB,V...) NUM_AXIS_PAIRED_LIST(V) LIST_ITEM_E(EA) LIST_ITEM_E(EB)
@@ -145,10 +155,14 @@ template <class L, class R> struct IF<true, L, R> { typedef L type; };
145155
#define XY_ARRAY(V...) ARRAY_N(XY_COUNT, V)
146156
#define XY_CODE(V...) CODE_N(XY_COUNT, V)
147157
#define XY_GANG(V...) GANG_N(XY_COUNT, V)
158+
#define XY_ANY(x,y) (false XY_GANG(|| (x), || (y)))
159+
#define XY_ALL(x,y) ((NUM_AXES > 0) XY_GANG(&& (x), && (y)))
148160
#define XYZ_LIST(V...) LIST_N(XYZ_COUNT, V)
149161
#define XYZ_ARRAY(V...) ARRAY_N(XYZ_COUNT, V)
150162
#define XYZ_CODE(V...) CODE_N(XYZ_COUNT, V)
151163
#define XYZ_GANG(V...) GANG_N(XYZ_COUNT, V)
164+
#define XYZ_ANY(x,y,z) (false XYZ_GANG(|| (x), || (y), || (z)))
165+
#define XYZ_ALL(x,y,z) ((NUM_AXES > 0) XYZ_GANG(&& (x), && (y), && (z)))
152166

153167
#if HAS_ROTATIONAL_AXES
154168
#define ROTATIONAL_AXIS_GANG(V...) GANG_N(ROTATIONAL_AXES, V)
@@ -646,8 +660,8 @@ struct XYval {
646660

647661
// Exact comparisons. For floats a "NEAR" operation may be better.
648662
FI bool operator==(const XYval<T> &rs) const { return x == rs.x && y == rs.y; }
649-
FI bool operator==(const XYZval<T> &rs) const { return ENABLED(HAS_X_AXIS) XY_GANG(&& x == rs.x, && y == rs.y); }
650-
FI bool operator==(const XYZEval<T> &rs) const { return ENABLED(HAS_X_AXIS) XY_GANG(&& x == rs.x, && y == rs.y); }
663+
FI bool operator==(const XYZval<T> &rs) const { return XY_ALL(x == rs.x, y == rs.y); }
664+
FI bool operator==(const XYZEval<T> &rs) const { return XY_ALL(x == rs.x, y == rs.y); }
651665
FI bool operator!=(const XYval<T> &rs) const { return !operator==(rs); }
652666
FI bool operator!=(const XYZval<T> &rs) const { return !operator==(rs); }
653667
FI bool operator!=(const XYZEval<T> &rs) const { return !operator==(rs); }
@@ -661,15 +675,15 @@ struct XYval {
661675
FI bool operator> (const XYval<T> &rs) const { return x > rs.x && y > rs.y; }
662676
FI bool operator>=(const XYval<T> &rs) const { return x >= rs.x && y >= rs.y; }
663677

664-
FI bool operator< (const XYZval<T> &rs) const { return true XY_GANG(&& x < rs.x, && y < rs.y); }
665-
FI bool operator<=(const XYZval<T> &rs) const { return true XY_GANG(&& x <= rs.x, && y <= rs.y); }
666-
FI bool operator> (const XYZval<T> &rs) const { return true XY_GANG(&& x > rs.x, && y > rs.y); }
667-
FI bool operator>=(const XYZval<T> &rs) const { return true XY_GANG(&& x >= rs.x, && y >= rs.y); }
678+
FI bool operator< (const XYZval<T> &rs) const { return XY_ALL(x < rs.x, y < rs.y); }
679+
FI bool operator<=(const XYZval<T> &rs) const { return XY_ALL(x <= rs.x, y <= rs.y); }
680+
FI bool operator> (const XYZval<T> &rs) const { return XY_ALL(x > rs.x, y > rs.y); }
681+
FI bool operator>=(const XYZval<T> &rs) const { return XY_ALL(x >= rs.x, y >= rs.y); }
668682

669-
FI bool operator< (const XYZEval<T> &rs) const { return true XY_GANG(&& x < rs.x, && y < rs.y); }
670-
FI bool operator<=(const XYZEval<T> &rs) const { return true XY_GANG(&& x <= rs.x, && y <= rs.y); }
671-
FI bool operator> (const XYZEval<T> &rs) const { return true XY_GANG(&& x > rs.x, && y > rs.y); }
672-
FI bool operator>=(const XYZEval<T> &rs) const { return true XY_GANG(&& x >= rs.x, && y >= rs.y); }
683+
FI bool operator< (const XYZEval<T> &rs) const { return XY_ALL(x < rs.x, y < rs.y); }
684+
FI bool operator<=(const XYZEval<T> &rs) const { return XY_ALL(x <= rs.x, y <= rs.y); }
685+
FI bool operator> (const XYZEval<T> &rs) const { return XY_ALL(x > rs.x, y > rs.y); }
686+
FI bool operator>=(const XYZEval<T> &rs) const { return XY_ALL(x >= rs.x, y >= rs.y); }
673687

674688
};
675689

@@ -738,7 +752,7 @@ struct XYZval {
738752
// Pointer to the data as a simple array
739753
explicit FI operator T* () { return pos; }
740754
// If any element is true then it's true
741-
FI constexpr operator bool() const { return 0 NUM_AXIS_GANG(|| x, || y, || z, || i, || j, || k, || u, || v, || w); }
755+
FI constexpr operator bool() const { return NUM_AXIS_ANY(x, y, z, i, j, k, u, v, w); }
742756
// Smallest element
743757
FI constexpr T small() const { return TERN0(HAS_X_AXIS, _MIN(NUM_AXIS_LIST(x, y, z, i, j, k, u, v, w))); }
744758
// Largest element
@@ -824,22 +838,22 @@ struct XYZval {
824838
FI XYZval<T>& operator<<=(const int &p) { NUM_AXIS_CODE(_LSE(x), _LSE(y), _LSE(z), _LSE(i), _LSE(j), _LSE(k), _LSE(u), _LSE(v), _LSE(w)); return *this; }
825839

826840
// Exact comparisons. For floats a "NEAR" operation may be better.
827-
FI bool operator==(const XYZEval<T> &rs) const { return ENABLED(HAS_X_AXIS) NUM_AXIS_GANG(&& x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k, && u == rs.u, && v == rs.v, && w == rs.w); }
841+
FI bool operator==(const XYZEval<T> &rs) const { return NUM_AXIS_ALL(x == rs.x, y == rs.y, z == rs.z, i == rs.i, j == rs.j, k == rs.k, u == rs.u, v == rs.v, w == rs.w); }
828842
FI bool operator!=(const XYZEval<T> &rs) const { return !operator==(rs); }
829843

830844
// Exact comparison to a single value
831-
FI bool operator==(const T &p) const { return ENABLED(HAS_X_AXIS) NUM_AXIS_GANG(&& x == p, && y == p, && z == p, && i == p, && j == p, && k == p, && u == p, && v == p, && w == p); }
845+
FI bool operator==(const T &p) const { return NUM_AXIS_ALL(x == p, y == p, z == p, i == p, j == p, k == p, u == p, v == p, w == p); }
832846
FI bool operator!=(const T &p) const { return !operator==(p); }
833847

834-
FI bool operator< (const XYZval<T> &rs) const { return true NUM_AXIS_GANG(&& x < rs.x, && y < rs.y, && z < rs.z, && i < rs.i, && j < rs.j, && k < rs.k, && u < rs.u, && v < rs.v, && w < rs.w); }
835-
FI bool operator<=(const XYZval<T> &rs) const { return true NUM_AXIS_GANG(&& x <= rs.x, && y <= rs.y, && z <= rs.z, && i <= rs.i, && j <= rs.j, && k <= rs.k, && u <= rs.u, && v <= rs.v, && w <= rs.w); }
836-
FI bool operator> (const XYZval<T> &rs) const { return true NUM_AXIS_GANG(&& x > rs.x, && y > rs.y, && z > rs.z, && i > rs.i, && j > rs.j, && k > rs.k, && u > rs.u, && v > rs.v, && w > rs.w); }
837-
FI bool operator>=(const XYZval<T> &rs) const { return true NUM_AXIS_GANG(&& x >= rs.x, && y >= rs.y, && z >= rs.z, && i >= rs.i, && j >= rs.j, && k >= rs.k, && u >= rs.u, && v >= rs.v, && w >= rs.w); }
848+
FI bool operator< (const XYZval<T> &rs) const { return NUM_AXIS_ALL(x < rs.x, y < rs.y, z < rs.z, i < rs.i, j < rs.j, k < rs.k, u < rs.u, v < rs.v, w < rs.w); }
849+
FI bool operator<=(const XYZval<T> &rs) const { return NUM_AXIS_ALL(x <= rs.x, y <= rs.y, z <= rs.z, i <= rs.i, j <= rs.j, k <= rs.k, u <= rs.u, v <= rs.v, w <= rs.w); }
850+
FI bool operator> (const XYZval<T> &rs) const { return NUM_AXIS_ALL(x > rs.x, y > rs.y, z > rs.z, i > rs.i, j > rs.j, k > rs.k, u > rs.u, v > rs.v, w > rs.w); }
851+
FI bool operator>=(const XYZval<T> &rs) const { return NUM_AXIS_ALL(x >= rs.x, y >= rs.y, z >= rs.z, i >= rs.i, j >= rs.j, k >= rs.k, u >= rs.u, v >= rs.v, w >= rs.w); }
838852

839-
FI bool operator< (const XYZEval<T> &rs) const { return true NUM_AXIS_GANG(&& x < rs.x, && y < rs.y, && z < rs.z, && i < rs.i, && j < rs.j, && k < rs.k, && u < rs.u, && v < rs.v, && w < rs.w); }
840-
FI bool operator<=(const XYZEval<T> &rs) const { return true NUM_AXIS_GANG(&& x <= rs.x, && y <= rs.y, && z <= rs.z, && i <= rs.i, && j <= rs.j, && k <= rs.k, && u <= rs.u, && v <= rs.v, && w <= rs.w); }
841-
FI bool operator> (const XYZEval<T> &rs) const { return true NUM_AXIS_GANG(&& x > rs.x, && y > rs.y, && z > rs.z, && i > rs.i, && j > rs.j, && k > rs.k, && u > rs.u, && v > rs.v, && w > rs.w); }
842-
FI bool operator>=(const XYZEval<T> &rs) const { return true NUM_AXIS_GANG(&& x >= rs.x, && y >= rs.y, && z >= rs.z, && i >= rs.i, && j >= rs.j, && k >= rs.k, && u >= rs.u, && v >= rs.v, && w >= rs.w); }
853+
FI bool operator< (const XYZEval<T> &rs) const { return NUM_AXIS_ALL(x < rs.x, y < rs.y, z < rs.z, i < rs.i, j < rs.j, k < rs.k, u < rs.u, v < rs.v, w < rs.w); }
854+
FI bool operator<=(const XYZEval<T> &rs) const { return NUM_AXIS_ALL(x <= rs.x, y <= rs.y, z <= rs.z, i <= rs.i, j <= rs.j, k <= rs.k, u <= rs.u, v <= rs.v, w <= rs.w); }
855+
FI bool operator> (const XYZEval<T> &rs) const { return NUM_AXIS_ALL(x > rs.x, y > rs.y, z > rs.z, i > rs.i, j > rs.j, k > rs.k, u > rs.u, v > rs.v, w > rs.w); }
856+
FI bool operator>=(const XYZEval<T> &rs) const { return NUM_AXIS_ALL(x >= rs.x, y >= rs.y, z >= rs.z, i >= rs.i, j >= rs.j, k >= rs.k, u >= rs.u, v >= rs.v, w >= rs.w); }
843857

844858
};
845859

@@ -909,7 +923,7 @@ struct XYZEval {
909923
// Pointer to the data as a simple array
910924
explicit FI operator T* () { return pos; }
911925
// If any element is true then it's true
912-
FI constexpr operator bool() const { return 0 LOGICAL_AXIS_GANG(|| e, || x, || y, || z, || i, || j, || k, || u, || v, || w); }
926+
FI constexpr operator bool() const { return LOGICAL_AXIS_ANY(e, x, y, z, i, j, k, u, v, w); }
913927
// Smallest element
914928
FI constexpr T small() const { return _MIN(LOGICAL_AXIS_LIST(e, x, y, z, i, j, k, u, v, w)); }
915929
// Largest element
@@ -998,24 +1012,24 @@ struct XYZEval {
9981012
FI XYZEval<T>& operator<<=(const int &p) { LOGICAL_AXIS_CODE(_LSE(e), _LSE(x), _LSE(y), _LSE(z), _LSE(i), _LSE(j), _LSE(k), _LSE(u), _LSE(v), _LSE(w)); return *this; }
9991013

10001014
// Exact comparisons. For floats a "NEAR" operation may be better.
1001-
FI bool operator==(const XYZval<T> &rs) const { return ENABLED(HAS_X_AXIS) NUM_AXIS_GANG(&& x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k, && u == rs.u, && v == rs.v, && w == rs.w); }
1002-
FI bool operator==(const XYZEval<T> &rs) const { return ANY(HAS_X_AXIS, HAS_EXTRUDERS) LOGICAL_AXIS_GANG(&& e == rs.e, && x == rs.x, && y == rs.y, && z == rs.z, && i == rs.i, && j == rs.j, && k == rs.k, && u == rs.u, && v == rs.v, && w == rs.w); }
1015+
FI bool operator==(const XYZval<T> &rs) const { return NUM_AXIS_ALL(x == rs.x, y == rs.y, z == rs.z, i == rs.i, j == rs.j, k == rs.k, u == rs.u, v == rs.v, w == rs.w); }
1016+
FI bool operator==(const XYZEval<T> &rs) const { return LOGICAL_AXIS_ALL(e == rs.e, x == rs.x, y == rs.y, z == rs.z, i == rs.i, j == rs.j, k == rs.k, u == rs.u, v == rs.v, w == rs.w); }
10031017
FI bool operator!=(const XYZval<T> &rs) const { return !operator==(rs); }
10041018
FI bool operator!=(const XYZEval<T> &rs) const { return !operator==(rs); }
10051019

10061020
// Exact comparison to a single value
1007-
FI bool operator==(const T &p) const { return ENABLED(HAS_X_AXIS) LOGICAL_AXIS_GANG(&& e == p, && x == p, && y == p, && z == p, && i == p, && j == p, && k == p, && u == p, && v == p, && w == p); }
1021+
FI bool operator==(const T &p) const { return LOGICAL_AXIS_ALL(e == p, x == p, y == p, z == p, i == p, j == p, k == p, u == p, v == p, w == p); }
10081022
FI bool operator!=(const T &p) const { return !operator==(p); }
10091023

1010-
FI bool operator< (const XYZEval<T> &rs) const { return true LOGICAL_AXIS_GANG(&& e < rs.e, && x < rs.x, && y < rs.y, && z < rs.z, && i < rs.i, && j < rs.j, && k < rs.k, && u < rs.u, && v < rs.v, && w < rs.w); }
1011-
FI bool operator<=(const XYZEval<T> &rs) const { return true LOGICAL_AXIS_GANG(&& e <= rs.e, && x <= rs.x, && y <= rs.y, && z <= rs.z, && i <= rs.i, && j <= rs.j, && k <= rs.k, && u <= rs.u, && v <= rs.v, && w <= rs.w); }
1012-
FI bool operator> (const XYZEval<T> &rs) const { return true LOGICAL_AXIS_GANG(&& e > rs.e, && x > rs.x, && y > rs.y, && z > rs.z, && i > rs.i, && j > rs.j, && k > rs.k, && u > rs.u, && v > rs.v, && w > rs.w); }
1013-
FI bool operator>=(const XYZEval<T> &rs) const { return true LOGICAL_AXIS_GANG(&& e >= rs.e, && x >= rs.x, && y >= rs.y, && z >= rs.z, && i >= rs.i, && j >= rs.j, && k >= rs.k, && u >= rs.u, && v >= rs.v, && w >= rs.w); }
1024+
FI bool operator< (const XYZEval<T> &rs) const { return LOGICAL_AXIS_ALL(e < rs.e, x < rs.x, y < rs.y, z < rs.z, i < rs.i, j < rs.j, k < rs.k, u < rs.u, v < rs.v, w < rs.w); }
1025+
FI bool operator<=(const XYZEval<T> &rs) const { return LOGICAL_AXIS_ALL(e <= rs.e, x <= rs.x, y <= rs.y, z <= rs.z, i <= rs.i, j <= rs.j, k <= rs.k, u <= rs.u, v <= rs.v, w <= rs.w); }
1026+
FI bool operator> (const XYZEval<T> &rs) const { return LOGICAL_AXIS_ALL(e > rs.e, x > rs.x, y > rs.y, z > rs.z, i > rs.i, j > rs.j, k > rs.k, u > rs.u, v > rs.v, w > rs.w); }
1027+
FI bool operator>=(const XYZEval<T> &rs) const { return LOGICAL_AXIS_ALL(e >= rs.e, x >= rs.x, y >= rs.y, z >= rs.z, i >= rs.i, j >= rs.j, k >= rs.k, u >= rs.u, v >= rs.v, w >= rs.w); }
10141028

1015-
FI bool operator< (const XYZval<T> &rs) const { return true NUM_AXIS_GANG(&& x < rs.x, && y < rs.y, && z < rs.z, && i < rs.i, && j < rs.j, && k < rs.k, && u < rs.u, && v < rs.v, && w < rs.w); }
1016-
FI bool operator<=(const XYZval<T> &rs) const { return true NUM_AXIS_GANG(&& x <= rs.x, && y <= rs.y, && z <= rs.z, && i <= rs.i, && j <= rs.j, && k <= rs.k, && u <= rs.u, && v <= rs.v, && w <= rs.w); }
1017-
FI bool operator> (const XYZval<T> &rs) const { return true NUM_AXIS_GANG(&& x > rs.x, && y > rs.y, && z > rs.z, && i > rs.i, && j > rs.j, && k > rs.k, && u > rs.u, && v > rs.v, && w > rs.w); }
1018-
FI bool operator>=(const XYZval<T> &rs) const { return true NUM_AXIS_GANG(&& x >= rs.x, && y >= rs.y, && z >= rs.z, && i >= rs.i, && j >= rs.j, && k >= rs.k, && u >= rs.u, && v >= rs.v, && w >= rs.w); }
1029+
FI bool operator< (const XYZval<T> &rs) const { return NUM_AXIS_ALL(x < rs.x, y < rs.y, z < rs.z, i < rs.i, j < rs.j, k < rs.k, u < rs.u, v < rs.v, w < rs.w); }
1030+
FI bool operator<=(const XYZval<T> &rs) const { return NUM_AXIS_ALL(x <= rs.x, y <= rs.y, z <= rs.z, i <= rs.i, j <= rs.j, k <= rs.k, u <= rs.u, v <= rs.v, w <= rs.w); }
1031+
FI bool operator> (const XYZval<T> &rs) const { return NUM_AXIS_ALL(x > rs.x, y > rs.y, z > rs.z, i > rs.i, j > rs.j, k > rs.k, u > rs.u, v > rs.v, w > rs.w); }
1032+
FI bool operator>=(const XYZval<T> &rs) const { return NUM_AXIS_ALL(x >= rs.x, y >= rs.y, z >= rs.z, i >= rs.i, j >= rs.j, k >= rs.k, u >= rs.u, v >= rs.v, w >= rs.w); }
10191033

10201034
};
10211035

‎Marlin/src/gcode/calibrate/G28.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -377,7 +377,7 @@ void GcodeSuite::G28() {
377377
float z_homing_height = seenR ? parser.value_linear_units() : Z_CLEARANCE_FOR_HOMING;
378378

379379
// Check for any lateral motion that might require clearance
380-
const bool may_skate = seenR NUM_AXIS_GANG(|| doX, || doY, || TERN0(Z_SAFE_HOMING, doZ), || doI, || doJ, || doK, || doU, || doV, || doW);
380+
const bool may_skate = seenR && NUM_AXIS_ANY(doX, doY, TERN0(Z_SAFE_HOMING, doZ), doI, doJ, doK, doU, doV, doW);
381381

382382
if (seenR && z_homing_height == 0) {
383383
if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("R0 = No Z raise");

‎Marlin/src/module/motion.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1438,7 +1438,7 @@ FORCE_INLINE void segment_idle(millis_t &next_idle_ms) {
14381438
float get_move_distance(const xyze_pos_t &diff OPTARG(HAS_ROTATIONAL_AXES, bool &is_cartesian_move)) {
14391439
#if NUM_AXES
14401440

1441-
if (!(NUM_AXIS_GANG(diff.x, || diff.y, /* skip z */, || diff.i, || diff.j, || diff.k, || diff.u, || diff.v, || diff.w)))
1441+
if (NUM_AXIS_NONE(diff.x, diff.y, 0, diff.i, diff.j, diff.k, diff.u, diff.v, diff.w))
14421442
return TERN0(HAS_Z_AXIS, ABS(diff.z));
14431443

14441444
#if ENABLED(ARTICULATED_ROBOT_ARM)

‎Marlin/src/module/planner.cpp‎

Lines changed: 4 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1372,7 +1372,7 @@ void Planner::check_axes_activity() {
13721372
float high = 0.0f;
13731373
for (uint8_t b = block_buffer_tail; b != block_buffer_head; b = next_block_index(b)) {
13741374
const block_t * const block = &block_buffer[b];
1375-
if (NUM_AXIS_GANG(block->steps.x, || block->steps.y, || block->steps.z, || block->steps.i, || block->steps.j, || block->steps.k, || block->steps.u, || block->steps.v, || block->steps.w)) {
1375+
if (XYZ_HAS_STEPS(block)) {
13761376
const float se = float(block->steps.e) / block->step_event_count * block->nominal_speed; // mm/sec
13771377
NOLESS(high, se);
13781378
}
@@ -2023,12 +2023,7 @@ bool Planner::_populate_block(
20232023
bool cartesian_move = hints.cartesian_move;
20242024
#endif
20252025

2026-
if (true NUM_AXIS_GANG(
2027-
&& block->steps.a < MIN_STEPS_PER_SEGMENT, && block->steps.b < MIN_STEPS_PER_SEGMENT, && block->steps.c < MIN_STEPS_PER_SEGMENT,
2028-
&& block->steps.i < MIN_STEPS_PER_SEGMENT, && block->steps.j < MIN_STEPS_PER_SEGMENT, && block->steps.k < MIN_STEPS_PER_SEGMENT,
2029-
&& block->steps.u < MIN_STEPS_PER_SEGMENT, && block->steps.v < MIN_STEPS_PER_SEGMENT, && block->steps.w < MIN_STEPS_PER_SEGMENT
2030-
)
2031-
) {
2026+
if (!XYZ_HAS_ENOUGH_STEPS(block)) {
20322027
block->millimeters = TERN0(HAS_EXTRUDERS, ABS(dist_mm.e));
20332028
}
20342029
else {
@@ -2098,11 +2093,7 @@ bool Planner::_populate_block(
20982093
E_TERN_(block->extruder = extruder);
20992094

21002095
#if ENABLED(AUTO_POWER_CONTROL)
2101-
if (NUM_AXIS_GANG(
2102-
block->steps.x, || block->steps.y, || block->steps.z,
2103-
|| block->steps.i, || block->steps.j, || block->steps.k,
2104-
|| block->steps.u, || block->steps.v, || block->steps.w
2105-
)) powerManager.power_on();
2096+
if (XYZ_HAS_STEPS(block)) powerManager.power_on();
21062097
#endif
21072098

21082099
// Enable active axes
@@ -2352,7 +2343,7 @@ bool Planner::_populate_block(
23522343
#if ANY(LIN_ADVANCE, FTM_HAS_LIN_ADVANCE)
23532344
bool use_adv_lead = false;
23542345
#endif
2355-
if (!ANY_AXIS_MOVES(block)) { // Is this a retract / recover move?
2346+
if (!XYZ_HAS_STEPS(block)) { // Is this a retract / recover move?
23562347
accel = CEIL(settings.retract_acceleration * steps_per_mm); // Convert to: acceleration steps/sec^2
23572348
}
23582349
else {

‎Marlin/src/module/planner.h‎

Lines changed: 13 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1188,10 +1188,18 @@ class Planner {
11881188
#define PLANNER_XY_FEEDRATE_MM_S 60.0f
11891189
#endif
11901190

1191-
#define ANY_AXIS_MOVES(BLOCK) \
1192-
(false NUM_AXIS_GANG( \
1193-
|| BLOCK->steps.a, || BLOCK->steps.b, || BLOCK->steps.c, \
1194-
|| BLOCK->steps.i, || BLOCK->steps.j, || BLOCK->steps.k, \
1195-
|| BLOCK->steps.u, || BLOCK->steps.v, || BLOCK->steps.w))
1191+
#define XYZ_HAS_STEPS(B) NUM_AXIS_ANY( \
1192+
B->steps.a, B->steps.b, B->steps.c, \
1193+
B->steps.i, B->steps.j, B->steps.k, \
1194+
B->steps.u, B->steps.v, B->steps.w)
1195+
1196+
#if MIN_STEPS_PER_SEGMENT <= 1
1197+
#define XYZ_HAS_ENOUGH_STEPS XYZ_HAS_STEPS
1198+
#else
1199+
#define XYZ_HAS_ENOUGH_STEPS(B) NUM_AXIS_ANY( \
1200+
B->steps.a >= MIN_STEPS_PER_SEGMENT, B->steps.b >= MIN_STEPS_PER_SEGMENT, B->steps.c >= MIN_STEPS_PER_SEGMENT, \
1201+
B->steps.i >= MIN_STEPS_PER_SEGMENT, B->steps.j >= MIN_STEPS_PER_SEGMENT, B->steps.k >= MIN_STEPS_PER_SEGMENT, \
1202+
B->steps.u >= MIN_STEPS_PER_SEGMENT, B->steps.v >= MIN_STEPS_PER_SEGMENT, B->steps.w >= MIN_STEPS_PER_SEGMENT)
1203+
#endif
11961204

11971205
extern Planner planner;

0 commit comments

Comments
 (0)