zaubentrucker/muele-marlin
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Simpler Allen Key config. Fixes, cleanups from refactor (#15256)

Browse source
This commit is contained in:
Scott Lahteine 2019-09-14 03:05:10 -05:00 committed by GitHub
parent ffb418b226
commit 465c6d9230
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
62 changed files with 389 additions and 685 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Marlin/src/HAL/HAL_LPC1768/u8g/LCD_I2C_routines.c
View file

@ -33,7 +33,7 @@
#include <lpc17xx_pinsel.h> #include <lpc17xx_pinsel.h>
#include <lpc17xx_libcfg_default.h> #include <lpc17xx_libcfg_default.h>
#include "../../../core/millis_t.h" typedef uint32_t millis_t;
////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////

1
Marlin/src/core/macros.h
View file

@ -79,6 +79,7 @@
#define SBI32(n,b) (n |= _BV32(b)) #define SBI32(n,b) (n |= _BV32(b))
#define CBI32(n,b) (n &= ~_BV32(b)) #define CBI32(n,b) (n &= ~_BV32(b))
#define cu(x) ((x)*(x)*(x))
#define RADIANS(d) ((d)*float(M_PI)/180.0f) #define RADIANS(d) ((d)*float(M_PI)/180.0f)
#define DEGREES(r) ((r)*180.0f/float(M_PI)) #define DEGREES(r) ((r)*180.0f/float(M_PI))
#define HYPOT2(x,y) (sq(x)+sq(y)) #define HYPOT2(x,y) (sq(x)+sq(y))

2
Marlin/src/core/serial.cpp
View file

@ -68,7 +68,7 @@ void print_bin(const uint16_t val) {
} }
} }
void print_xyz(PGM_P const prefix, PGM_P const suffix, const float x, const float y, const float z) { void print_xyz(PGM_P const prefix, PGM_P const suffix, const float &x, const float &y, const float &z) {
serialprintPGM(prefix); serialprintPGM(prefix);
SERIAL_CHAR('('); SERIAL_CHAR('(');
SERIAL_ECHO(x); SERIAL_ECHO(x);

2
Marlin/src/core/serial.h
View file

@ -186,7 +186,7 @@ void serial_spaces(uint8_t count);
void print_bin(const uint16_t val); void print_bin(const uint16_t val);
void print_xyz(PGM_P const prefix, PGM_P const suffix, const float x, const float y, const float z);
void print_xyz(PGM_P const prefix, PGM_P const suffix, const float xyz[]); void print_xyz(PGM_P const prefix, PGM_P const suffix, const float xyz[]);
void print_xyz(PGM_P const prefix, PGM_P const suffix, const float &x, const float &y, const float &z);
#define SERIAL_POS(SUFFIX,VAR) do { print_xyz(PSTR(" " STRINGIFY(VAR) "="), PSTR(" : " SUFFIX "\n"), VAR); }while(0) #define SERIAL_POS(SUFFIX,VAR) do { print_xyz(PSTR(" " STRINGIFY(VAR) "="), PSTR(" : " SUFFIX "\n"), VAR); }while(0)
#define SERIAL_XYZ(PREFIX,V...) do { print_xyz(PSTR(PREFIX), nullptr, V); }while(0) #define SERIAL_XYZ(PREFIX,V...) do { print_xyz(PSTR(PREFIX), nullptr, V); }while(0)

4
Marlin/src/feature/I2CPositionEncoder.cpp
View file

@ -168,7 +168,7 @@ void I2CPositionEncoder::update() {
if (errPrstIdx >= I2CPE_ERR_PRST_ARRAY_SIZE) { if (errPrstIdx >= I2CPE_ERR_PRST_ARRAY_SIZE) {
float sumP = 0; float sumP = 0;
LOOP_L_N(i, I2CPE_ERR_PRST_ARRAY_SIZE) sumP += errPrst[i]; LOOP_L_N(i, I2CPE_ERR_PRST_ARRAY_SIZE) sumP += errPrst[i];
const int32_t errorP = int32_t(sumP * (1.0f / (I2CPE_ERR_PRST_ARRAY_SIZE))); const int32_t errorP = int32_t(sumP * RECIPROCAL(I2CPE_ERR_PRST_ARRAY_SIZE));
SERIAL_ECHO(axis_codes[encoderAxis]); SERIAL_ECHO(axis_codes[encoderAxis]);
SERIAL_ECHOLNPAIR(" - err detected: ", errorP * planner.steps_to_mm[encoderAxis], "mm; correcting!"); SERIAL_ECHOLNPAIR(" - err detected: ", errorP * planner.steps_to_mm[encoderAxis], "mm; correcting!");
babystep.add_steps(encoderAxis, -LROUND(errorP)); babystep.add_steps(encoderAxis, -LROUND(errorP));
@ -440,7 +440,7 @@ void I2CPositionEncoder::calibrate_steps_mm(const uint8_t iter) {
total += new_steps_mm; total += new_steps_mm;
// swap start and end points so next loop runs from current position // swap start and end points so next loop runs from current position
float tempCoord = startCoord[encoderAxis]; const float tempCoord = startCoord[encoderAxis];
startCoord[encoderAxis] = endCoord[encoderAxis]; startCoord[encoderAxis] = endCoord[encoderAxis];
endCoord[encoderAxis] = tempCoord; endCoord[encoderAxis] = tempCoord;
} }

12
Marlin/src/feature/backlash.h
View file

@ -60,27 +60,27 @@ public:
static void measure_with_probe(); static void measure_with_probe();
#endif #endif
static inline float get_measurement(const uint8_t e) { static inline float get_measurement(const AxisEnum a) {
// Return the measurement averaged over all readings // Return the measurement averaged over all readings
return ( return (
#if ENABLED(MEASURE_BACKLASH_WHEN_PROBING) #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
measured_count[e] > 0 ? measured_mm[e] / measured_count[e] : measured_count[a] > 0 ? measured_mm[a] / measured_count[a] :
#endif #endif
0 0
); );
#if DISABLED(MEASURE_BACKLASH_WHEN_PROBING) #if DISABLED(MEASURE_BACKLASH_WHEN_PROBING)
UNUSED(e); UNUSED(a);
#endif #endif
} }
static inline bool has_measurement(const uint8_t e) { static inline bool has_measurement(const AxisEnum a) {
return (false return (false
#if ENABLED(MEASURE_BACKLASH_WHEN_PROBING) #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
|| (measured_count[e] > 0) || (measured_count[a] > 0)
#endif #endif
); );
#if DISABLED(MEASURE_BACKLASH_WHEN_PROBING) #if DISABLED(MEASURE_BACKLASH_WHEN_PROBING)
UNUSED(e); UNUSED(a);
#endif #endif
} }

6
Marlin/src/feature/bedlevel/abl/abl.cpp
View file

@ -282,11 +282,9 @@ float bilinear_z_offset(const float raw[XYZ]) {
ry = raw[Y_AXIS] - bilinear_start[Y_AXIS]; ry = raw[Y_AXIS] - bilinear_start[Y_AXIS];
#if ENABLED(EXTRAPOLATE_BEYOND_GRID) #if ENABLED(EXTRAPOLATE_BEYOND_GRID)
// Keep using the last grid box #define FAR_EDGE_OR_BOX 2 // Keep using the last grid box
#define FAR_EDGE_OR_BOX 2
#else #else
// Just use the grid far edge #define FAR_EDGE_OR_BOX 1 // Just use the grid far edge
#define FAR_EDGE_OR_BOX 1
#endif #endif
if (last_x != rx) { if (last_x != rx) {

2
Marlin/src/feature/bedlevel/bedlevel.h
View file

@ -56,7 +56,7 @@ class TemporaryBedLevelingState {
TemporaryBedLevelingState(const bool enable); TemporaryBedLevelingState(const bool enable);
~TemporaryBedLevelingState() { set_bed_leveling_enabled(saved); } ~TemporaryBedLevelingState() { set_bed_leveling_enabled(saved); }
}; };
#define TEMPORARY_BED_LEVELING_STATE(enable) TemporaryBedLevelingState tbls(enable) #define TEMPORARY_BED_LEVELING_STATE(enable) const TemporaryBedLevelingState tbls(enable)
#if HAS_MESH #if HAS_MESH

8
Marlin/src/feature/bedlevel/mbl/mesh_bed_leveling.h
View file

@ -73,22 +73,22 @@ public:
} }
static int8_t cell_index_x(const float &x) { static int8_t cell_index_x(const float &x) {
int8_t cx = (x - (MESH_MIN_X)) * (1.0f / (MESH_X_DIST)); int8_t cx = (x - (MESH_MIN_X)) * RECIPROCAL(MESH_X_DIST);
return constrain(cx, 0, (GRID_MAX_POINTS_X) - 2); return constrain(cx, 0, (GRID_MAX_POINTS_X) - 2);
} }
static int8_t cell_index_y(const float &y) { static int8_t cell_index_y(const float &y) {
int8_t cy = (y - (MESH_MIN_Y)) * (1.0f / (MESH_Y_DIST)); int8_t cy = (y - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST);
return constrain(cy, 0, (GRID_MAX_POINTS_Y) - 2); return constrain(cy, 0, (GRID_MAX_POINTS_Y) - 2);
} }
static int8_t probe_index_x(const float &x) { static int8_t probe_index_x(const float &x) {
int8_t px = (x - (MESH_MIN_X) + 0.5f * (MESH_X_DIST)) * (1.0f / (MESH_X_DIST)); int8_t px = (x - (MESH_MIN_X) + 0.5f * (MESH_X_DIST)) * RECIPROCAL(MESH_X_DIST);
return WITHIN(px, 0, GRID_MAX_POINTS_X - 1) ? px : -1; return WITHIN(px, 0, GRID_MAX_POINTS_X - 1) ? px : -1;
} }
static int8_t probe_index_y(const float &y) { static int8_t probe_index_y(const float &y) {
int8_t py = (y - (MESH_MIN_Y) + 0.5f * (MESH_Y_DIST)) * (1.0f / (MESH_Y_DIST)); int8_t py = (y - (MESH_MIN_Y) + 0.5f * (MESH_Y_DIST)) * RECIPROCAL(MESH_Y_DIST);
return WITHIN(py, 0, GRID_MAX_POINTS_Y - 1) ? py : -1; return WITHIN(py, 0, GRID_MAX_POINTS_Y - 1) ? py : -1;
} }

12
Marlin/src/feature/bedlevel/ubl/ubl.h
View file

@ -145,14 +145,14 @@ class unified_bed_leveling {
FORCE_INLINE static void set_z(const int8_t px, const int8_t py, const float &z) { z_values[px][py] = z; } FORCE_INLINE static void set_z(const int8_t px, const int8_t py, const float &z) { z_values[px][py] = z; }
static int8_t get_cell_index_x(const float &x) { static int8_t get_cell_index_x(const float &x) {
const int8_t cx = (x - (MESH_MIN_X)) * (1.0f / (MESH_X_DIST)); const int8_t cx = (x - (MESH_MIN_X)) * RECIPROCAL(MESH_X_DIST);
return constrain(cx, 0, (GRID_MAX_POINTS_X) - 1); // -1 is appropriate if we want all movement to the X_MAX return constrain(cx, 0, (GRID_MAX_POINTS_X) - 1); // -1 is appropriate if we want all movement to the X_MAX
} // position. But with this defined this way, it is possible } // position. But with this defined this way, it is possible
// to extrapolate off of this point even further out. Probably // to extrapolate off of this point even further out. Probably
// that is OK because something else should be keeping that from // that is OK because something else should be keeping that from
// happening and should not be worried about at this level. // happening and should not be worried about at this level.
static int8_t get_cell_index_y(const float &y) { static int8_t get_cell_index_y(const float &y) {
const int8_t cy = (y - (MESH_MIN_Y)) * (1.0f / (MESH_Y_DIST)); const int8_t cy = (y - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST);
return constrain(cy, 0, (GRID_MAX_POINTS_Y) - 1); // -1 is appropriate if we want all movement to the Y_MAX return constrain(cy, 0, (GRID_MAX_POINTS_Y) - 1); // -1 is appropriate if we want all movement to the Y_MAX
} // position. But with this defined this way, it is possible } // position. But with this defined this way, it is possible
// to extrapolate off of this point even further out. Probably // to extrapolate off of this point even further out. Probably
@ -160,12 +160,12 @@ class unified_bed_leveling {
// happening and should not be worried about at this level. // happening and should not be worried about at this level.
static int8_t find_closest_x_index(const float &x) { static int8_t find_closest_x_index(const float &x) {
const int8_t px = (x - (MESH_MIN_X) + (MESH_X_DIST) * 0.5) * (1.0f / (MESH_X_DIST)); const int8_t px = (x - (MESH_MIN_X) + (MESH_X_DIST) * 0.5) * RECIPROCAL(MESH_X_DIST);
return WITHIN(px, 0, GRID_MAX_POINTS_X - 1) ? px : -1; return WITHIN(px, 0, GRID_MAX_POINTS_X - 1) ? px : -1;
} }
static int8_t find_closest_y_index(const float &y) { static int8_t find_closest_y_index(const float &y) {
const int8_t py = (y - (MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * (1.0f / (MESH_Y_DIST)); const int8_t py = (y - (MESH_MIN_Y) + (MESH_Y_DIST) * 0.5) * RECIPROCAL(MESH_Y_DIST);
return WITHIN(py, 0, GRID_MAX_POINTS_Y - 1) ? py : -1; return WITHIN(py, 0, GRID_MAX_POINTS_Y - 1) ? py : -1;
} }
@ -210,7 +210,7 @@ class unified_bed_leveling {
); );
} }
const float xratio = (rx0 - mesh_index_to_xpos(x1_i)) * (1.0f / (MESH_X_DIST)), const float xratio = (rx0 - mesh_index_to_xpos(x1_i)) * RECIPROCAL(MESH_X_DIST),
z1 = z_values[x1_i][yi]; z1 = z_values[x1_i][yi];
return z1 + xratio * (z_values[_MIN(x1_i, GRID_MAX_POINTS_X - 2) + 1][yi] - z1); // Don't allow x1_i+1 to be past the end of the array return z1 + xratio * (z_values[_MIN(x1_i, GRID_MAX_POINTS_X - 2) + 1][yi] - z1); // Don't allow x1_i+1 to be past the end of the array
@ -239,7 +239,7 @@ class unified_bed_leveling {
); );
} }
const float yratio = (ry0 - mesh_index_to_ypos(y1_i)) * (1.0f / (MESH_Y_DIST)), const float yratio = (ry0 - mesh_index_to_ypos(y1_i)) * RECIPROCAL(MESH_Y_DIST),
z1 = z_values[xi][y1_i]; z1 = z_values[xi][y1_i];
return z1 + yratio * (z_values[xi][_MIN(y1_i, GRID_MAX_POINTS_Y - 2) + 1] - z1); // Don't allow y1_i+1 to be past the end of the array return z1 + yratio * (z_values[xi][_MIN(y1_i, GRID_MAX_POINTS_Y - 2) + 1] - z1); // Don't allow y1_i+1 to be past the end of the array

4
Marlin/src/feature/bedlevel/ubl/ubl_G29.cpp
View file

@ -441,7 +441,7 @@
#if HAS_BED_PROBE #if HAS_BED_PROBE
case 1: case 1: {
// //
// Invalidate Entire Mesh and Automatically Probe Mesh in areas that can be reached by the probe // Invalidate Entire Mesh and Automatically Probe Mesh in areas that can be reached by the probe
// //
@ -460,7 +460,7 @@
report_current_position(); report_current_position();
probe_deployed = true; probe_deployed = true;
break; } break;
#endif // HAS_BED_PROBE #endif // HAS_BED_PROBE

20
Marlin/src/feature/bedlevel/ubl/ubl_motion.cpp
View file

@ -88,7 +88,7 @@
FINAL_MOVE: FINAL_MOVE:
// The distance is always MESH_X_DIST so multiply by the constant reciprocal. // The distance is always MESH_X_DIST so multiply by the constant reciprocal.
const float xratio = (end[X_AXIS] - mesh_index_to_xpos(cell_dest_xi)) * (1.0f / (MESH_X_DIST)); const float xratio = (end[X_AXIS] - mesh_index_to_xpos(cell_dest_xi)) * RECIPROCAL(MESH_X_DIST);
float z1 = z_values[cell_dest_xi ][cell_dest_yi ] + xratio * float z1 = z_values[cell_dest_xi ][cell_dest_yi ] + xratio *
(z_values[cell_dest_xi + 1][cell_dest_yi ] - z_values[cell_dest_xi][cell_dest_yi ]), (z_values[cell_dest_xi + 1][cell_dest_yi ] - z_values[cell_dest_xi][cell_dest_yi ]),
@ -98,7 +98,7 @@
if (cell_dest_xi >= GRID_MAX_POINTS_X - 1) z1 = z2 = 0.0; if (cell_dest_xi >= GRID_MAX_POINTS_X - 1) z1 = z2 = 0.0;
// X cell-fraction done. Interpolate the two Z offsets with the Y fraction for the final Z offset. // X cell-fraction done. Interpolate the two Z offsets with the Y fraction for the final Z offset.
const float yratio = (end[Y_AXIS] - mesh_index_to_ypos(cell_dest_yi)) * (1.0f / (MESH_Y_DIST)), const float yratio = (end[Y_AXIS] - mesh_index_to_ypos(cell_dest_yi)) * RECIPROCAL(MESH_Y_DIST),
z0 = cell_dest_yi < GRID_MAX_POINTS_Y - 1 ? (z1 + (z2 - z1) * yratio) * planner.fade_scaling_factor_for_z(end[Z_AXIS]) : 0.0; z0 = cell_dest_yi < GRID_MAX_POINTS_Y - 1 ? (z1 + (z2 - z1) * yratio) * planner.fade_scaling_factor_for_z(end[Z_AXIS]) : 0.0;
// Undefined parts of the Mesh in z_values[][] are NAN. // Undefined parts of the Mesh in z_values[][] are NAN.
@ -373,10 +373,10 @@
#if IS_KINEMATIC #if IS_KINEMATIC
const float seconds = cartesian_xy_mm / feedrate; // seconds to move xy distance at requested rate const float seconds = cartesian_xy_mm / feedrate; // seconds to move xy distance at requested rate
uint16_t segments = LROUND(delta_segments_per_second * seconds), // preferred number of segments for distance @ feedrate uint16_t segments = LROUND(delta_segments_per_second * seconds), // preferred number of segments for distance @ feedrate
seglimit = LROUND(cartesian_xy_mm * (1.0f / (DELTA_SEGMENT_MIN_LENGTH))); // number of segments at minimum segment length seglimit = LROUND(cartesian_xy_mm * RECIPROCAL(DELTA_SEGMENT_MIN_LENGTH)); // number of segments at minimum segment length
NOMORE(segments, seglimit); // limit to minimum segment length (fewer segments) NOMORE(segments, seglimit); // limit to minimum segment length (fewer segments)
#else #else
uint16_t segments = LROUND(cartesian_xy_mm * (1.0f / (DELTA_SEGMENT_MIN_LENGTH))); // cartesian fixed segment length uint16_t segments = LROUND(cartesian_xy_mm * RECIPROCAL(DELTA_SEGMENT_MIN_LENGTH)); // cartesian fixed segment length
#endif #endif
NOLESS(segments, 1U); // must have at least one segment NOLESS(segments, 1U); // must have at least one segment
@ -440,8 +440,8 @@
// in top of loop and again re-find same adjacent cell and use it, just less efficient // in top of loop and again re-find same adjacent cell and use it, just less efficient
// for mesh inset area. // for mesh inset area.
int8_t cell_xi = (raw[X_AXIS] - (MESH_MIN_X)) * (1.0f / (MESH_X_DIST)), int8_t cell_xi = (raw[X_AXIS] - (MESH_MIN_X)) * RECIPROCAL(MESH_X_DIST),
cell_yi = (raw[Y_AXIS] - (MESH_MIN_Y)) * (1.0f / (MESH_Y_DIST)); cell_yi = (raw[Y_AXIS] - (MESH_MIN_Y)) * RECIPROCAL(MESH_Y_DIST);
LIMIT(cell_xi, 0, (GRID_MAX_POINTS_X) - 1); LIMIT(cell_xi, 0, (GRID_MAX_POINTS_X) - 1);
LIMIT(cell_yi, 0, (GRID_MAX_POINTS_Y) - 1); LIMIT(cell_yi, 0, (GRID_MAX_POINTS_Y) - 1);
@ -462,15 +462,15 @@
float cx = raw[X_AXIS] - x0, // cell-relative x and y float cx = raw[X_AXIS] - x0, // cell-relative x and y
cy = raw[Y_AXIS] - y0; cy = raw[Y_AXIS] - y0;
const float z_xmy0 = (z_x1y0 - z_x0y0) * (1.0f / (MESH_X_DIST)), // z slope per x along y0 (lower left to lower right) const float z_xmy0 = (z_x1y0 - z_x0y0) * RECIPROCAL(MESH_X_DIST), // z slope per x along y0 (lower left to lower right)
z_xmy1 = (z_x1y1 - z_x0y1) * (1.0f / (MESH_X_DIST)); // z slope per x along y1 (upper left to upper right) z_xmy1 = (z_x1y1 - z_x0y1) * RECIPROCAL(MESH_X_DIST); // z slope per x along y1 (upper left to upper right)
float z_cxy0 = z_x0y0 + z_xmy0 * cx; // z height along y0 at cx (changes for each cx in cell) float z_cxy0 = z_x0y0 + z_xmy0 * cx; // z height along y0 at cx (changes for each cx in cell)
const float z_cxy1 = z_x0y1 + z_xmy1 * cx, // z height along y1 at cx const float z_cxy1 = z_x0y1 + z_xmy1 * cx, // z height along y1 at cx
z_cxyd = z_cxy1 - z_cxy0; // z height difference along cx from y0 to y1 z_cxyd = z_cxy1 - z_cxy0; // z height difference along cx from y0 to y1
float z_cxym = z_cxyd * (1.0f / (MESH_Y_DIST)); // z slope per y along cx from y0 to y1 (changes for each cx in cell) float z_cxym = z_cxyd * RECIPROCAL(MESH_Y_DIST); // z slope per y along cx from y0 to y1 (changes for each cx in cell)
// float z_cxcy = z_cxy0 + z_cxym * cy; // interpolated mesh z height along cx at cy (do inside the segment loop) // float z_cxcy = z_cxy0 + z_cxym * cy; // interpolated mesh z height along cx at cy (do inside the segment loop)
@ -479,7 +479,7 @@
// each change by a constant for fixed segment lengths. // each change by a constant for fixed segment lengths.
const float z_sxy0 = z_xmy0 * diff[X_AXIS], // per-segment adjustment to z_cxy0 const float z_sxy0 = z_xmy0 * diff[X_AXIS], // per-segment adjustment to z_cxy0
z_sxym = (z_xmy1 - z_xmy0) * (1.0f / (MESH_Y_DIST)) * diff[X_AXIS]; // per-segment adjustment to z_cxym z_sxym = (z_xmy1 - z_xmy0) * RECIPROCAL(MESH_Y_DIST) * diff[X_AXIS]; // per-segment adjustment to z_cxym
for (;;) { // for all segments within this mesh cell for (;;) { // for all segments within this mesh cell

4
Marlin/src/feature/dac/stepper_dac.cpp
View file

@ -74,8 +74,8 @@ void dac_current_raw(uint8_t channel, uint16_t val) {
mcp4728_simpleCommand(UPDATE); mcp4728_simpleCommand(UPDATE);
} }
static float dac_perc(int8_t n) { return 100.0 * mcp4728_getValue(dac_order[n]) * (1.0f / (DAC_STEPPER_MAX)); } static float dac_perc(int8_t n) { return 100.0 * mcp4728_getValue(dac_order[n]) * RECIPROCAL(DAC_STEPPER_MAX); }
static float dac_amps(int8_t n) { return mcp4728_getDrvPct(dac_order[n]) * (DAC_STEPPER_MAX) * 0.125 * (1.0f / (DAC_STEPPER_SENSE)); } static float dac_amps(int8_t n) { return mcp4728_getDrvPct(dac_order[n]) * (DAC_STEPPER_MAX) * 0.125 * RECIPROCAL(DAC_STEPPER_SENSE); }
uint8_t dac_current_get_percent(AxisEnum axis) { return mcp4728_getDrvPct(dac_order[axis]); } uint8_t dac_current_get_percent(AxisEnum axis) { return mcp4728_getDrvPct(dac_order[axis]); }
void dac_current_set_percents(const uint8_t pct[XYZE]) { void dac_current_set_percents(const uint8_t pct[XYZE]) {

2
Marlin/src/feature/filwidth.h
View file

@ -66,7 +66,7 @@ public:
} }
// Convert raw measurement to mm // Convert raw measurement to mm
static inline float raw_to_mm(const uint16_t v) { return v * 5.0f * (1.0f / 16383.0f); } static inline float raw_to_mm(const uint16_t v) { return v * 5.0f * RECIPROCAL(16383.0f); }
static inline float raw_to_mm() { return raw_to_mm(raw); } static inline float raw_to_mm() { return raw_to_mm(raw); }
// A scaled reading is ready // A scaled reading is ready

3
Marlin/src/feature/runout.h
View file

@ -27,7 +27,8 @@
#include "../sd/cardreader.h" #include "../sd/cardreader.h"
#include "../module/printcounter.h" #include "../module/printcounter.h"
#include "../module/stepper.h" #include "../module/planner.h"
#include "../module/stepper.h" // for block_t
#include "../gcode/queue.h" #include "../gcode/queue.h"
#include "../inc/MarlinConfig.h" #include "../inc/MarlinConfig.h"

6
Marlin/src/gcode/bedlevel/abl/G29.cpp
View file

@ -769,11 +769,7 @@ G29_TYPE GcodeSuite::G29() {
if (!dryrun && !isnan(measured_z)) { if (!dryrun && !isnan(measured_z)) {
vector_3 planeNormal = vector_3::cross(points[0] - points[1], points[2] - points[1]).get_normal(); vector_3 planeNormal = vector_3::cross(points[0] - points[1], points[2] - points[1]).get_normal();
if (planeNormal.z < 0) { if (planeNormal.z < 0) planeNormal *= -1;
planeNormal.x *= -1;
planeNormal.y *= -1;
planeNormal.z *= -1;
}
planner.bed_level_matrix = matrix_3x3::create_look_at(planeNormal); planner.bed_level_matrix = matrix_3x3::create_look_at(planeNormal);
// Can't re-enable (on error) until the new grid is written // Can't re-enable (on error) until the new grid is written

3
Marlin/src/gcode/calibrate/G33.cpp
View file

@ -369,10 +369,11 @@ static float auto_tune_a() {
delta_r = {0.0}, delta_r = {0.0},
delta_t[ABC] = {0.0}; delta_t[ABC] = {0.0};
ZERO(delta_t);
LOOP_XYZ(axis) { LOOP_XYZ(axis) {
LOOP_XYZ(axis_2) delta_t[axis_2] = 0.0;
delta_t[axis] = diff; delta_t[axis] = diff;
calc_kinematics_diff_probe_points(z_pt, delta_e, delta_r, delta_t); calc_kinematics_diff_probe_points(z_pt, delta_e, delta_r, delta_t);
delta_t[axis] = 0;
a_fac += z_pt[uint8_t((axis * _4P_STEP) - _7P_STEP + NPP) % NPP + 1] / 6.0; a_fac += z_pt[uint8_t((axis * _4P_STEP) - _7P_STEP + NPP) % NPP + 1] / 6.0;
a_fac -= z_pt[uint8_t((axis * _4P_STEP) + 1 + _7P_STEP)] / 6.0; a_fac -= z_pt[uint8_t((axis * _4P_STEP) + 1 + _7P_STEP)] / 6.0;
} }

47
Marlin/src/gcode/calibrate/G425.cpp
View file

@ -314,18 +314,16 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
// The difference between the known and the measured location // The difference between the known and the measured location
// of the calibration object is the positional error // of the calibration object is the positional error
m.pos_error[X_AXIS] = m.pos_error[X_AXIS] = (0
#if HAS_X_CENTER #if HAS_X_CENTER
m.true_center[X_AXIS] - m.obj_center[X_AXIS]; + m.true_center[X_AXIS] - m.obj_center[X_AXIS]
#else #endif
0; );
#endif m.pos_error[Y_AXIS] = (0
m.pos_error[Y_AXIS] = #if HAS_Y_CENTER
#if HAS_Y_CENTER + m.true_center[Y_AXIS] - m.obj_center[Y_AXIS]
m.true_center[Y_AXIS] - m.obj_center[Y_AXIS]; #endif
#else );
0;
#endif
m.pos_error[Z_AXIS] = m.true_center[Z_AXIS] - m.obj_center[Z_AXIS]; m.pos_error[Z_AXIS] = m.true_center[Z_AXIS] - m.obj_center[Z_AXIS];
} }
@ -394,13 +392,13 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
inline void report_measured_nozzle_dimensions(const measurements_t &m) { inline void report_measured_nozzle_dimensions(const measurements_t &m) {
SERIAL_ECHOLNPGM("Nozzle Tip Outer Dimensions:"); SERIAL_ECHOLNPGM("Nozzle Tip Outer Dimensions:");
#if HAS_X_CENTER #if HAS_X_CENTER || HAS_Y_CENTER
SERIAL_ECHOLNPAIR(" X", m.nozzle_outer_dimension[X_AXIS]); #if HAS_X_CENTER
#else SERIAL_ECHOLNPAIR(" X", m.nozzle_outer_dimension[X_AXIS]);
UNUSED(m); #endif
#endif #if HAS_Y_CENTER
#if HAS_Y_CENTER SERIAL_ECHOLNPAIR(" Y", m.nozzle_outer_dimension[Y_AXIS]);
SERIAL_ECHOLNPAIR(" Y", m.nozzle_outer_dimension[Y_AXIS]); #endif
#else #else
UNUSED(m); UNUSED(m);
#endif #endif
@ -412,16 +410,11 @@ inline void probe_sides(measurements_t &m, const float uncertainty) {
// This function requires normalize_hotend_offsets() to be called // This function requires normalize_hotend_offsets() to be called
// //
inline void report_hotend_offsets() { inline void report_hotend_offsets() {
for (uint8_t e = 1; e < HOTENDS; e++) { for (uint8_t e = 1; e < HOTENDS; e++)
SERIAL_ECHOPAIR("T", int(e)); SERIAL_ECHOLNPAIR("T", int(e), " Hotend Offset X", hotend_offset[X_AXIS][e], " Y", hotend_offset[Y_AXIS][e], " Z", hotend_offset[Z_AXIS][e]);
SERIAL_ECHOLNPGM(" Hotend Offset:");
SERIAL_ECHOLNPAIR(" X: ", hotend_offset[X_AXIS][e]);
SERIAL_ECHOLNPAIR(" Y: ", hotend_offset[Y_AXIS][e]);
SERIAL_ECHOLNPAIR(" Z: ", hotend_offset[Z_AXIS][e]);
SERIAL_EOL();
}
} }
#endif #endif
#endif // CALIBRATION_REPORTING #endif // CALIBRATION_REPORTING
/** /**

10
Marlin/src/gcode/calibrate/M425.cpp
View file

@ -46,10 +46,10 @@
void GcodeSuite::M425() { void GcodeSuite::M425() {
bool noArgs = true; bool noArgs = true;
LOOP_XYZ(i) { LOOP_XYZ(a) {
if (parser.seen(axis_codes[i])) { if (parser.seen(axis_codes[a])) {
planner.synchronize(); planner.synchronize();
backlash.distance_mm[i] = parser.has_value() ? parser.value_linear_units() : backlash.get_measurement(i); backlash.distance_mm[a] = parser.has_value() ? parser.value_linear_units() : backlash.get_measurement(AxisEnum(a));
noArgs = false; noArgs = false;
} }
} }
@ -88,10 +88,10 @@ void GcodeSuite::M425() {
#if ENABLED(MEASURE_BACKLASH_WHEN_PROBING) #if ENABLED(MEASURE_BACKLASH_WHEN_PROBING)
SERIAL_ECHOPGM(" Average measured backlash (mm):"); SERIAL_ECHOPGM(" Average measured backlash (mm):");
if (backlash.has_any_measurement()) { if (backlash.has_any_measurement()) {
LOOP_XYZ(a) if (backlash.has_measurement(a)) { LOOP_XYZ(a) if (backlash.has_measurement(AxisEnum(a))) {
SERIAL_CHAR(' '); SERIAL_CHAR(' ');
SERIAL_CHAR(axis_codes[a]); SERIAL_CHAR(axis_codes[a]);
SERIAL_ECHO(backlash.get_measurement(a)); SERIAL_ECHO(backlash.get_measurement(AxisEnum(a)));
} }
} }
else else

4
Marlin/src/gcode/control/M605.cpp
View file

@ -137,8 +137,8 @@
DEBUG_EOL(); DEBUG_EOL();
HOTEND_LOOP() { HOTEND_LOOP() {
DEBUG_ECHOPAIR(" nozzle:", int(e)); DEBUG_ECHOPAIR(" T", int(e));
LOOP_XYZ(j) DEBUG_ECHOPAIR(" hotend_offset[", axis_codes[j], "_AXIS][", int(e), "]=", hotend_offset[j][e]); LOOP_XYZ(a) DEBUG_ECHOPAIR(" hotend_offset[", axis_codes[a], "_AXIS][", int(e), "]=", hotend_offset[a][e]);
DEBUG_EOL(); DEBUG_EOL();
} }
DEBUG_EOL(); DEBUG_EOL();

7
Marlin/src/gcode/feature/mixing/M166.cpp
View file

@ -30,15 +30,12 @@
#include "../../../feature/mixing.h" #include "../../../feature/mixing.h"
inline void echo_mix() { inline void echo_mix() {
SERIAL_ECHOPAIR(" (", int(mixer.mix[0])); SERIAL_ECHOPAIR(" (", int(mixer.mix[0]), "%|", int(mixer.mix[1]), "%)");
SERIAL_ECHOPAIR("%|", int(mixer.mix[1]));
SERIAL_ECHOPGM("%)");
} }
inline void echo_zt(const int t, const float &z) { inline void echo_zt(const int t, const float &z) {
mixer.update_mix_from_vtool(t); mixer.update_mix_from_vtool(t);
SERIAL_ECHOPAIR(" Z", z); SERIAL_ECHOPAIR(" Z", z, " T", t);
SERIAL_ECHOPAIR(" T", t);
echo_mix(); echo_mix();
} }

6
Marlin/src/gcode/host/M114.cpp
View file

@ -38,11 +38,11 @@
void report_xyze(const float pos[], const uint8_t n = 4, const uint8_t precision = 3) { void report_xyze(const float pos[], const uint8_t n = 4, const uint8_t precision = 3) {
char str[12]; char str[12];
for (uint8_t i = 0; i < n; i++) { for (uint8_t a = 0; a < n; a++) {
SERIAL_CHAR(' '); SERIAL_CHAR(' ');
SERIAL_CHAR(axis_codes[i]); SERIAL_CHAR(axis_codes[a]);
SERIAL_CHAR(':'); SERIAL_CHAR(':');
SERIAL_ECHO(dtostrf(pos[i], 1, precision, str)); SERIAL_ECHO(dtostrf(pos[a], 1, precision, str));
} }
SERIAL_EOL(); SERIAL_EOL();
} }

30
Marlin/src/gcode/motion/G2_G3.cpp
View file

@ -280,20 +280,22 @@ void GcodeSuite::G2_G3(const bool clockwise) {
float arc_offset[2] = { 0, 0 }; float arc_offset[2] = { 0, 0 };
if (parser.seenval('R')) { if (parser.seenval('R')) {
const float r = parser.value_linear_units(), const float r = parser.value_linear_units();
p1 = current_position[X_AXIS], q1 = current_position[Y_AXIS], if (r) {
p2 = destination[X_AXIS], q2 = destination[Y_AXIS]; const float p1 = current_position[X_AXIS], q1 = current_position[Y_AXIS],
if (r && (p2 != p1 || q2 != q1)) { p2 = destination[X_AXIS], q2 = destination[Y_AXIS];
const float e = clockwise ^ (r < 0) ? -1 : 1, // clockwise -1/1, counterclockwise 1/-1 if (p2 != p1 || q2 != q1) {
dx = p2 - p1, dy = q2 - q1, // X and Y differences const float e = clockwise ^ (r < 0) ? -1 : 1, // clockwise -1/1, counterclockwise 1/-1
d = HYPOT(dx, dy), // Linear distance between the points dx = p2 - p1, dy = q2 - q1, // X and Y differences
dinv = 1/d, // Inverse of d d = HYPOT(dx, dy), // Linear distance between the points
h = SQRT(sq(r) - sq(d * 0.5f)), // Distance to the arc pivot-point dinv = 1/d, // Inverse of d
mx = (p1 + p2) * 0.5f, my = (q1 + q2) * 0.5f,// Point between the two points h = SQRT(sq(r) - sq(d * 0.5f)), // Distance to the arc pivot-point
sx = -dy * dinv, sy = dx * dinv, // Slope of the perpendicular bisector mx = (p1 + p2) * 0.5f, my = (q1 + q2) * 0.5f,// Point between the two points
cx = mx + e * h * sx, cy = my + e * h * sy; // Pivot-point of the arc sx = -dy * dinv, sy = dx * dinv, // Slope of the perpendicular bisector
arc_offset[0] = cx - p1; cx = mx + e * h * sx, cy = my + e * h * sy; // Pivot-point of the arc
arc_offset[1] = cy - q1; arc_offset[0] = cx - p1;
arc_offset[1] = cy - q1;
}
} }
} }
else { else {

7
Marlin/src/gcode/probe/G30.cpp
View file

@ -54,11 +54,8 @@ void GcodeSuite::G30() {
const ProbePtRaise raise_after = parser.boolval('E', true) ? PROBE_PT_STOW : PROBE_PT_NONE; const ProbePtRaise raise_after = parser.boolval('E', true) ? PROBE_PT_STOW : PROBE_PT_NONE;
const float measured_z = probe_pt(xpos, ypos, raise_after, 1); const float measured_z = probe_pt(xpos, ypos, raise_after, 1);
if (!isnan(measured_z)) { if (!isnan(measured_z))
SERIAL_ECHOPAIR("Bed X: ", FIXFLOAT(xpos)); SERIAL_ECHOLNPAIR("Bed X: ", FIXFLOAT(xpos), " Y: ", FIXFLOAT(ypos), " Z: ", FIXFLOAT(measured_z));
SERIAL_ECHOPAIR(" Y: ", FIXFLOAT(ypos));
SERIAL_ECHOLNPAIR(" Z: ", FIXFLOAT(measured_z));
}
clean_up_after_endstop_or_probe_move(); clean_up_after_endstop_or_probe_move();

2
Marlin/src/inc/MarlinConfigPre.h
View file

@ -43,3 +43,5 @@
#include "Conditionals_adv.h" #include "Conditionals_adv.h"
#include HAL_PATH(../HAL, inc/Conditionals_adv.h) #include HAL_PATH(../HAL, inc/Conditionals_adv.h)
#include <stdint.h>

2
Marlin/src/inc/SanityCheck.h
View file

@ -388,6 +388,8 @@
#error "SDPOWER is now SDPOWER_PIN. Please update your configuration and/or pins." #error "SDPOWER is now SDPOWER_PIN. Please update your configuration and/or pins."
#elif defined(STRING_SPLASH_LINE1) || defined(STRING_SPLASH_LINE2) #elif defined(STRING_SPLASH_LINE1) || defined(STRING_SPLASH_LINE2)
#error "STRING_SPLASH_LINE[12] are now obsolete. Please remove them from Configuration.h." #error "STRING_SPLASH_LINE[12] are now obsolete. Please remove them from Configuration.h."
#elif defined(Z_PROBE_ALLEN_KEY_DEPLOY_1_X) || defined(Z_PROBE_ALLEN_KEY_STOW_1_X)
#error "Z_PROBE_ALLEN_KEY_(DEPLOY|STOW) coordinates are now a single setting. Please update your configuration."
#endif #endif
#define BOARD_MKS_13 -1000 #define BOARD_MKS_13 -1000

20
Marlin/src/lcd/dogm/status_screen_lite_ST7920.cpp
View file

@ -658,7 +658,7 @@ void ST7920_Lite_Status_Screen::draw_status_message() {
#endif #endif
} }
void ST7920_Lite_Status_Screen::draw_position(const float x, const float y, const float z, bool position_known) { void ST7920_Lite_Status_Screen::draw_position(const float (&pos)[XYZE], const bool position_known) {
char str[7]; char str[7];
set_ddram_address(DDRAM_LINE_4); set_ddram_address(DDRAM_LINE_4);
begin_data(); begin_data();
@ -667,13 +667,13 @@ void ST7920_Lite_Status_Screen::draw_position(const float x, const float y, cons
const unsigned char alt_label = position_known ? 0 : (ui.get_blink() ? ' ' : 0); const unsigned char alt_label = position_known ? 0 : (ui.get_blink() ? ' ' : 0);
write_byte(alt_label ? alt_label : 'X'); write_byte(alt_label ? alt_label : 'X');
write_str(dtostrf(x, -4, 0, str), 4); write_str(dtostrf(pos[X_AXIS], -4, 0, str), 4);
write_byte(alt_label ? alt_label : 'Y'); write_byte(alt_label ? alt_label : 'Y');
write_str(dtostrf(y, -4, 0, str), 4); write_str(dtostrf(pos[Y_AXIS], -4, 0, str), 4);
write_byte(alt_label ? alt_label : 'Z'); write_byte(alt_label ? alt_label : 'Z');
write_str(dtostrf(z, -5, 1, str), 5); write_str(dtostrf(pos[Z_AXIS], -5, 1, str), 5);
} }
bool ST7920_Lite_Status_Screen::indicators_changed() { bool ST7920_Lite_Status_Screen::indicators_changed() {
@ -826,16 +826,14 @@ void ST7920_Lite_Status_Screen::update_status_or_position(bool forceUpdate) {
} }
} }
if (countdown == 0 && (forceUpdate || position_changed() || if (countdown == 0 && (forceUpdate || position_changed()
#if DISABLED(DISABLE_REDUCED_ACCURACY_WARNING) #if DISABLED(DISABLE_REDUCED_ACCURACY_WARNING)
blink_changed() || blink_changed()
#endif #endif
)) { )) {
draw_position(current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS], draw_position(current_position, true
#if ENABLED(DISABLE_REDUCED_ACCURACY_WARNING) #if DISABLED(DISABLE_REDUCED_ACCURACY_WARNING)
true && all_axes_known()
#else
all_axes_known()
#endif #endif
); );
} }

2
Marlin/src/lcd/dogm/status_screen_lite_ST7920.h
View file

@ -86,7 +86,7 @@ class ST7920_Lite_Status_Screen {
static void draw_print_time(const duration_t &elapsed); static void draw_print_time(const duration_t &elapsed);
static void draw_feedrate_percentage(const uint16_t percentage); static void draw_feedrate_percentage(const uint16_t percentage);
static void draw_status_message(); static void draw_status_message();
static void draw_position(const float x, const float y, const float z, bool position_known = true); static void draw_position(const float (&pos)[XYZE], bool position_known = true);
static bool indicators_changed(); static bool indicators_changed();
static bool position_changed(); static bool position_changed();

3
Marlin/src/lcd/extensible_ui/lib/lulzbot/screens/move_axis_screen.cpp
View file

@ -36,7 +36,7 @@ void MoveAxisScreen::onEntry() {
// ourselves. The relative distances are reset to zero whenever this // ourselves. The relative distances are reset to zero whenever this
// screen is entered. // screen is entered.
for(uint8_t i = 0; i < ExtUI::extruderCount; i++) { for (uint8_t i = 0; i < ExtUI::extruderCount; i++) {
screen_data.MoveAxisScreen.e_rel[i] = 0; screen_data.MoveAxisScreen.e_rel[i] = 0;
} }
BaseNumericAdjustmentScreen::onEntry(); BaseNumericAdjustmentScreen::onEntry();
@ -111,6 +111,7 @@ float MoveAxisScreen::getManualFeedrate(uint8_t axis, float increment_mm) {
// connect segments and even out the motion. // connect segments and even out the motion.
constexpr float max_manual_feedrate[XYZE] = MAX_MANUAL_FEEDRATE; constexpr float max_manual_feedrate[XYZE] = MAX_MANUAL_FEEDRATE;
return min(max_manual_feedrate[axis]/60, abs(increment_mm * TOUCH_REPEATS_PER_SECOND * 0.80)); return min(max_manual_feedrate[axis]/60, abs(increment_mm * TOUCH_REPEATS_PER_SECOND * 0.80));
return min(max_manual_feedrate[axis] / 60, abs(increment_mm * TOUCH_REPEATS_PER_SECOND * 0.80));
} }
void MoveAxisScreen::setManualFeedrate(ExtUI::axis_t axis, float increment_mm) { void MoveAxisScreen::setManualFeedrate(ExtUI::axis_t axis, float increment_mm) {

2
Marlin/src/lcd/ultralcd.cpp
View file

@ -685,7 +685,7 @@ void MarlinUI::quick_feedback(const bool clear_buttons/*=true*/) {
// previous invocation is being blocked. Modifications to manual_move_offset shouldn't be made while // previous invocation is being blocked. Modifications to manual_move_offset shouldn't be made while
// processing_manual_move is true or the planner will get out of sync. // processing_manual_move is true or the planner will get out of sync.
processing_manual_move = true; processing_manual_move = true;
prepare_move_to_destination(); // will call set_current_from_destination() prepare_move_to_destination(); // will set current_position from destination
processing_manual_move = false; processing_manual_move = false;
feedrate_mm_s = old_feedrate; feedrate_mm_s = old_feedrate;

4
Marlin/src/libs/L6470/L6470_Marlin.cpp
View file

@ -384,8 +384,8 @@ bool L6470_Marlin::get_user_input(uint8_t &driver_count, uint8_t axis_index[3],
} break; } break;
case 'Z': { case 'Z': {
position_min = center[E_AXIS] - displacement; position_min = center[Z_AXIS] - displacement;
position_max = center[E_AXIS] + displacement; position_max = center[Z_AXIS] + displacement;
echo_min_max('Z', position_min, position_max); echo_min_max('Z', position_min, position_max);
if (false if (false
#ifdef Z_MIN_POS #ifdef Z_MIN_POS

23
Marlin/src/libs/least_squares_fit.h
View file

@ -51,18 +51,19 @@ void inline incremental_LSF_reset(struct linear_fit_data *lsf) {
void inline incremental_WLSF(struct linear_fit_data *lsf, const float &x, const float &y, const float &z, const float &w) { void inline incremental_WLSF(struct linear_fit_data *lsf, const float &x, const float &y, const float &z, const float &w) {
// weight each accumulator by factor w, including the "number" of samples // weight each accumulator by factor w, including the "number" of samples
// (analogous to calling inc_LSF twice with same values to weight it by 2X) // (analogous to calling inc_LSF twice with same values to weight it by 2X)
lsf->xbar += w * x; const float wx = w * x, wy = w * y, wz = w * z;
lsf->ybar += w * y; lsf->xbar += wx;
lsf->zbar += w * z; lsf->ybar += wy;
lsf->x2bar += w * x * x; // don't use sq(x) -- let compiler re-use w*x four times lsf->zbar += wz;
lsf->y2bar += w * y * y; lsf->x2bar += wx * x;
lsf->z2bar += w * z * z; lsf->y2bar += wy * y;
lsf->xybar += w * x * y; lsf->z2bar += wz * z;
lsf->xzbar += w * x * z; lsf->xybar += wx * y;
lsf->yzbar += w * y * z; lsf->xzbar += wx * z;
lsf->yzbar += wy * z;
lsf->N += w; lsf->N += w;
lsf->max_absx = _MAX(ABS(w * x), lsf->max_absx); lsf->max_absx = _MAX(ABS(wx), lsf->max_absx);
lsf->max_absy = _MAX(ABS(w * y), lsf->max_absy); lsf->max_absy = _MAX(ABS(wy), lsf->max_absy);
} }
void inline incremental_LSF(struct linear_fit_data *lsf, const float &x, const float &y, const float &z) { void inline incremental_LSF(struct linear_fit_data *lsf, const float &x, const float &y, const float &z) {

16
Marlin/src/libs/nozzle.cpp
View file

@ -175,16 +175,9 @@ Nozzle nozzle;
if (!TEST(cleans, Z_AXIS)) start.z = end.z = current_position[Z_AXIS]; if (!TEST(cleans, Z_AXIS)) start.z = end.z = current_position[Z_AXIS];
switch (pattern) { switch (pattern) {
case 1: case 1: zigzag(start, end, strokes, objects); break;
zigzag(start, end, strokes, objects); case 2: circle(start, end, strokes, radius); break;
break; default: stroke(start, end, strokes);
case 2:
circle(start, end, strokes, radius);
break;
default:
stroke(start, end, strokes);
} }
} }
@ -193,8 +186,7 @@ Nozzle nozzle;
#if ENABLED(NOZZLE_PARK_FEATURE) #if ENABLED(NOZZLE_PARK_FEATURE)
void Nozzle::park(const uint8_t z_action, const point_t &park/*=NOZZLE_PARK_POINT*/) { void Nozzle::park(const uint8_t z_action, const point_t &park/*=NOZZLE_PARK_POINT*/) {
const float fr_xy = NOZZLE_PARK_XY_FEEDRATE, constexpr float fr_xy = NOZZLE_PARK_XY_FEEDRATE, fr_z = NOZZLE_PARK_Z_FEEDRATE;
fr_z = NOZZLE_PARK_Z_FEEDRATE;
switch (z_action) { switch (z_action) {
case 1: // Go to Z-park height case 1: // Go to Z-park height

4
Marlin/src/libs/numtostr.cpp
View file

@ -21,6 +21,8 @@
*/ */
#include "numtostr.h" #include "numtostr.h"
#include "../inc/MarlinConfigPre.h"
#include "../core/utility.h" #include "../core/utility.h"
char conv[8] = { 0 }; char conv[8] = { 0 };
@ -183,7 +185,7 @@ char* ftostr52(const float &f) {
return &conv[3]; return &conv[3];
} }
#endif // LCD_DECIMAL_SMALL_XY #endif
// Convert float to fixed-length string with +123.4 / -123.4 format // Convert float to fixed-length string with +123.4 / -123.4 format
char* ftostr41sign(const float &f) { char* ftostr41sign(const float &f) {

6
Marlin/src/libs/numtostr.h
View file

@ -21,7 +21,7 @@
*/ */
#pragma once #pragma once
#include "../inc/MarlinConfigPre.h" #include <stdint.h>
// Convert a full-range unsigned 8bit int to a percentage // Convert a full-range unsigned 8bit int to a percentage
char* ui8tostr4pct(const uint8_t i); char* ui8tostr4pct(const uint8_t i);
@ -83,9 +83,13 @@ char* ftostr52sign(const float &x);
// Convert unsigned float to string with 1234.5 format omitting trailing zeros // Convert unsigned float to string with 1234.5 format omitting trailing zeros
char* ftostr51rj(const float &x); char* ftostr51rj(const float &x);
#include "../core/macros.h"
// Convert float to rj string with 123 or -12 format // Convert float to rj string with 123 or -12 format
FORCE_INLINE char* ftostr3(const float &x) { return i16tostr3(int16_t(x + (x < 0 ? -0.5f : 0.5f))); } FORCE_INLINE char* ftostr3(const float &x) { return i16tostr3(int16_t(x + (x < 0 ? -0.5f : 0.5f))); }
#include "../inc/MarlinConfigPre.h"
#if ENABLED(LCD_DECIMAL_SMALL_XY) #if ENABLED(LCD_DECIMAL_SMALL_XY)
// Convert float to rj string with 1234, _123, 12.3, _1.2, -123, _-12, or -1.2 format // Convert float to rj string with 1234, _123, 12.3, _1.2, -123, _-12, or -1.2 format
char* ftostr4sign(const float &fx); char* ftostr4sign(const float &fx);

4
Marlin/src/libs/stopwatch.h
View file

@ -25,7 +25,9 @@
//#define DEBUG_STOPWATCH //#define DEBUG_STOPWATCH
#include "../core/macros.h" // for FORCE_INLINE #include "../core/macros.h" // for FORCE_INLINE
#include "../core/millis_t.h"
#include <stdint.h>
typedef uint32_t millis_t;
/** /**
* @brief Stopwatch class * @brief Stopwatch class

7
Marlin/src/libs/vector_3.cpp
View file

@ -57,8 +57,11 @@ vector_3 vector_3::cross(const vector_3 &left, const vector_3 &right) {
left.x * right.y - left.y * right.x); left.x * right.y - left.y * right.x);
} }
vector_3 vector_3::operator+(const vector_3 &v) { return vector_3((x + v.x), (y + v.y), (z + v.z)); } vector_3 vector_3::operator+(const vector_3 &v) { return vector_3(x + v.x, y + v.y, z + v.z); }
vector_3 vector_3::operator-(const vector_3 &v) { return vector_3((x - v.x), (y - v.y), (z - v.z)); } vector_3 vector_3::operator-(const vector_3 &v) { return vector_3(x - v.x, y - v.y, z - v.z); }
vector_3 vector_3::operator* (const float &v) { return vector_3(x * v, y * v, z * v); }
vector_3& vector_3::operator*=(const float &v) { x *= v; y *= v; z *= v; return *this; }
vector_3 vector_3::get_normal() const { vector_3 vector_3::get_normal() const {
vector_3 normalized = vector_3(x, y, z); vector_3 normalized = vector_3(x, y, z);

4
Marlin/src/libs/vector_3.h
View file

@ -52,6 +52,10 @@ struct vector_3 {
vector_3 operator+(const vector_3 &v); vector_3 operator+(const vector_3 &v);
vector_3 operator-(const vector_3 &v); vector_3 operator-(const vector_3 &v);
vector_3 operator* (const float &v);
vector_3& operator*=(const float &v);
void normalize(); void normalize();
float get_length() const; float get_length() const;
vector_3 get_normal() const; vector_3 get_normal() const;

19
Marlin/src/module/configuration_store.cpp
View file

@ -1205,9 +1205,7 @@ void MarlinSettings::postprocess() {
const float backlash_smoothing_mm = 3; const float backlash_smoothing_mm = 3;
#endif #endif
_FIELD_TEST(backlash_distance_mm); _FIELD_TEST(backlash_distance_mm);
EEPROM_WRITE(backlash_distance_mm[X_AXIS]); EEPROM_WRITE(backlash_distance_mm);
EEPROM_WRITE(backlash_distance_mm[Y_AXIS]);
EEPROM_WRITE(backlash_distance_mm[Z_AXIS]);
EEPROM_WRITE(backlash_correction); EEPROM_WRITE(backlash_correction);
EEPROM_WRITE(backlash_smoothing_mm); EEPROM_WRITE(backlash_smoothing_mm);
} }
@ -2010,9 +2008,7 @@ void MarlinSettings::postprocess() {
float backlash_smoothing_mm; float backlash_smoothing_mm;
#endif #endif
_FIELD_TEST(backlash_distance_mm); _FIELD_TEST(backlash_distance_mm);
EEPROM_READ(backlash_distance_mm[X_AXIS]); EEPROM_READ(backlash_distance_mm);
EEPROM_READ(backlash_distance_mm[Y_AXIS]);
EEPROM_READ(backlash_distance_mm[Z_AXIS]);
EEPROM_READ(backlash_correction); EEPROM_READ(backlash_correction);
EEPROM_READ(backlash_smoothing_mm); EEPROM_READ(backlash_smoothing_mm);
} }
@ -2805,9 +2801,8 @@ void MarlinSettings::reset() {
CONFIG_ECHO_START(); CONFIG_ECHO_START();
for (uint8_t e = 1; e < HOTENDS; e++) { for (uint8_t e = 1; e < HOTENDS; e++) {
SERIAL_ECHOPAIR( SERIAL_ECHOPAIR(
" M218 T", (int)e " M218 T", (int)e,
, " X", LINEAR_UNIT(hotend_offset[X_AXIS][e]) " X", LINEAR_UNIT(hotend_offset[X_AXIS][e]), " Y", LINEAR_UNIT(hotend_offset[Y_AXIS][e])
, " Y", LINEAR_UNIT(hotend_offset[Y_AXIS][e])
); );
SERIAL_ECHOLNPAIR_F(" Z", LINEAR_UNIT(hotend_offset[Z_AXIS][e]), 3); SERIAL_ECHOLNPAIR_F(" Z", LINEAR_UNIT(hotend_offset[Z_AXIS][e]), 3);
} }
@ -2922,9 +2917,9 @@ void MarlinSettings::reset() {
CONFIG_ECHO_HEADING("Endstop adjustment:"); CONFIG_ECHO_HEADING("Endstop adjustment:");
CONFIG_ECHO_START(); CONFIG_ECHO_START();
SERIAL_ECHOLNPAIR( SERIAL_ECHOLNPAIR(
" M666 X", LINEAR_UNIT(delta_endstop_adj[X_AXIS]) " M666 X", LINEAR_UNIT(delta_endstop_adj[A_AXIS])
, " Y", LINEAR_UNIT(delta_endstop_adj[Y_AXIS]) , " Y", LINEAR_UNIT(delta_endstop_adj[B_AXIS])
, " Z", LINEAR_UNIT(delta_endstop_adj[Z_AXIS]) , " Z", LINEAR_UNIT(delta_endstop_adj[C_AXIS])
); );
CONFIG_ECHO_HEADING("Delta settings: L<diagonal_rod> R<radius> H<height> S<segments_per_s> B<calibration radius> XYZ<tower angle corrections>"); CONFIG_ECHO_HEADING("Delta settings: L<diagonal_rod> R<radius> H<height> S<segments_per_s> B<calibration radius> XYZ<tower angle corrections>");

8
Marlin/src/module/delta.cpp
View file

@ -101,12 +101,8 @@ void recalc_delta_settings() {
*/ */
#define DELTA_DEBUG(VAR) do { \ #define DELTA_DEBUG(VAR) do { \
SERIAL_ECHOPAIR("cartesian X:", VAR[X_AXIS]); \ SERIAL_ECHOLNPAIR("Cartesian X", VAR[X_AXIS], " Y", VAR[Y_AXIS], " Z", VAR[Z_AXIS]); \
SERIAL_ECHOPAIR(" Y:", VAR[Y_AXIS]); \ SERIAL_ECHOLNPAIR("Delta A", delta[A_AXIS], " B", delta[B_AXIS], " C", delta[C_AXIS]); \
SERIAL_ECHOLNPAIR(" Z:", VAR[Z_AXIS]); \
SERIAL_ECHOPAIR("delta A:", delta[A_AXIS]); \
SERIAL_ECHOPAIR(" B:", delta[B_AXIS]); \
SERIAL_ECHOLNPAIR(" C:", delta[C_AXIS]); \
}while(0) }while(0)
void inverse_kinematics(const float (&raw)[XYZ]) { void inverse_kinematics(const float (&raw)[XYZ]) {

4
Marlin/src/module/motion.cpp
View file

@ -105,7 +105,7 @@ float current_position[XYZE] = { X_HOME_POS, Y_HOME_POS, Z_HOME_POS };
* Cartesian Destination * Cartesian Destination
* The destination for a move, filled in by G-code movement commands, * The destination for a move, filled in by G-code movement commands,
* and expected by functions like 'prepare_move_to_destination'. * and expected by functions like 'prepare_move_to_destination'.
* Set with 'get_destination_from_command' or 'set_destination_from_current'. * G-codes can set destination using 'get_destination_from_command'
*/ */
float destination[XYZE]; // = { 0 } float destination[XYZE]; // = { 0 }
@ -670,7 +670,7 @@ void clean_up_after_endstop_or_probe_move() {
// For SCARA enforce a minimum segment size // For SCARA enforce a minimum segment size
#if IS_SCARA #if IS_SCARA
NOMORE(segments, cartesian_mm * (1.0f / float(SCARA_MIN_SEGMENT_LENGTH))); NOMORE(segments, cartesian_mm * RECIPROCAL(SCARA_MIN_SEGMENT_LENGTH));
#endif #endif
// At least one segment is required // At least one segment is required

62
Marlin/src/module/planner.cpp
View file

@ -1174,7 +1174,10 @@ void Planner::recalculate() {
* Maintain fans, paste extruder pressure, * Maintain fans, paste extruder pressure,
*/ */
void Planner::check_axes_activity() { void Planner::check_axes_activity() {
uint8_t axis_active[NUM_AXIS] = { 0 };
#if ANY(DISABLE_X, DISABLE_Y, DISABLE_Z, DISABLE_E)
uint8_t axis_active[NUM_AXIS] = { 0 };
#endif
#if FAN_COUNT > 0 #if FAN_COUNT > 0
uint8_t tail_fan_speed[FAN_COUNT]; uint8_t tail_fan_speed[FAN_COUNT];
@ -1190,10 +1193,9 @@ void Planner::check_axes_activity() {
#endif #endif
if (has_blocks_queued()) { if (has_blocks_queued()) {
block_t* block;
#if FAN_COUNT > 0 || ENABLED(BARICUDA) #if FAN_COUNT > 0 || ENABLED(BARICUDA)
block = &block_buffer[block_buffer_tail]; block_t *block = &block_buffer[block_buffer_tail];
#endif #endif
#if FAN_COUNT > 0 #if FAN_COUNT > 0
@ -1210,10 +1212,12 @@ void Planner::check_axes_activity() {
#endif #endif
#endif #endif
for (uint8_t b = block_buffer_tail; b != block_buffer_head; b = next_block_index(b)) { #if ANY(DISABLE_X, DISABLE_Y, DISABLE_Z, DISABLE_E)
block = &block_buffer[b]; for (uint8_t b = block_buffer_tail; b != block_buffer_head; b = next_block_index(b)) {
LOOP_XYZE(i) if (block->steps[i]) axis_active[i]++; block_t *block = &block_buffer[b];
} LOOP_XYZE(i) if (block->steps[i]) axis_active[i] = true;
}
#endif
} }
else { else {
#if FAN_COUNT > 0 #if FAN_COUNT > 0
@ -1517,14 +1521,14 @@ float Planner::get_axis_position_mm(const AxisEnum axis) {
const bool was_enabled = STEPPER_ISR_ENABLED(); const bool was_enabled = STEPPER_ISR_ENABLED();
if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT(); if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
// ((a1+a2)+(a1-a2))/2 -> (a1+a2+a1-a2)/2 -> (a1+a1)/2 -> a1 const int32_t p1 = stepper.position(CORE_AXIS_1),
// ((a1+a2)-(a1-a2))/2 -> (a1+a2-a1+a2)/2 -> (a2+a2)/2 -> a2 p2 = stepper.position(CORE_AXIS_2);
axis_steps = 0.5f * (
axis == CORE_AXIS_2 ? CORESIGN(stepper.position(CORE_AXIS_1) - stepper.position(CORE_AXIS_2))
: stepper.position(CORE_AXIS_1) + stepper.position(CORE_AXIS_2)
);
if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT(); if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
// ((a1+a2)+(a1-a2))/2 -> (a1+a2+a1-a2)/2 -> (a1+a1)/2 -> a1
// ((a1+a2)-(a1-a2))/2 -> (a1+a2-a1+a2)/2 -> (a2+a2)/2 -> a2
axis_steps = (axis == CORE_AXIS_2 ? CORESIGN(p1 - p2) : p1 + p2) * 0.5f;
} }
else else
axis_steps = stepper.position(axis); axis_steps = stepper.position(axis);
@ -1551,11 +1555,11 @@ void Planner::synchronize() {
* *
* Add a new linear movement to the planner queue (in terms of steps). * Add a new linear movement to the planner queue (in terms of steps).
* *
* target - target position in steps units * target - target position in steps units
* target_float - target position in direct (mm, degrees) units. optional * target_float - target position in direct (mm, degrees) units. optional
* fr_mm_s - (target) speed of the move * fr_mm_s - (target) speed of the move
* extruder - target extruder * extruder - target extruder
* millimeters - the length of the movement, if known * millimeters - the length of the movement, if known
* *
* Returns true if movement was properly queued, false otherwise * Returns true if movement was properly queued, false otherwise
*/ */
@ -1644,18 +1648,14 @@ bool Planner::_populate_block(block_t * const block, bool split_move,
#endif #endif
/* <-- add a slash to enable /* <-- add a slash to enable
SERIAL_ECHOPAIR(" _populate_block FR:", fr_mm_s); SERIAL_ECHOLNPAIR(" _populate_block FR:", fr_mm_s,
SERIAL_ECHOPAIR(" A:", target[A_AXIS]); " A:", target[A_AXIS], " (", da, " steps)"
SERIAL_ECHOPAIR(" (", da); " B:", target[B_AXIS], " (", db, " steps)"
SERIAL_ECHOPAIR(" steps) B:", target[B_AXIS]); " C:", target[C_AXIS], " (", dc, " steps)"
SERIAL_ECHOPAIR(" (", db); #if EXTRUDERS
SERIAL_ECHOPAIR(" steps) C:", target[C_AXIS]); " E:", target[E_AXIS], " (", de, " steps)"
SERIAL_ECHOPAIR(" (", dc); #endif
#if EXTRUDERS );
SERIAL_ECHOPAIR(" steps) E:", target[E_AXIS]);
SERIAL_ECHOPAIR(" (", de);
#endif
SERIAL_ECHOLNPGM(" steps)");
//*/ //*/
#if EITHER(PREVENT_COLD_EXTRUSION, PREVENT_LENGTHY_EXTRUDE) #if EITHER(PREVENT_COLD_EXTRUSION, PREVENT_LENGTHY_EXTRUDE)
@ -2633,7 +2633,7 @@ bool Planner::buffer_segment(const float &a, const float &b, const float &c, con
//*/ //*/
// Queue the movement // Queue the movement
if ( if (
!_buffer_steps(target !_buffer_steps(target
#if HAS_POSITION_FLOAT #if HAS_POSITION_FLOAT
, target_float , target_float

6
Marlin/src/module/planner.h
View file

@ -507,8 +507,7 @@ class Planner {
skew(pos); skew(pos);
#endif #endif
#if HAS_LEVELING #if HAS_LEVELING
if (leveling) if (leveling) apply_leveling(pos);
apply_leveling(pos);
#endif #endif
#if ENABLED(FWRETRACT) #if ENABLED(FWRETRACT)
apply_retract(pos); apply_retract(pos);
@ -529,8 +528,7 @@ class Planner {
unapply_retract(pos); unapply_retract(pos);
#endif #endif
#if HAS_LEVELING #if HAS_LEVELING
if (leveling) if (leveling) unapply_leveling(pos);
unapply_leveling(pos);
#endif #endif
#if ENABLED(SKEW_CORRECTION) #if ENABLED(SKEW_CORRECTION)
unskew(pos); unskew(pos);

132
Marlin/src/module/probe.cpp
View file

@ -155,167 +155,77 @@ float zprobe_zoffset; // Initialized by settings.load()
#elif ENABLED(Z_PROBE_ALLEN_KEY) #elif ENABLED(Z_PROBE_ALLEN_KEY)
void run_deploy_moves_script() { void run_deploy_moves_script() {
#if defined(Z_PROBE_ALLEN_KEY_DEPLOY_1_X) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_1_Y) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_1_Z) #ifdef Z_PROBE_ALLEN_KEY_DEPLOY_1
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_1_X
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X current_position[X_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_1_Y
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y current_position[Y_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_1_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z current_position[Z_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE #ifndef Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE 0.0
#endif #endif
const float deploy_1[] = { Z_PROBE_ALLEN_KEY_DEPLOY_1_X, Z_PROBE_ALLEN_KEY_DEPLOY_1_Y, Z_PROBE_ALLEN_KEY_DEPLOY_1_Z }; constexpr float deploy_1[] = Z_PROBE_ALLEN_KEY_DEPLOY_1;
do_blocking_move_to(deploy_1, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE)); do_blocking_move_to(deploy_1, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE));
#endif #endif
#if defined(Z_PROBE_ALLEN_KEY_DEPLOY_2_X) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_2_Y) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_2_Z) #ifdef Z_PROBE_ALLEN_KEY_DEPLOY_2
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_2_X
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X current_position[X_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_2_Y
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y current_position[Y_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z current_position[Z_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE #ifndef Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE 0.0
#endif #endif
const float deploy_2[] = { Z_PROBE_ALLEN_KEY_DEPLOY_2_X, Z_PROBE_ALLEN_KEY_DEPLOY_2_Y, Z_PROBE_ALLEN_KEY_DEPLOY_2_Z }; constexpr float deploy_2[] = Z_PROBE_ALLEN_KEY_DEPLOY_2;
do_blocking_move_to(deploy_2, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE)); do_blocking_move_to(deploy_2, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE));
#endif #endif
#if defined(Z_PROBE_ALLEN_KEY_DEPLOY_3_X) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_3_Y) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_3_Z) #ifdef Z_PROBE_ALLEN_KEY_DEPLOY_3
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_3_X
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X current_position[X_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_3_Y
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y current_position[Y_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_3_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z current_position[Z_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE #ifndef Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE 0.0
#endif #endif
const float deploy_3[] = { Z_PROBE_ALLEN_KEY_DEPLOY_3_X, Z_PROBE_ALLEN_KEY_DEPLOY_3_Y, Z_PROBE_ALLEN_KEY_DEPLOY_3_Z }; constexpr float deploy_3[] = Z_PROBE_ALLEN_KEY_DEPLOY_3;
do_blocking_move_to(deploy_3, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE)); do_blocking_move_to(deploy_3, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE));
#endif #endif
#if defined(Z_PROBE_ALLEN_KEY_DEPLOY_4_X) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_4_Y) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_4_Z) #ifdef Z_PROBE_ALLEN_KEY_DEPLOY_4
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_4_X
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_X current_position[X_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_4_Y
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_Y current_position[Y_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_4_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_Z current_position[Z_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE #ifndef Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE 0.0
#endif #endif
const float deploy_4[] = { Z_PROBE_ALLEN_KEY_DEPLOY_4_X, Z_PROBE_ALLEN_KEY_DEPLOY_4_Y, Z_PROBE_ALLEN_KEY_DEPLOY_4_Z }; constexpr float deploy_4[] = Z_PROBE_ALLEN_KEY_DEPLOY_4;
do_blocking_move_to(deploy_4, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE)); do_blocking_move_to(deploy_4, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE));
#endif #endif
#if defined(Z_PROBE_ALLEN_KEY_DEPLOY_5_X) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_5_Y) || defined(Z_PROBE_ALLEN_KEY_DEPLOY_5_Z) #ifdef Z_PROBE_ALLEN_KEY_DEPLOY_5
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_5_X
#define Z_PROBE_ALLEN_KEY_DEPLOY_5_X current_position[X_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_5_Y
#define Z_PROBE_ALLEN_KEY_DEPLOY_5_Y current_position[Y_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_5_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_5_Z current_position[Z_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_DEPLOY_5_FEEDRATE #ifndef Z_PROBE_ALLEN_KEY_DEPLOY_5_FEEDRATE
#define Z_PROBE_ALLEN_KEY_DEPLOY_5_FEEDRATE 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_5_FEEDRATE 0.0
#endif #endif
const float deploy_5[] = { Z_PROBE_ALLEN_KEY_DEPLOY_5_X, Z_PROBE_ALLEN_KEY_DEPLOY_5_Y, Z_PROBE_ALLEN_KEY_DEPLOY_5_Z }; constexpr float deploy_5[] = Z_PROBE_ALLEN_KEY_DEPLOY_5;
do_blocking_move_to(deploy_5, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_5_FEEDRATE)); do_blocking_move_to(deploy_5, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_DEPLOY_5_FEEDRATE));
#endif #endif
} }
void run_stow_moves_script() { void run_stow_moves_script() {
#if defined(Z_PROBE_ALLEN_KEY_STOW_1_X) || defined(Z_PROBE_ALLEN_KEY_STOW_1_Y) || defined(Z_PROBE_ALLEN_KEY_STOW_1_Z) #ifdef Z_PROBE_ALLEN_KEY_STOW_1
#ifndef Z_PROBE_ALLEN_KEY_STOW_1_X
#define Z_PROBE_ALLEN_KEY_STOW_1_X current_position[X_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_1_Y
#define Z_PROBE_ALLEN_KEY_STOW_1_Y current_position[Y_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_1_Z
#define Z_PROBE_ALLEN_KEY_STOW_1_Z current_position[Z_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE #ifndef Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE 0.0 #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE 0.0
#endif #endif
const float stow_1[] = { Z_PROBE_ALLEN_KEY_STOW_1_X, Z_PROBE_ALLEN_KEY_STOW_1_Y, Z_PROBE_ALLEN_KEY_STOW_1_Z }; constexpr float stow_1[] = Z_PROBE_ALLEN_KEY_STOW_1;
do_blocking_move_to(stow_1, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE)); do_blocking_move_to(stow_1, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE));
#endif #endif
#if defined(Z_PROBE_ALLEN_KEY_STOW_2_X) || defined(Z_PROBE_ALLEN_KEY_STOW_2_Y) || defined(Z_PROBE_ALLEN_KEY_STOW_2_Z) #ifdef Z_PROBE_ALLEN_KEY_STOW_2
#ifndef Z_PROBE_ALLEN_KEY_STOW_2_X
#define Z_PROBE_ALLEN_KEY_STOW_2_X current_position[X_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_2_Y
#define Z_PROBE_ALLEN_KEY_STOW_2_Y current_position[Y_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_2_Z
#define Z_PROBE_ALLEN_KEY_STOW_2_Z current_position[Z_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE #ifndef Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE 0.0 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE 0.0
#endif #endif
const float stow_2[] = { Z_PROBE_ALLEN_KEY_STOW_2_X, Z_PROBE_ALLEN_KEY_STOW_2_Y, Z_PROBE_ALLEN_KEY_STOW_2_Z }; constexpr float stow_2[] = Z_PROBE_ALLEN_KEY_STOW_2;
do_blocking_move_to(stow_2, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE)); do_blocking_move_to(stow_2, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE));
#endif #endif
#if defined(Z_PROBE_ALLEN_KEY_STOW_3_X) || defined(Z_PROBE_ALLEN_KEY_STOW_3_Y) || defined(Z_PROBE_ALLEN_KEY_STOW_3_Z) #ifdef Z_PROBE_ALLEN_KEY_STOW_3
#ifndef Z_PROBE_ALLEN_KEY_STOW_3_X
#define Z_PROBE_ALLEN_KEY_STOW_3_X current_position[X_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_3_Y
#define Z_PROBE_ALLEN_KEY_STOW_3_Y current_position[Y_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_3_Z current_position[Z_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE #ifndef Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE 0.0 #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE 0.0
#endif #endif
const float stow_3[] = { Z_PROBE_ALLEN_KEY_STOW_3_X, Z_PROBE_ALLEN_KEY_STOW_3_Y, Z_PROBE_ALLEN_KEY_STOW_3_Z }; constexpr float stow_3[] = Z_PROBE_ALLEN_KEY_STOW_3;
do_blocking_move_to(stow_3, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE)); do_blocking_move_to(stow_3, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE));
#endif #endif
#if defined(Z_PROBE_ALLEN_KEY_STOW_4_X) || defined(Z_PROBE_ALLEN_KEY_STOW_4_Y) || defined(Z_PROBE_ALLEN_KEY_STOW_4_Z) #ifdef Z_PROBE_ALLEN_KEY_STOW_4
#ifndef Z_PROBE_ALLEN_KEY_STOW_4_X
#define Z_PROBE_ALLEN_KEY_STOW_4_X current_position[X_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_4_Y
#define Z_PROBE_ALLEN_KEY_STOW_4_Y current_position[Y_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_4_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_Z current_position[Z_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE #ifndef Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE 0.0
#endif #endif
const float stow_4[] = { Z_PROBE_ALLEN_KEY_STOW_4_X, Z_PROBE_ALLEN_KEY_STOW_4_Y, Z_PROBE_ALLEN_KEY_STOW_4_Z }; constexpr float stow_4[] = Z_PROBE_ALLEN_KEY_STOW_4;
do_blocking_move_to(stow_4, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE)); do_blocking_move_to(stow_4, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE));
#endif #endif
#if defined(Z_PROBE_ALLEN_KEY_STOW_5_X) || defined(Z_PROBE_ALLEN_KEY_STOW_5_Y) || defined(Z_PROBE_ALLEN_KEY_STOW_5_Z) #ifdef Z_PROBE_ALLEN_KEY_STOW_5
#ifndef Z_PROBE_ALLEN_KEY_STOW_5_X
#define Z_PROBE_ALLEN_KEY_STOW_5_X current_position[X_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_5_Y
#define Z_PROBE_ALLEN_KEY_STOW_5_Y current_position[Y_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_5_Z
#define Z_PROBE_ALLEN_KEY_STOW_5_Z current_position[Z_AXIS]
#endif
#ifndef Z_PROBE_ALLEN_KEY_STOW_5_FEEDRATE #ifndef Z_PROBE_ALLEN_KEY_STOW_5_FEEDRATE
#define Z_PROBE_ALLEN_KEY_STOW_5_FEEDRATE 0.0 #define Z_PROBE_ALLEN_KEY_STOW_5_FEEDRATE 0.0
#endif #endif
const float stow_5[] = { Z_PROBE_ALLEN_KEY_STOW_5_X, Z_PROBE_ALLEN_KEY_STOW_5_Y, Z_PROBE_ALLEN_KEY_STOW_5_Z }; constexpr float stow_5[] = Z_PROBE_ALLEN_KEY_STOW_5;
do_blocking_move_to(stow_5, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_5_FEEDRATE)); do_blocking_move_to(stow_5, MMM_TO_MMS(Z_PROBE_ALLEN_KEY_STOW_5_FEEDRATE));
#endif #endif
} }
@ -741,7 +651,7 @@ static float run_z_probe() {
#endif #endif
const float measured_z = probes_total * (1.0f / (MULTIPLE_PROBING)); const float measured_z = probes_total * RECIPROCAL(MULTIPLE_PROBING);
#elif TOTAL_PROBING == 2 #elif TOTAL_PROBING == 2

39
Marlin/src/module/stepper.cpp
View file

@ -174,8 +174,8 @@ int32_t Stepper::delta_error[XYZE] = { 0 };
uint32_t Stepper::advance_dividend[XYZE] = { 0 }, uint32_t Stepper::advance_dividend[XYZE] = { 0 },
Stepper::advance_divisor = 0, Stepper::advance_divisor = 0,
Stepper::step_events_completed = 0, // The number of step events executed in the current block Stepper::step_events_completed = 0, // The number of step events executed in the current block
Stepper::accelerate_until, // The point from where we need to stop acceleration Stepper::accelerate_until, // The count at which to stop accelerating
Stepper::decelerate_after, // The point from where we need to start decelerating Stepper::decelerate_after, // The count at which to start decelerating
Stepper::step_event_count; // The total event count for the current block Stepper::step_event_count; // The total event count for the current block
#if EXTRUDERS > 1 || ENABLED(MIXING_EXTRUDER) #if EXTRUDERS > 1 || ENABLED(MIXING_EXTRUDER)
@ -2239,19 +2239,16 @@ void Stepper::endstop_triggered(const AxisEnum axis) {
const bool was_enabled = STEPPER_ISR_ENABLED(); const bool was_enabled = STEPPER_ISR_ENABLED();
if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT(); if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
endstops_trigsteps[axis] = (
#if IS_CORE #if IS_CORE
(axis == CORE_AXIS_2
endstops_trigsteps[axis] = 0.5f * ( ? CORESIGN(count_position[CORE_AXIS_1] - count_position[CORE_AXIS_2])
axis == CORE_AXIS_2 ? CORESIGN(count_position[CORE_AXIS_1] - count_position[CORE_AXIS_2]) : count_position[CORE_AXIS_1] + count_position[CORE_AXIS_2]
: count_position[CORE_AXIS_1] + count_position[CORE_AXIS_2] ) * 0.5f
); #else // !IS_CORE
count_position[axis]
#else // !COREXY && !COREXZ && !COREYZ #endif
);
endstops_trigsteps[axis] = count_position[axis];
#endif // !COREXY && !COREXZ && !COREYZ
// Discard the rest of the move if there is a current block // Discard the rest of the move if there is a current block
quick_stop(); quick_stop();
@ -2279,15 +2276,19 @@ int32_t Stepper::triggered_position(const AxisEnum axis) {
void Stepper::report_positions() { void Stepper::report_positions() {
// Protect the access to the position. #ifdef __AVR__
const bool was_enabled = STEPPER_ISR_ENABLED(); // Protect the access to the position.
if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT(); const bool was_enabled = STEPPER_ISR_ENABLED();
if (was_enabled) DISABLE_STEPPER_DRIVER_INTERRUPT();
#endif
const int32_t xpos = count_position[X_AXIS], const int32_t xpos = count_position[X_AXIS],
ypos = count_position[Y_AXIS], ypos = count_position[Y_AXIS],
zpos = count_position[Z_AXIS]; zpos = count_position[Z_AXIS];
if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT(); #ifdef __AVR__
if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
#endif
#if CORE_IS_XY || CORE_IS_XZ || ENABLED(DELTA) || IS_SCARA #if CORE_IS_XY || CORE_IS_XZ || ENABLED(DELTA) || IS_SCARA
SERIAL_ECHOPGM(MSG_COUNT_A); SERIAL_ECHOPGM(MSG_COUNT_A);

3
Marlin/src/module/stepper.h
View file

@ -321,6 +321,9 @@ class Stepper {
static uint32_t acc_step_rate; // needed for deceleration start point static uint32_t acc_step_rate; // needed for deceleration start point
#endif #endif
//
// Exact steps at which an endstop was triggered
//
static volatile int32_t endstops_trigsteps[XYZ]; static volatile int32_t endstops_trigsteps[XYZ];
// //

25
Marlin/src/module/temperature.cpp
View file

@ -1320,13 +1320,14 @@ void Temperature::manage_heater() {
if (!WITHIN(t_index, 0, COUNT(user_thermistor) - 1)) return 25; if (!WITHIN(t_index, 0, COUNT(user_thermistor) - 1)) return 25;
if (user_thermistor[t_index].pre_calc) { user_thermistor_t &t = user_thermistor[t_index];
// pre-calculate some variables if (t.pre_calc) { // pre-calculate some variables
user_thermistor[t_index].pre_calc = false; t.pre_calc = false;
user_thermistor[t_index].res_25_recip = 1.0f / user_thermistor[t_index].res_25; t.res_25_recip = 1.0f / t.res_25;
user_thermistor[t_index].res_25_log = logf(user_thermistor[t_index].res_25); t.res_25_log = logf(t.res_25);
user_thermistor[t_index].beta_recip = 1.0f / user_thermistor[t_index].beta; t.beta_recip = 1.0f / t.beta;
user_thermistor[t_index].sh_alpha = (1.0f / (THERMISTOR_RESISTANCE_NOMINAL_C - THERMISTOR_ABS_ZERO_C)) - (user_thermistor[t_index].beta_recip * user_thermistor[t_index].res_25_log) - (user_thermistor[t_index].sh_c_coeff * user_thermistor[t_index].res_25_log * user_thermistor[t_index].res_25_log * user_thermistor[t_index].res_25_log); t.sh_alpha = RECIPROCAL(THERMISTOR_RESISTANCE_NOMINAL_C - (THERMISTOR_ABS_ZERO_C))
- (t.beta_recip * t.res_25_log) - (t.sh_c_coeff * cu(t.res_25_log));
} }
// maximum adc value .. take into account the over sampling // maximum adc value .. take into account the over sampling
@ -1334,13 +1335,13 @@ void Temperature::manage_heater() {
adc_raw = constrain(raw, 1, adc_max - 1); // constrain to prevent divide-by-zero adc_raw = constrain(raw, 1, adc_max - 1); // constrain to prevent divide-by-zero
const float adc_inverse = (adc_max - adc_raw) - 0.5f, const float adc_inverse = (adc_max - adc_raw) - 0.5f,
resistance = user_thermistor[t_index].series_res * (adc_raw + 0.5f) / adc_inverse, resistance = t.series_res * (adc_raw + 0.5f) / adc_inverse,
log_resistance = logf(resistance); log_resistance = logf(resistance);
float value = user_thermistor[t_index].sh_alpha; float value = t.sh_alpha;
value += log_resistance * user_thermistor[t_index].beta_recip; value += log_resistance * t.beta_recip;
if (user_thermistor[t_index].sh_c_coeff != 0) if (t.sh_c_coeff != 0)
value += user_thermistor[t_index].sh_c_coeff * log_resistance * log_resistance * log_resistance; value += t.sh_c_coeff * cu(log_resistance);
value = 1.0f / value; value = 1.0f / value;
//#if (MOTHERBOARD == BOARD_RAMPS_14_EFB) //#if (MOTHERBOARD == BOARD_RAMPS_14_EFB)

57
Marlin/src/module/tool_change.cpp
View file

@ -133,9 +133,11 @@
#endif // SWITCHING_NOZZLE #endif // SWITCHING_NOZZLE
inline void fast_line_to_current(const AxisEnum fr_axis) { inline void _line_to_current(const AxisEnum fr_axis, const float fscale=1.0f) {
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[fr_axis], active_extruder); planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[fr_axis] * fscale, active_extruder);
} }
inline void slow_line_to_current(const AxisEnum fr_axis) { _line_to_current(fr_axis, 0.5f); }
inline void fast_line_to_current(const AxisEnum fr_axis) { _line_to_current(fr_axis); }
#if ENABLED(MAGNETIC_PARKING_EXTRUDER) #if ENABLED(MAGNETIC_PARKING_EXTRUDER)
@ -150,13 +152,11 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
const float oldx = current_position[X_AXIS], const float oldx = current_position[X_AXIS],
grabpos = mpe_settings.parking_xpos[new_tool] + (new_tool ? mpe_settings.grab_distance : -mpe_settings.grab_distance), grabpos = mpe_settings.parking_xpos[new_tool] + (new_tool ? mpe_settings.grab_distance : -mpe_settings.grab_distance),
offsetcompensation = offsetcompensation = (0
#if HAS_HOTEND_OFFSET #if HAS_HOTEND_OFFSET
hotend_offset[X_AXIS][active_extruder] * mpe_settings.compensation_factor + hotend_offset[X_AXIS][active_extruder] * mpe_settings.compensation_factor
#else
0
#endif #endif
; );
if (axis_unhomed_error(true, false, false)) return; if (axis_unhomed_error(true, false, false)) return;
@ -337,7 +337,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
planner.synchronize(); planner.synchronize();
DEBUG_POS("(5) Unpark extruder", current_position); DEBUG_POS("(5) Unpark extruder", current_position);
} }
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[X_AXIS] * 0.5, active_extruder); slow_line_to_current(X_AXIS);
// STEP 6 // STEP 6
@ -411,7 +411,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
current_position[Y_AXIS] = SWITCHING_TOOLHEAD_Y_POS; current_position[Y_AXIS] = SWITCHING_TOOLHEAD_Y_POS;
if (DEBUGGING(LEVELING)) DEBUG_POS("Move Y SwitchPos", current_position); if (DEBUGGING(LEVELING)) DEBUG_POS("Move Y SwitchPos", current_position);
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[Y_AXIS] * 0.5f, active_extruder); slow_line_to_current(Y_AXIS);
// Wait for move to complete, then another 0.2s // Wait for move to complete, then another 0.2s
planner.synchronize(); planner.synchronize();
@ -446,7 +446,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
DEBUG_ECHOLNPGM("(4) Grab and lock new toolhead"); DEBUG_ECHOLNPGM("(4) Grab and lock new toolhead");
DEBUG_POS("Move Y SwitchPos", current_position); DEBUG_POS("Move Y SwitchPos", current_position);
} }
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[Y_AXIS] * 0.5, active_extruder); slow_line_to_current(Y_AXIS);
// Wait for move to finish, pause 0.2s, move servo, pause 0.5s // Wait for move to finish, pause 0.2s, move servo, pause 0.5s
planner.synchronize(); planner.synchronize();
@ -491,21 +491,21 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
SERIAL_ECHOLNPAIR("(1) Place old tool ", int(active_extruder)); SERIAL_ECHOLNPAIR("(1) Place old tool ", int(active_extruder));
DEBUG_POS("Move Y SwitchPos + Security", current_position); DEBUG_POS("Move Y SwitchPos + Security", current_position);
} }
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[Y_AXIS], active_extruder); fast_line_to_current(Y_AXIS);
current_position[X_AXIS] = placexclear; current_position[X_AXIS] = placexclear;
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
planner.synchronize(); planner.synchronize();
DEBUG_POS("Move X SwitchPos + Security", current_position); DEBUG_POS("Move X SwitchPos + Security", current_position);
} }
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[X_AXIS], active_extruder); fast_line_to_current(X_AXIS);
current_position[Y_AXIS] = SWITCHING_TOOLHEAD_Y_POS; current_position[Y_AXIS] = SWITCHING_TOOLHEAD_Y_POS;
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
planner.synchronize(); planner.synchronize();
DEBUG_POS("Move Y SwitchPos", current_position); DEBUG_POS("Move Y SwitchPos", current_position);
} }
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[Y_AXIS], active_extruder); fast_line_to_current(Y_AXIS);
current_position[X_AXIS] = placexpos; current_position[X_AXIS] = placexpos;
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
@ -541,7 +541,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
current_position[X_AXIS] = grabxpos; current_position[X_AXIS] = grabxpos;
if (DEBUGGING(LEVELING)) DEBUG_POS("Move to new toolhead X", current_position); if (DEBUGGING(LEVELING)) DEBUG_POS("Move to new toolhead X", current_position);
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[X_AXIS], active_extruder); fast_line_to_current(X_AXIS);
// 4. Grab the new toolhead and move to security position // 4. Grab the new toolhead and move to security position
@ -559,7 +559,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
planner.synchronize(); planner.synchronize();
DEBUG_POS("Move Y SwitchPos", current_position); DEBUG_POS("Move Y SwitchPos", current_position);
} }
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[Y_AXIS] * 0.2, active_extruder); _line_to_current(Y_AXIS, 0.2f);
#if ENABLED(PRIME_BEFORE_REMOVE) && (SWITCHING_TOOLHEAD_PRIME_MM || SWITCHING_TOOLHEAD_RETRACT_MM) #if ENABLED(PRIME_BEFORE_REMOVE) && (SWITCHING_TOOLHEAD_PRIME_MM || SWITCHING_TOOLHEAD_RETRACT_MM)
#if SWITCHING_TOOLHEAD_PRIME_MM #if SWITCHING_TOOLHEAD_PRIME_MM
@ -577,13 +577,13 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
current_position[X_AXIS] = grabxclear; current_position[X_AXIS] = grabxclear;
if (DEBUGGING(LEVELING)) DEBUG_POS("Move to new toolhead X + Security", current_position); if (DEBUGGING(LEVELING)) DEBUG_POS("Move to new toolhead X + Security", current_position);
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[X_AXIS] * 0.1, active_extruder); _line_to_current(X_AXIS, 0.1f);
planner.synchronize(); planner.synchronize();
safe_delay(100); // Give switch time to settle safe_delay(100); // Give switch time to settle
current_position[Y_AXIS] += SWITCHING_TOOLHEAD_Y_CLEAR; current_position[Y_AXIS] += SWITCHING_TOOLHEAD_Y_CLEAR;
if (DEBUGGING(LEVELING)) DEBUG_POS("Move back Y clear", current_position); if (DEBUGGING(LEVELING)) DEBUG_POS("Move back Y clear", current_position);
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[Y_AXIS], active_extruder); // move away from docked toolhead fast_line_to_current(Y_AXIS); // move away from docked toolhead
planner.synchronize(); // Always sync last tool-change move planner.synchronize(); // Always sync last tool-change move
if (DEBUGGING(LEVELING)) DEBUG_POS("MST Tool-Change done.", current_position); if (DEBUGGING(LEVELING)) DEBUG_POS("MST Tool-Change done.", current_position);
@ -620,7 +620,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
current_position[Z_AXIS] += SWITCHING_TOOLHEAD_Z_HOP; current_position[Z_AXIS] += SWITCHING_TOOLHEAD_Z_HOP;
if (DEBUGGING(LEVELING)) DEBUG_POS("(1) Raise Z-Axis ", current_position); if (DEBUGGING(LEVELING)) DEBUG_POS("(1) Raise Z-Axis ", current_position);
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[Z_AXIS], active_extruder); fast_line_to_current(Z_AXIS);
// 2. Move to position near active extruder parking // 2. Move to position near active extruder parking
@ -629,9 +629,9 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
SERIAL_ECHOLNPAIR("(2) Move near active extruder parking", active_extruder); SERIAL_ECHOLNPAIR("(2) Move near active extruder parking", active_extruder);
DEBUG_POS("Moving ParkPos", current_position); DEBUG_POS("Moving ParkPos", current_position);
} }
current_position[X_AXIS] = placexpos + hotend_offset[X_AXIS][active_extruder]; current_position[X_AXIS] = hotend_offset[X_AXIS][active_extruder] + placexpos;
current_position[Y_AXIS] = SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_CLEAR + hotend_offset[Y_AXIS][active_extruder]; current_position[Y_AXIS] = hotend_offset[Y_AXIS][active_extruder] + SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_CLEAR;
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[X_AXIS], active_extruder); fast_line_to_current(X_AXIS);
// 3. Move gently to park position of active extruder // 3. Move gently to park position of active extruder
@ -642,7 +642,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
} }
current_position[Y_AXIS] -= SWITCHING_TOOLHEAD_Y_CLEAR; current_position[Y_AXIS] -= SWITCHING_TOOLHEAD_Y_CLEAR;
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[Y_AXIS] * 0.5, active_extruder); slow_line_to_current(Y_AXIS);
// 4. Disengage magnetic field, wait for delay // 4. Disengage magnetic field, wait for delay
@ -658,10 +658,11 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
} }
current_position[Y_AXIS] += SWITCHING_TOOLHEAD_Y_CLEAR; current_position[Y_AXIS] += SWITCHING_TOOLHEAD_Y_CLEAR;
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[Y_AXIS] * 0.5f, active_extruder); slow_line_to_current(Y_AXIS);
current_position[X_AXIS] = grabxpos + hotend_offset[X_AXIS][active_extruder];
current_position[Y_AXIS] = SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_CLEAR + hotend_offset[Y_AXIS][active_extruder]; current_position[X_AXIS] = hotend_offset[X_AXIS][active_extruder] + grabxpos;
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[X_AXIS], active_extruder); current_position[Y_AXIS] = hotend_offset[Y_AXIS][active_extruder] + SWITCHING_TOOLHEAD_Y_POS + SWITCHING_TOOLHEAD_Y_CLEAR;
fast_line_to_current(X_AXIS);
// 6. Move gently to park position of new extruder // 6. Move gently to park position of new extruder
@ -670,7 +671,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
planner.synchronize(); planner.synchronize();
DEBUG_ECHOLNPGM("(6) Move near new extruder"); DEBUG_ECHOLNPGM("(6) Move near new extruder");
} }
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[Y_AXIS] * 0.5f, active_extruder); slow_line_to_current(Y_AXIS);
// 7. Engage magnetic field for new extruder parking // 7. Engage magnetic field for new extruder parking
@ -682,7 +683,7 @@ inline void fast_line_to_current(const AxisEnum fr_axis) {
current_position[Y_AXIS] += SWITCHING_TOOLHEAD_Y_CLEAR; current_position[Y_AXIS] += SWITCHING_TOOLHEAD_Y_CLEAR;
if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("(8) Unpark extruder"); if (DEBUGGING(LEVELING)) DEBUG_ECHOLNPGM("(8) Unpark extruder");
planner.buffer_line(current_position, planner.settings.max_feedrate_mm_s[X_AXIS] * 0.5f, active_extruder); slow_line_to_current(X_AXIS);
planner.synchronize(); // Always sync the final move planner.synchronize(); // Always sync the final move
// 9. Apply Z hotend offset to current position // 9. Apply Z hotend offset to current position

28
config/examples/delta/Anycubic/Kossel/Configuration.h
View file

@ -1028,39 +1028,25 @@
// 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29, // 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29,
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_2_X -64.0 // Push it down #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 3.0 } // Push it down
#define Z_PROBE_ALLEN_KEY_STOW_2_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_2_Z 3.0
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_3_X -64.0 // Move it up to clear #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 50.0 } // Move it up to clear
#define Z_PROBE_ALLEN_KEY_STOW_3_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_3_Z 50.0
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 50.0 }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

28
config/examples/delta/Dreammaker/Overlord/Configuration.h
View file

@ -973,39 +973,25 @@
// 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29, // 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29,
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_2_X -64.0 // Push it down #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 3.0 } // Push it down
#define Z_PROBE_ALLEN_KEY_STOW_2_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_2_Z 3.0
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_3_X -64.0 // Move it up to clear #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 50.0 } // Move it up to clear
#define Z_PROBE_ALLEN_KEY_STOW_3_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_3_Z 50.0
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 50.0 }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

28
config/examples/delta/Dreammaker/Overlord_Pro/Configuration.h
View file

@ -985,39 +985,25 @@
// 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29, // 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29,
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_2_X -64.0 // Push it down #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 3.0 } // Push it down
#define Z_PROBE_ALLEN_KEY_STOW_2_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_2_Z 3.0
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_3_X -64.0 // Move it up to clear #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 50.0 } // Move it up to clear
#define Z_PROBE_ALLEN_KEY_STOW_3_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_3_Z 50.0
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 50.0 }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

32
config/examples/delta/FLSUN/auto_calibrate/Configuration.h
View file

@ -975,41 +975,27 @@
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
// Kossel Mini // Kossel Mini
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_DEPTH 20 #define Z_PROBE_ALLEN_KEY_STOW_DEPTH 20
// Move the probe into position // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 }
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
// Move the nozzle down further to push the probe into retracted position. // Move the nozzle down further to push the probe into retracted position.
#define Z_PROBE_ALLEN_KEY_STOW_2_X Z_PROBE_ALLEN_KEY_STOW_1_X #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 23.0-(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_2_Y Z_PROBE_ALLEN_KEY_STOW_1_Y #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_2_Z (Z_PROBE_ALLEN_KEY_STOW_1_Z-Z_PROBE_ALLEN_KEY_STOW_DEPTH)
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED/10)
// Raise things back up slightly so we don't bump into anything // Raise things back up slightly so we don't bump into anything
#define Z_PROBE_ALLEN_KEY_STOW_3_X Z_PROBE_ALLEN_KEY_STOW_2_X #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 23.0+(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_3_Y Z_PROBE_ALLEN_KEY_STOW_2_Y #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE (XY_PROBE_SPEED)/2
#define Z_PROBE_ALLEN_KEY_STOW_3_Z (Z_PROBE_ALLEN_KEY_STOW_1_Z+Z_PROBE_ALLEN_KEY_STOW_DEPTH)
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE (XY_PROBE_SPEED/2)
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 23.0+(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

32
config/examples/delta/FLSUN/kossel/Configuration.h
View file

@ -975,40 +975,26 @@
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
// Kossel Mini // Kossel Mini
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_DEPTH 20 #define Z_PROBE_ALLEN_KEY_STOW_DEPTH 20
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
// Move the nozzle down further to push the probe into retracted position. // Move the nozzle down further to push the probe into retracted position.
#define Z_PROBE_ALLEN_KEY_STOW_2_X Z_PROBE_ALLEN_KEY_STOW_1_X #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 23.0-(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_2_Y Z_PROBE_ALLEN_KEY_STOW_1_Y #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_2_Z (Z_PROBE_ALLEN_KEY_STOW_1_Z-Z_PROBE_ALLEN_KEY_STOW_DEPTH)
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED/10)
// Raise things back up slightly so we don't bump into anything // Raise things back up slightly so we don't bump into anything
#define Z_PROBE_ALLEN_KEY_STOW_3_X Z_PROBE_ALLEN_KEY_STOW_2_X #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 23.0+(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_3_Y Z_PROBE_ALLEN_KEY_STOW_2_Y #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE (XY_PROBE_SPEED)/2
#define Z_PROBE_ALLEN_KEY_STOW_3_Z (Z_PROBE_ALLEN_KEY_STOW_1_Z+Z_PROBE_ALLEN_KEY_STOW_DEPTH)
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE (XY_PROBE_SPEED/2)
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 23.0+(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

34
config/examples/delta/FLSUN/kossel_mini/Configuration.h
View file

@ -975,40 +975,26 @@
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
// Kossel Mini // Kossel Mini
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED/10)
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_DEPTH 20 #define Z_PROBE_ALLEN_KEY_STOW_DEPTH 20
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
// Move the nozzle down further to push the probe into retracted position. // Move the nozzle down further to push the probe into retracted position.
#define Z_PROBE_ALLEN_KEY_STOW_2_X Z_PROBE_ALLEN_KEY_STOW_1_X #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 23.0-(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_2_Y Z_PROBE_ALLEN_KEY_STOW_1_Y #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_2_Z (Z_PROBE_ALLEN_KEY_STOW_1_Z-Z_PROBE_ALLEN_KEY_STOW_DEPTH)
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED/10)
// Raise things back up slightly so we don't bump into anything // Raise things back up slightly so we don't bump into anything
#define Z_PROBE_ALLEN_KEY_STOW_3_X Z_PROBE_ALLEN_KEY_STOW_2_X #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 23.0+(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_3_Y Z_PROBE_ALLEN_KEY_STOW_2_Y #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE (XY_PROBE_SPEED)/2
#define Z_PROBE_ALLEN_KEY_STOW_3_Z (Z_PROBE_ALLEN_KEY_STOW_1_Z+Z_PROBE_ALLEN_KEY_STOW_DEPTH)
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE (XY_PROBE_SPEED/2)
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 23.0+(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

28
config/examples/delta/Geeetech/Rostock 301/Configuration.h
View file

@ -964,39 +964,25 @@
// 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29, // 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29,
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_2_X -64.0 // Push it down #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 3.0 } // Push it down
#define Z_PROBE_ALLEN_KEY_STOW_2_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_2_Z 3.0
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_3_X -64.0 // Move it up to clear #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 50.0 } // Move it up to clear
#define Z_PROBE_ALLEN_KEY_STOW_3_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_3_Z 50.0
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 50.0 }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

28
config/examples/delta/Hatchbox_Alpha/Configuration.h
View file

@ -979,39 +979,25 @@
// 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29, // 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29,
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_2_X -64.0 // Push it down #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 3.0 } // Push it down
#define Z_PROBE_ALLEN_KEY_STOW_2_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_2_Z 3.0
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_3_X -64.0 // Move it up to clear #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 50.0 } // Move it up to clear
#define Z_PROBE_ALLEN_KEY_STOW_3_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_3_Z 50.0
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 50.0 }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

28
config/examples/delta/MKS/SBASE/Configuration.h
View file

@ -964,39 +964,25 @@
// 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29, // 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29,
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_2_X -64.0 // Push it down #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 3.0 } // Push it down
#define Z_PROBE_ALLEN_KEY_STOW_2_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_2_Z 3.0
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_3_X -64.0 // Move it up to clear #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 50.0 } // Move it up to clear
#define Z_PROBE_ALLEN_KEY_STOW_3_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_3_Z 50.0
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 50.0 }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

28
config/examples/delta/Tevo Little Monster/Configuration.h
View file

@ -968,39 +968,25 @@
// 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29, // 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29,
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_2_X -64.0 // Push it down #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 3.0 } // Push it down
#define Z_PROBE_ALLEN_KEY_STOW_2_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_2_Z 3.0
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_3_X -64.0 // Move it up to clear #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 50.0 } // Move it up to clear
#define Z_PROBE_ALLEN_KEY_STOW_3_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_3_Z 50.0
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 50.0 }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

28
config/examples/delta/generic/Configuration.h
View file

@ -964,39 +964,25 @@
// 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29, // 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29,
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_2_X -64.0 // Push it down #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 3.0 } // Push it down
#define Z_PROBE_ALLEN_KEY_STOW_2_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_2_Z 3.0
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_3_X -64.0 // Move it up to clear #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 50.0 } // Move it up to clear
#define Z_PROBE_ALLEN_KEY_STOW_3_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_3_Z 50.0
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 50.0 }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

34
config/examples/delta/kossel_mini/Configuration.h
View file

@ -965,40 +965,26 @@
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
// Kossel Mini // Kossel Mini
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED/10)
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_DEPTH 20 #define Z_PROBE_ALLEN_KEY_STOW_DEPTH 20
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
// Move the nozzle down further to push the probe into retracted position. // Move the nozzle down further to push the probe into retracted position.
#define Z_PROBE_ALLEN_KEY_STOW_2_X Z_PROBE_ALLEN_KEY_STOW_1_X #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 23.0-(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_2_Y Z_PROBE_ALLEN_KEY_STOW_1_Y #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_2_Z (Z_PROBE_ALLEN_KEY_STOW_1_Z-Z_PROBE_ALLEN_KEY_STOW_DEPTH)
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED/10)
// Raise things back up slightly so we don't bump into anything // Raise things back up slightly so we don't bump into anything
#define Z_PROBE_ALLEN_KEY_STOW_3_X Z_PROBE_ALLEN_KEY_STOW_2_X #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 23.0+(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_3_Y Z_PROBE_ALLEN_KEY_STOW_2_Y #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE (XY_PROBE_SPEED)/2
#define Z_PROBE_ALLEN_KEY_STOW_3_Z (Z_PROBE_ALLEN_KEY_STOW_1_Z+Z_PROBE_ALLEN_KEY_STOW_DEPTH)
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE (XY_PROBE_SPEED/2)
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 23.0+(Z_PROBE_ALLEN_KEY_STOW_DEPTH) }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

32
config/examples/delta/kossel_pro/Configuration.h
View file

@ -958,44 +958,28 @@
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
// Kossel Pro // Kossel Pro
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X -105.00 // Move left but not quite so far that we'll bump the belt #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { -105.00, 0.00, 100.0 } // Move left but not quite so far that we'll bump the belt
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y 0.00
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X -110.00 // Move outward to position deploy pin to the left of the arm #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { -110.00, -125.00, 100.0 } // Move outward to position deploy pin to the left of the arm
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y -125.00
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z Z_PROBE_ALLEN_KEY_DEPLOY_1_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { -110.00 * 0.75, -125.00 * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_X 45.00 // Move right to trigger deploy pin #define Z_PROBE_ALLEN_KEY_DEPLOY_4 { 45.00, -125.00, 100.0 } // Move right to trigger deploy pin
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_Y -125.00
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_Z Z_PROBE_ALLEN_KEY_DEPLOY_3_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE (XY_PROBE_SPEED)/2 #define Z_PROBE_ALLEN_KEY_DEPLOY_4_FEEDRATE (XY_PROBE_SPEED)/2
#define Z_PROBE_ALLEN_KEY_STOW_1_X 36.00 // Line up with bed retaining clip #define Z_PROBE_ALLEN_KEY_STOW_1 { 36.00, -125.00, 75.0 } // Line up with bed retaining clip
#define Z_PROBE_ALLEN_KEY_STOW_1_Y -125.00
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 75.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_2_X Z_PROBE_ALLEN_KEY_STOW_1_X // move down to retract probe #define Z_PROBE_ALLEN_KEY_STOW_2 { 36.00, -125.00, 0.0 } // move down to retract probe
#define Z_PROBE_ALLEN_KEY_STOW_2_Y Z_PROBE_ALLEN_KEY_STOW_1_Y
#define Z_PROBE_ALLEN_KEY_STOW_2_Z 0.0
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/2 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/2
#define Z_PROBE_ALLEN_KEY_STOW_3_X 0.0 // return to 0,0,100 #define Z_PROBE_ALLEN_KEY_STOW_3 { 0.0, 0.0, 100.0 } // return to 0,0,100
#define Z_PROBE_ALLEN_KEY_STOW_3_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_3_Z 100.0
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 100.0 }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY

28
config/examples/delta/kossel_xl/Configuration.h
View file

@ -967,39 +967,25 @@
// 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29, // 2 or 3 sets of coordinates for deploying and retracting the spring loaded touch probe on G29,
// if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe. // if servo actuated touch probe is not defined. Uncomment as appropriate for your printer/probe.
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_X 30.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_1 { 30.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_X 0.0 #define Z_PROBE_ALLEN_KEY_DEPLOY_2 { 0.0, DELTA_PRINTABLE_RADIUS, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Y DELTA_PRINTABLE_RADIUS
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_Z 100.0
#define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_DEPLOY_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_X Z_PROBE_ALLEN_KEY_DEPLOY_2_X * 0.75 #define Z_PROBE_ALLEN_KEY_DEPLOY_3 { 0.0, (DELTA_PRINTABLE_RADIUS) * 0.75, 100.0 }
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Y Z_PROBE_ALLEN_KEY_DEPLOY_2_Y * 0.75
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_Z Z_PROBE_ALLEN_KEY_DEPLOY_2_Z
#define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_DEPLOY_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_1_X -64.0 // Move the probe into position #define Z_PROBE_ALLEN_KEY_STOW_1 { -64.0, 56.0, 23.0 } // Move the probe into position
#define Z_PROBE_ALLEN_KEY_STOW_1_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_1_Z 23.0
#define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_1_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_2_X -64.0 // Push it down #define Z_PROBE_ALLEN_KEY_STOW_2 { -64.0, 56.0, 3.0 } // Push it down
#define Z_PROBE_ALLEN_KEY_STOW_2_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_2_Z 3.0
#define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10 #define Z_PROBE_ALLEN_KEY_STOW_2_FEEDRATE (XY_PROBE_SPEED)/10
#define Z_PROBE_ALLEN_KEY_STOW_3_X -64.0 // Move it up to clear #define Z_PROBE_ALLEN_KEY_STOW_3 { -64.0, 56.0, 50.0 } // Move it up to clear
#define Z_PROBE_ALLEN_KEY_STOW_3_Y 56.0
#define Z_PROBE_ALLEN_KEY_STOW_3_Z 50.0
#define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_3_FEEDRATE XY_PROBE_SPEED
#define Z_PROBE_ALLEN_KEY_STOW_4_X 0.0 #define Z_PROBE_ALLEN_KEY_STOW_4 { 0.0, 0.0, 50.0 }
#define Z_PROBE_ALLEN_KEY_STOW_4_Y 0.0
#define Z_PROBE_ALLEN_KEY_STOW_4_Z Z_PROBE_ALLEN_KEY_STOW_3_Z
#define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED #define Z_PROBE_ALLEN_KEY_STOW_4_FEEDRATE XY_PROBE_SPEED
#endif // Z_PROBE_ALLEN_KEY #endif // Z_PROBE_ALLEN_KEY