3DPrinting/MarlinFirmware
1
0
Fork 0
mirror of https://github.com/MarlinFirmware/Marlin.git synced 2024-11-27 22:08:02 +00:00
Code Issues Releases Wiki Activity

Merge pull request #7011 from thinkyhead/bf_serial_macros

Browse Source 
Tweak serial macros
This commit is contained in:
Scott Lahteine 2017-06-09 17:58:20 -05:00 committed by GitHub
commit f4b76b1ee7
26 changed files with 444 additions and 450 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Marlin/G26_Mesh_Validation_Tool.cpp
View File

@ -288,7 +288,7 @@
SERIAL_ECHOPAIR(" Doing circle at: (xi=", xi); SERIAL_ECHOPAIR(" Doing circle at: (xi=", xi);
SERIAL_ECHOPAIR(", yi=", yi); SERIAL_ECHOPAIR(", yi=", yi);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
start_angle = 0.0; // assume it is going to be a full circle start_angle = 0.0; // assume it is going to be a full circle
@ -467,7 +467,7 @@
SERIAL_ECHOPAIR(") -> (ex=", ex); SERIAL_ECHOPAIR(") -> (ex=", ex);
SERIAL_ECHOPAIR(", ey=", ey); SERIAL_ECHOPAIR(", ey=", ey);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
//debug_current_and_destination(PSTR("Connecting horizontal line.")); //debug_current_and_destination(PSTR("Connecting horizontal line."));
} }
@ -501,7 +501,7 @@
SERIAL_ECHOPAIR(") -> (ex=", ex); SERIAL_ECHOPAIR(") -> (ex=", ex);
SERIAL_ECHOPAIR(", ey=", ey); SERIAL_ECHOPAIR(", ey=", ey);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
debug_current_and_destination(PSTR("Connecting vertical line.")); debug_current_and_destination(PSTR("Connecting vertical line."));
} }
print_line_from_here_to_there(LOGICAL_X_POSITION(sx), LOGICAL_Y_POSITION(sy), g26_layer_height, LOGICAL_X_POSITION(ex), LOGICAL_Y_POSITION(ey), g26_layer_height); print_line_from_here_to_there(LOGICAL_X_POSITION(sx), LOGICAL_Y_POSITION(sy), g26_layer_height, LOGICAL_X_POSITION(ex), LOGICAL_Y_POSITION(ey), g26_layer_height);

2
Marlin/I2CPositionEncoder.cpp
View File

@ -736,7 +736,7 @@
char c; char c;
while (Wire.available() > 0 && (c = (char)Wire.read()) > 0) while (Wire.available() > 0 && (c = (char)Wire.read()) > 0)
SERIAL_ECHO(c); SERIAL_ECHO(c);
SERIAL_EOL; SERIAL_EOL();
} }
// Set module back to normal (distance) mode // Set module back to normal (distance) mode

8
Marlin/M100_Free_Mem_Chk.cpp
View File

@ -130,7 +130,7 @@ int16_t count_test_bytes(const char * const ptr) {
} }
SERIAL_CHAR(ccc); SERIAL_CHAR(ccc);
} }
SERIAL_EOL; SERIAL_EOL();
ptr += 16; ptr += 16;
safe_delay(25); safe_delay(25);
idle(); idle();
@ -200,7 +200,7 @@ void free_memory_pool_report(char * const ptr, const int16_t size) {
*addr = i; *addr = i;
SERIAL_ECHOPAIR("\nCorrupting address: ", hex_address(addr)); SERIAL_ECHOPAIR("\nCorrupting address: ", hex_address(addr));
} }
SERIAL_EOL; SERIAL_EOL();
} }
} }
#endif // M100_FREE_MEMORY_CORRUPTOR #endif // M100_FREE_MEMORY_CORRUPTOR
@ -229,7 +229,7 @@ void init_free_memory(char *ptr, int16_t size) {
if (ptr[i] != TEST_BYTE) { if (ptr[i] != TEST_BYTE) {
SERIAL_ECHOPAIR("? address : ", hex_address(ptr + i)); SERIAL_ECHOPAIR("? address : ", hex_address(ptr + i));
SERIAL_ECHOLNPAIR("=", hex_byte(ptr[i])); SERIAL_ECHOLNPAIR("=", hex_byte(ptr[i]));
SERIAL_EOL; SERIAL_EOL();
} }
} }
} }
@ -323,7 +323,7 @@ int check_for_free_memory_corruption(const char * const title) {
SERIAL_ECHOPGM(" return="); SERIAL_ECHOPGM(" return=");
if (block_cnt == 1) { if (block_cnt == 1) {
SERIAL_CHAR('0'); // if the block_cnt is 1, nothing has broken up the free memory SERIAL_CHAR('0'); // if the block_cnt is 1, nothing has broken up the free memory
SERIAL_EOL; // area and it is appropriate to say 'no corruption'. SERIAL_EOL(); // area and it is appropriate to say 'no corruption'.
return 0; return 0;
} }
SERIAL_ECHOLNPGM("true"); SERIAL_ECHOLNPGM("true");

256
Marlin/Marlin_main.cpp
View File

@ -734,7 +734,7 @@ void report_current_position_detail();
SERIAL_CHAR(')'); SERIAL_CHAR(')');
if (suffix) {serialprintPGM(suffix);} //won't compile for Teensy with the previous construction if (suffix) {serialprintPGM(suffix);} //won't compile for Teensy with the previous construction
else SERIAL_EOL; else SERIAL_EOL();
} }
void print_xyz(const char* prefix, const char* suffix, const float xyz[]) { void print_xyz(const char* prefix, const char* suffix, const float xyz[]) {
@ -868,10 +868,10 @@ inline bool _enqueuecommand(const char* cmd, bool say_ok=false) {
*/ */
bool enqueue_and_echo_command(const char* cmd, bool say_ok/*=false*/) { bool enqueue_and_echo_command(const char* cmd, bool say_ok/*=false*/) {
if (_enqueuecommand(cmd, say_ok)) { if (_enqueuecommand(cmd, say_ok)) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR(MSG_ENQUEUEING, cmd); SERIAL_ECHOPAIR(MSG_ENQUEUEING, cmd);
SERIAL_CHAR('"'); SERIAL_CHAR('"');
SERIAL_EOL; SERIAL_EOL();
return true; return true;
} }
return false; return false;
@ -1010,7 +1010,7 @@ void servo_init() {
#endif // HAS_COLOR_LEDS #endif // HAS_COLOR_LEDS
void gcode_line_error(const char* err, bool doFlush = true) { void gcode_line_error(const char* err, bool doFlush = true) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
serialprintPGM(err); serialprintPGM(err);
SERIAL_ERRORLN(gcode_LastN); SERIAL_ERRORLN(gcode_LastN);
//Serial.println(gcode_N); //Serial.println(gcode_N);
@ -1206,7 +1206,7 @@ inline void get_serial_commands() {
card.checkautostart(true); card.checkautostart(true);
} }
else if (n == -1) { else if (n == -1) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ECHOLNPGM(MSG_SD_ERR_READ); SERIAL_ECHOLNPGM(MSG_SD_ERR_READ);
} }
if (sd_char == '#') stop_buffering = true; if (sd_char == '#') stop_buffering = true;
@ -1261,7 +1261,7 @@ void get_available_commands() {
bool get_target_extruder_from_command(int code) { bool get_target_extruder_from_command(int code) {
if (parser.seen('T')) { if (parser.seen('T')) {
if (parser.value_byte() >= EXTRUDERS) { if (parser.value_byte() >= EXTRUDERS) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_CHAR('M'); SERIAL_CHAR('M');
SERIAL_ECHO(code); SERIAL_ECHO(code);
SERIAL_ECHOLNPAIR(" " MSG_INVALID_EXTRUDER " ", parser.value_byte()); SERIAL_ECHOLNPAIR(" " MSG_INVALID_EXTRUDER " ", parser.value_byte());
@ -1421,7 +1421,7 @@ static void set_axis_is_at_home(const AxisEnum axis) {
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPAIR(">>> set_axis_is_at_home(", axis_codes[axis]); SERIAL_ECHOPAIR(">>> set_axis_is_at_home(", axis_codes[axis]);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -1510,7 +1510,7 @@ static void set_axis_is_at_home(const AxisEnum axis) {
DEBUG_POS("", current_position); DEBUG_POS("", current_position);
SERIAL_ECHOPAIR("<<< set_axis_is_at_home(", axis_codes[axis]); SERIAL_ECHOPAIR("<<< set_axis_is_at_home(", axis_codes[axis]);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -1527,7 +1527,7 @@ inline float get_homing_bump_feedrate(const AxisEnum axis) {
uint8_t hbd = pgm_read_byte(&homing_bump_divisor[axis]); uint8_t hbd = pgm_read_byte(&homing_bump_divisor[axis]);
if (hbd < 1) { if (hbd < 1) {
hbd = 10; hbd = 10;
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM("Warning: Homing Bump Divisor < 1"); SERIAL_ECHOLNPGM("Warning: Homing Bump Divisor < 1");
} }
return homing_feedrate(axis) / hbd; return homing_feedrate(axis) / hbd;
@ -1748,7 +1748,7 @@ static void clean_up_after_endstop_or_probe_move() {
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPAIR("do_probe_raise(", z_raise); SERIAL_ECHOPAIR("do_probe_raise(", z_raise);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -1777,7 +1777,7 @@ static void clean_up_after_endstop_or_probe_move() {
zz = z && !axis_homed[Z_AXIS]; zz = z && !axis_homed[Z_AXIS];
#endif #endif
if (xx || yy || zz) { if (xx || yy || zz) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(MSG_HOME " "); SERIAL_ECHOPGM(MSG_HOME " ");
if (xx) SERIAL_ECHOPGM(MSG_X); if (xx) SERIAL_ECHOPGM(MSG_X);
if (yy) SERIAL_ECHOPGM(MSG_Y); if (yy) SERIAL_ECHOPGM(MSG_Y);
@ -1811,7 +1811,7 @@ static void clean_up_after_endstop_or_probe_move() {
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPAIR("dock_sled(", stow); SERIAL_ECHOPAIR("dock_sled(", stow);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -2054,7 +2054,7 @@ static void clean_up_after_endstop_or_probe_move() {
// (Measured completion time was 0.65 seconds // (Measured completion time was 0.65 seconds
// after reset, deploy, and stow sequence) // after reset, deploy, and stow sequence)
if (TEST_BLTOUCH()) { // If it still claims to be triggered... if (TEST_BLTOUCH()) { // If it still claims to be triggered...
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_STOP_BLTOUCH); SERIAL_ERRORLNPGM(MSG_STOP_BLTOUCH);
stop(); // punt! stop(); // punt!
} }
@ -2066,7 +2066,7 @@ static void clean_up_after_endstop_or_probe_move() {
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPAIR("set_bltouch_deployed(", deploy); SERIAL_ECHOPAIR("set_bltouch_deployed(", deploy);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
} }
@ -2098,7 +2098,7 @@ static void clean_up_after_endstop_or_probe_move() {
// measured completion time was 0.65 seconds // measured completion time was 0.65 seconds
// after reset, deploy & stow sequence // after reset, deploy & stow sequence
if (TEST_BLTOUCH()) { // If it still claims to be triggered... if (TEST_BLTOUCH()) { // If it still claims to be triggered...
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_STOP_BLTOUCH); SERIAL_ERRORLNPGM(MSG_STOP_BLTOUCH);
stop(); // punt! stop(); // punt!
return true; return true;
@ -2111,7 +2111,7 @@ static void clean_up_after_endstop_or_probe_move() {
#define _AUE_ARGS #define _AUE_ARGS
#endif #endif
if (axis_unhomed_error(_AUE_ARGS)) { if (axis_unhomed_error(_AUE_ARGS)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_STOP_UNHOMED); SERIAL_ERRORLNPGM(MSG_STOP_UNHOMED);
stop(); stop();
return true; return true;
@ -2159,7 +2159,7 @@ static void clean_up_after_endstop_or_probe_move() {
if (_TRIGGERED_WHEN_STOWED_TEST == deploy) { // State hasn't changed? if (_TRIGGERED_WHEN_STOWED_TEST == deploy) { // State hasn't changed?
if (IsRunning()) { if (IsRunning()) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("Z-Probe failed"); SERIAL_ERRORLNPGM("Z-Probe failed");
LCD_ALERTMESSAGEPGM("Err: ZPROBE"); LCD_ALERTMESSAGEPGM("Err: ZPROBE");
} }
@ -2323,7 +2323,7 @@ static void clean_up_after_endstop_or_probe_move() {
SERIAL_PROTOCOL_F(y, 3); SERIAL_PROTOCOL_F(y, 3);
SERIAL_PROTOCOLPGM(" Z: "); SERIAL_PROTOCOLPGM(" Z: ");
SERIAL_PROTOCOL_F(measured_z, 3); SERIAL_PROTOCOL_F(measured_z, 3);
SERIAL_EOL; SERIAL_EOL();
} }
#if ENABLED(DEBUG_LEVELING_FEATURE) #if ENABLED(DEBUG_LEVELING_FEATURE)
@ -2523,7 +2523,7 @@ static void clean_up_after_endstop_or_probe_move() {
SERIAL_PROTOCOLCHAR(' '); SERIAL_PROTOCOLCHAR(' ');
SERIAL_PROTOCOL((int)x); SERIAL_PROTOCOL((int)x);
} }
SERIAL_EOL; SERIAL_EOL();
#endif #endif
#ifdef SCAD_MESH_OUTPUT #ifdef SCAD_MESH_OUTPUT
SERIAL_PROTOCOLLNPGM("measured_z = ["); // open 2D array SERIAL_PROTOCOLLNPGM("measured_z = ["); // open 2D array
@ -2561,12 +2561,12 @@ static void clean_up_after_endstop_or_probe_move() {
SERIAL_PROTOCOLCHAR(']'); // close sub-array SERIAL_PROTOCOLCHAR(']'); // close sub-array
if (y < sy - 1) SERIAL_PROTOCOLCHAR(','); if (y < sy - 1) SERIAL_PROTOCOLCHAR(',');
#endif #endif
SERIAL_EOL; SERIAL_EOL();
} }
#ifdef SCAD_MESH_OUTPUT #ifdef SCAD_MESH_OUTPUT
SERIAL_PROTOCOLPGM("];"); // close 2D array SERIAL_PROTOCOLPGM("];"); // close 2D array
#endif #endif
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -2596,7 +2596,7 @@ static void clean_up_after_endstop_or_probe_move() {
#endif #endif
return; // Don't overwrite good values. return; // Don't overwrite good values.
} }
SERIAL_EOL; SERIAL_EOL();
// Get X neighbors, Y neighbors, and XY neighbors // Get X neighbors, Y neighbors, and XY neighbors
const uint8_t x1 = x + xdir, y1 = y + ydir, x2 = x1 + xdir, y2 = y1 + ydir; const uint8_t x1 = x + xdir, y1 = y + ydir, x2 = x1 + xdir, y2 = y1 + ydir;
@ -2798,7 +2798,7 @@ static void do_homing_move(const AxisEnum axis, const float distance, const floa
SERIAL_ECHOPAIR(", ", distance); SERIAL_ECHOPAIR(", ", distance);
SERIAL_ECHOPAIR(", ", fr_mm_s); SERIAL_ECHOPAIR(", ", fr_mm_s);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -2841,7 +2841,7 @@ static void do_homing_move(const AxisEnum axis, const float distance, const floa
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPAIR("<<< do_homing_move(", axis_codes[axis]); SERIAL_ECHOPAIR("<<< do_homing_move(", axis_codes[axis]);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
} }
@ -2896,7 +2896,7 @@ static void homeaxis(const AxisEnum axis) {
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPAIR(">>> homeaxis(", axis_codes[axis]); SERIAL_ECHOPAIR(">>> homeaxis(", axis_codes[axis]);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -3029,7 +3029,7 @@ static void homeaxis(const AxisEnum axis) {
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPAIR("<<< homeaxis(", axis_codes[axis]); SERIAL_ECHOPAIR("<<< homeaxis(", axis_codes[axis]);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
} // homeaxis() } // homeaxis()
@ -3176,15 +3176,15 @@ void gcode_get_destination() {
switch (busy_state) { switch (busy_state) {
case IN_HANDLER: case IN_HANDLER:
case IN_PROCESS: case IN_PROCESS:
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_BUSY_PROCESSING); SERIAL_ECHOLNPGM(MSG_BUSY_PROCESSING);
break; break;
case PAUSED_FOR_USER: case PAUSED_FOR_USER:
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_BUSY_PAUSED_FOR_USER); SERIAL_ECHOLNPGM(MSG_BUSY_PAUSED_FOR_USER);
break; break;
case PAUSED_FOR_INPUT: case PAUSED_FOR_INPUT:
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_BUSY_PAUSED_FOR_INPUT); SERIAL_ECHOLNPGM(MSG_BUSY_PAUSED_FOR_INPUT);
break; break;
default: default:
@ -3302,7 +3302,7 @@ inline void gcode_G0_G1(
} }
else { else {
// Bad arguments // Bad arguments
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_ARC_ARGS); SERIAL_ERRORLNPGM(MSG_ERR_ARC_ARGS);
} }
} }
@ -3543,7 +3543,7 @@ inline void gcode_G4() {
else else
SERIAL_ECHOLNPGM(" (disabled)"); SERIAL_ECHOLNPGM(" (disabled)");
SERIAL_EOL; SERIAL_EOL();
#elif ENABLED(MESH_BED_LEVELING) #elif ENABLED(MESH_BED_LEVELING)
@ -3557,7 +3557,7 @@ inline void gcode_G4() {
else else
SERIAL_ECHOPGM(" (disabled)"); SERIAL_ECHOPGM(" (disabled)");
SERIAL_EOL; SERIAL_EOL();
#endif // MESH_BED_LEVELING #endif // MESH_BED_LEVELING
} }
@ -3613,7 +3613,7 @@ inline void gcode_G4() {
// Disallow Z homing if X or Y are unknown // Disallow Z homing if X or Y are unknown
if (!axis_known_position[X_AXIS] || !axis_known_position[Y_AXIS]) { if (!axis_known_position[X_AXIS] || !axis_known_position[Y_AXIS]) {
LCD_MESSAGEPGM(MSG_ERR_Z_HOMING); LCD_MESSAGEPGM(MSG_ERR_Z_HOMING);
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_ERR_Z_HOMING); SERIAL_ECHOLNPGM(MSG_ERR_Z_HOMING);
return; return;
} }
@ -3652,7 +3652,7 @@ inline void gcode_G4() {
} }
else { else {
LCD_MESSAGEPGM(MSG_ZPROBE_OUT); LCD_MESSAGEPGM(MSG_ZPROBE_OUT);
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_ZPROBE_OUT); SERIAL_ECHOLNPGM(MSG_ZPROBE_OUT);
} }
@ -4300,14 +4300,14 @@ void home_all_axes() { gcode_G28(true); }
if (parser.seen('W')) { if (parser.seen('W')) {
if (!leveling_is_valid()) { if (!leveling_is_valid()) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("No bilinear grid"); SERIAL_ERRORLNPGM("No bilinear grid");
return; return;
} }
const float z = parser.seen('Z') && parser.has_value() ? parser.value_float() : NAN; const float z = parser.seen('Z') && parser.has_value() ? parser.value_float() : NAN;
if (!isnan(z) || !WITHIN(z, -10, 10)) { if (!isnan(z) || !WITHIN(z, -10, 10)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("Bad Z value"); SERIAL_ERRORLNPGM("Bad Z value");
return; return;
} }
@ -4837,11 +4837,11 @@ void home_all_axes() { gcode_G28(true); }
SERIAL_PROTOCOL_F(plane_equation_coefficients[1], 8); SERIAL_PROTOCOL_F(plane_equation_coefficients[1], 8);
SERIAL_PROTOCOLPGM(" d: "); SERIAL_PROTOCOLPGM(" d: ");
SERIAL_PROTOCOL_F(plane_equation_coefficients[2], 8); SERIAL_PROTOCOL_F(plane_equation_coefficients[2], 8);
SERIAL_EOL; SERIAL_EOL();
if (verbose_level > 2) { if (verbose_level > 2) {
SERIAL_PROTOCOLPGM("Mean of sampled points: "); SERIAL_PROTOCOLPGM("Mean of sampled points: ");
SERIAL_PROTOCOL_F(mean, 8); SERIAL_PROTOCOL_F(mean, 8);
SERIAL_EOL; SERIAL_EOL();
} }
} }
@ -4887,9 +4887,9 @@ void home_all_axes() { gcode_G28(true); }
SERIAL_PROTOCOLCHAR(' '); SERIAL_PROTOCOLCHAR(' ');
SERIAL_PROTOCOL_F(diff, 5); SERIAL_PROTOCOL_F(diff, 5);
} // xx } // xx
SERIAL_EOL; SERIAL_EOL();
} // yy } // yy
SERIAL_EOL; SERIAL_EOL();
if (verbose_level > 3) { if (verbose_level > 3) {
SERIAL_PROTOCOLLNPGM("\nCorrected Bed Height vs. Bed Topology:"); SERIAL_PROTOCOLLNPGM("\nCorrected Bed Height vs. Bed Topology:");
@ -4911,9 +4911,9 @@ void home_all_axes() { gcode_G28(true); }
SERIAL_PROTOCOLCHAR(' '); SERIAL_PROTOCOLCHAR(' ');
SERIAL_PROTOCOL_F(diff, 5); SERIAL_PROTOCOL_F(diff, 5);
} // xx } // xx
SERIAL_EOL; SERIAL_EOL();
} // yy } // yy
SERIAL_EOL; SERIAL_EOL();
} }
} //do_topography_map } //do_topography_map
@ -5163,7 +5163,7 @@ void home_all_axes() { gcode_G28(true); }
SERIAL_PROTOCOLPGM("Checking... AC"); SERIAL_PROTOCOLPGM("Checking... AC");
if (verbose_level == 0) SERIAL_PROTOCOLPGM(" (DRY-RUN)"); if (verbose_level == 0) SERIAL_PROTOCOLPGM(" (DRY-RUN)");
SERIAL_EOL; SERIAL_EOL();
LCD_MESSAGEPGM("Checking... AC"); // TODO: Make translatable string LCD_MESSAGEPGM("Checking... AC"); // TODO: Make translatable string
SERIAL_PROTOCOLPAIR(".Height:", DELTA_HEIGHT + home_offset[Z_AXIS]); SERIAL_PROTOCOLPAIR(".Height:", DELTA_HEIGHT + home_offset[Z_AXIS]);
@ -5179,7 +5179,7 @@ void home_all_axes() { gcode_G28(true); }
SERIAL_PROTOCOL_F(endstop_adj[C_AXIS], 2); SERIAL_PROTOCOL_F(endstop_adj[C_AXIS], 2);
SERIAL_PROTOCOLPAIR(" Radius:", delta_radius); SERIAL_PROTOCOLPAIR(" Radius:", delta_radius);
} }
SERIAL_EOL; SERIAL_EOL();
if (_7p_calibration && towers_set) { if (_7p_calibration && towers_set) {
SERIAL_PROTOCOLPGM(".Tower angle : Tx:"); SERIAL_PROTOCOLPGM(".Tower angle : Tx:");
if (delta_tower_angle_trim[A_AXIS] >= 0) SERIAL_CHAR('+'); if (delta_tower_angle_trim[A_AXIS] >= 0) SERIAL_CHAR('+');
@ -5188,7 +5188,7 @@ void home_all_axes() { gcode_G28(true); }
if (delta_tower_angle_trim[B_AXIS] >= 0) SERIAL_CHAR('+'); if (delta_tower_angle_trim[B_AXIS] >= 0) SERIAL_CHAR('+');
SERIAL_PROTOCOL_F(delta_tower_angle_trim[B_AXIS], 2); SERIAL_PROTOCOL_F(delta_tower_angle_trim[B_AXIS], 2);
SERIAL_PROTOCOLPGM(" Tz:+0.00"); SERIAL_PROTOCOLPGM(" Tz:+0.00");
SERIAL_EOL; SERIAL_EOL();
} }
#if ENABLED(Z_PROBE_SLED) #if ENABLED(Z_PROBE_SLED)
@ -5356,7 +5356,7 @@ void home_all_axes() { gcode_G28(true); }
if (z_at_pt[9] >= 0) SERIAL_CHAR('+'); if (z_at_pt[9] >= 0) SERIAL_CHAR('+');
SERIAL_PROTOCOL_F(z_at_pt[9], 2); SERIAL_PROTOCOL_F(z_at_pt[9], 2);
} }
if (!_4p_opposite_points) SERIAL_EOL; if (!_4p_opposite_points) SERIAL_EOL();
if ((_4p_opposite_points) || _7p_calibration) { if ((_4p_opposite_points) || _7p_calibration) {
if (_7p_calibration) { if (_7p_calibration) {
SERIAL_CHAR('.'); SERIAL_CHAR('.');
@ -5371,7 +5371,7 @@ void home_all_axes() { gcode_G28(true); }
SERIAL_PROTOCOLPGM(" xy:"); SERIAL_PROTOCOLPGM(" xy:");
if (z_at_pt[3] >= 0) SERIAL_CHAR('+'); if (z_at_pt[3] >= 0) SERIAL_CHAR('+');
SERIAL_PROTOCOL_F(z_at_pt[3], 2); SERIAL_PROTOCOL_F(z_at_pt[3], 2);
SERIAL_EOL; SERIAL_EOL();
} }
} }
if (test_precision != 0.0) { // !forced end if (test_precision != 0.0) { // !forced end
@ -5384,7 +5384,7 @@ void home_all_axes() { gcode_G28(true); }
SERIAL_PROTOCOLPGM("std dev:"); SERIAL_PROTOCOLPGM("std dev:");
SERIAL_PROTOCOL_F(zero_std_dev, 3); SERIAL_PROTOCOL_F(zero_std_dev, 3);
} }
SERIAL_EOL; SERIAL_EOL();
LCD_MESSAGEPGM("Calibration OK"); // TODO: Make translatable string LCD_MESSAGEPGM("Calibration OK"); // TODO: Make translatable string
} }
else { // !end iterations else { // !end iterations
@ -5395,7 +5395,7 @@ void home_all_axes() { gcode_G28(true); }
SERIAL_PROTOCOL_SP(36); SERIAL_PROTOCOL_SP(36);
SERIAL_PROTOCOLPGM("std dev:"); SERIAL_PROTOCOLPGM("std dev:");
SERIAL_PROTOCOL_F(zero_std_dev, 3); SERIAL_PROTOCOL_F(zero_std_dev, 3);
SERIAL_EOL; SERIAL_EOL();
lcd_setstatus(mess); lcd_setstatus(mess);
} }
SERIAL_PROTOCOLPAIR(".Height:", DELTA_HEIGHT + home_offset[Z_AXIS]); SERIAL_PROTOCOLPAIR(".Height:", DELTA_HEIGHT + home_offset[Z_AXIS]);
@ -5411,7 +5411,7 @@ void home_all_axes() { gcode_G28(true); }
SERIAL_PROTOCOL_F(endstop_adj[C_AXIS], 2); SERIAL_PROTOCOL_F(endstop_adj[C_AXIS], 2);
SERIAL_PROTOCOLPAIR(" Radius:", delta_radius); SERIAL_PROTOCOLPAIR(" Radius:", delta_radius);
} }
SERIAL_EOL; SERIAL_EOL();
if (_7p_calibration && towers_set) { if (_7p_calibration && towers_set) {
SERIAL_PROTOCOLPGM(".Tower angle : Tx:"); SERIAL_PROTOCOLPGM(".Tower angle : Tx:");
if (delta_tower_angle_trim[A_AXIS] >= 0) SERIAL_CHAR('+'); if (delta_tower_angle_trim[A_AXIS] >= 0) SERIAL_CHAR('+');
@ -5420,11 +5420,11 @@ void home_all_axes() { gcode_G28(true); }
if (delta_tower_angle_trim[B_AXIS] >= 0) SERIAL_CHAR('+'); if (delta_tower_angle_trim[B_AXIS] >= 0) SERIAL_CHAR('+');
SERIAL_PROTOCOL_F(delta_tower_angle_trim[B_AXIS], 2); SERIAL_PROTOCOL_F(delta_tower_angle_trim[B_AXIS], 2);
SERIAL_PROTOCOLPGM(" Tz:+0.00"); SERIAL_PROTOCOLPGM(" Tz:+0.00");
SERIAL_EOL; SERIAL_EOL();
} }
if (zero_std_dev >= test_precision || zero_std_dev <= calibration_precision) if (zero_std_dev >= test_precision || zero_std_dev <= calibration_precision)
serialprintPGM(save_message); serialprintPGM(save_message);
SERIAL_EOL; SERIAL_EOL();
} }
else { // forced end else { // forced end
if (verbose_level == 0) { if (verbose_level == 0) {
@ -5432,15 +5432,15 @@ void home_all_axes() { gcode_G28(true); }
SERIAL_PROTOCOL_SP(39); SERIAL_PROTOCOL_SP(39);
SERIAL_PROTOCOLPGM("std dev:"); SERIAL_PROTOCOLPGM("std dev:");
SERIAL_PROTOCOL_F(zero_std_dev, 3); SERIAL_PROTOCOL_F(zero_std_dev, 3);
SERIAL_EOL; SERIAL_EOL();
} }
else { else {
SERIAL_PROTOCOLLNPGM("Calibration OK"); SERIAL_PROTOCOLLNPGM("Calibration OK");
LCD_MESSAGEPGM("Calibration OK"); // TODO: Make translatable string LCD_MESSAGEPGM("Calibration OK"); // TODO: Make translatable string
SERIAL_PROTOCOLPAIR(".Height:", DELTA_HEIGHT + home_offset[Z_AXIS]); SERIAL_PROTOCOLPAIR(".Height:", DELTA_HEIGHT + home_offset[Z_AXIS]);
SERIAL_EOL; SERIAL_EOL();
serialprintPGM(save_message); serialprintPGM(save_message);
SERIAL_EOL; SERIAL_EOL();
} }
} }
@ -5545,7 +5545,7 @@ void home_all_axes() { gcode_G28(true); }
if (!parser.seen('F')) feedrate_mm_s = homing_feedrate(i); if (!parser.seen('F')) feedrate_mm_s = homing_feedrate(i);
// If G38.2 fails throw an error // If G38.2 fails throw an error
if (!G38_run_probe() && is_38_2) { if (!G38_run_probe() && is_38_2) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("Failed to reach target"); SERIAL_ERRORLNPGM("Failed to reach target");
} }
break; break;
@ -5685,7 +5685,7 @@ inline void gcode_G92() {
#else #else
if (!hasP && !hasS && args && *args) { if (!hasP && !hasS && args && *args) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLN(args); SERIAL_ECHOLN(args);
} }
@ -5899,7 +5899,7 @@ inline void gcode_M17() {
#if ENABLED(PREVENT_COLD_EXTRUSION) #if ENABLED(PREVENT_COLD_EXTRUSION)
if (!thermalManager.allow_cold_extrude && if (!thermalManager.allow_cold_extrude &&
thermalManager.degTargetHotend(active_extruder) < thermalManager.extrude_min_temp) { thermalManager.degTargetHotend(active_extruder) < thermalManager.extrude_min_temp) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_TOO_COLD_FOR_M600); SERIAL_ERRORLNPGM(MSG_TOO_COLD_FOR_M600);
return false; return false;
} }
@ -6232,7 +6232,7 @@ inline void gcode_M31() {
elapsed.toString(buffer); elapsed.toString(buffer);
lcd_setstatus(buffer); lcd_setstatus(buffer);
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPAIR("Print time: ", buffer); SERIAL_ECHOLNPAIR("Print time: ", buffer);
} }
@ -6330,7 +6330,7 @@ inline void gcode_M42() {
if (pin_number < 0) return; if (pin_number < 0) return;
if (pin_is_protected(pin_number)) { if (pin_is_protected(pin_number)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_PROTECTED_PIN); SERIAL_ERRORLNPGM(MSG_ERR_PROTECTED_PIN);
return; return;
} }
@ -6391,12 +6391,12 @@ inline void gcode_M42() {
inline void servo_probe_test() { inline void servo_probe_test() {
#if !(NUM_SERVOS > 0 && HAS_SERVO_0) #if !(NUM_SERVOS > 0 && HAS_SERVO_0)
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("SERVO not setup"); SERIAL_ERRORLNPGM("SERVO not setup");
#elif !HAS_Z_SERVO_ENDSTOP #elif !HAS_Z_SERVO_ENDSTOP
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("Z_ENDSTOP_SERVO_NR not setup"); SERIAL_ERRORLNPGM("Z_ENDSTOP_SERVO_NR not setup");
#else #else
@ -6832,7 +6832,7 @@ inline void gcode_M42() {
SERIAL_PROTOCOLPGM(" range: "); SERIAL_PROTOCOLPGM(" range: ");
SERIAL_PROTOCOL_F(max-min, 3); SERIAL_PROTOCOL_F(max-min, 3);
} }
SERIAL_EOL; SERIAL_EOL();
} }
} }
@ -6841,7 +6841,7 @@ inline void gcode_M42() {
if (STOW_PROBE()) return; if (STOW_PROBE()) return;
SERIAL_PROTOCOLPGM("Finished!"); SERIAL_PROTOCOLPGM("Finished!");
SERIAL_EOL; SERIAL_EOL();
if (verbose_level > 0) { if (verbose_level > 0) {
SERIAL_PROTOCOLPGM("Mean: "); SERIAL_PROTOCOLPGM("Mean: ");
@ -6852,13 +6852,13 @@ inline void gcode_M42() {
SERIAL_PROTOCOL_F(max, 3); SERIAL_PROTOCOL_F(max, 3);
SERIAL_PROTOCOLPGM(" Range: "); SERIAL_PROTOCOLPGM(" Range: ");
SERIAL_PROTOCOL_F(max-min, 3); SERIAL_PROTOCOL_F(max-min, 3);
SERIAL_EOL; SERIAL_EOL();
} }
SERIAL_PROTOCOLPGM("Standard Deviation: "); SERIAL_PROTOCOLPGM("Standard Deviation: ");
SERIAL_PROTOCOL_F(sigma, 6); SERIAL_PROTOCOL_F(sigma, 6);
SERIAL_EOL; SERIAL_EOL();
SERIAL_EOL; SERIAL_EOL();
clean_up_after_endstop_or_probe_move(); clean_up_after_endstop_or_probe_move();
@ -7014,11 +7014,11 @@ inline void gcode_M105() {
SERIAL_PROTOCOLPGM(MSG_OK); SERIAL_PROTOCOLPGM(MSG_OK);
print_heaterstates(); print_heaterstates();
#else // !HAS_TEMP_HOTEND && !HAS_TEMP_BED #else // !HAS_TEMP_HOTEND && !HAS_TEMP_BED
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_NO_THERMISTORS); SERIAL_ERRORLNPGM(MSG_ERR_NO_THERMISTORS);
#endif #endif
SERIAL_EOL; SERIAL_EOL();
} }
#if ENABLED(AUTO_REPORT_TEMPERATURES) && (HAS_TEMP_HOTEND || HAS_TEMP_BED) #if ENABLED(AUTO_REPORT_TEMPERATURES) && (HAS_TEMP_HOTEND || HAS_TEMP_BED)
@ -7041,7 +7041,7 @@ inline void gcode_M105() {
if (auto_report_temp_interval && ELAPSED(millis(), next_temp_report_ms)) { if (auto_report_temp_interval && ELAPSED(millis(), next_temp_report_ms)) {
next_temp_report_ms = millis() + 1000UL * auto_report_temp_interval; next_temp_report_ms = millis() + 1000UL * auto_report_temp_interval;
print_heaterstates(); print_heaterstates();
SERIAL_EOL; SERIAL_EOL();
} }
} }
@ -7194,7 +7194,7 @@ inline void gcode_M109() {
SERIAL_PROTOCOLLNPGM("?"); SERIAL_PROTOCOLLNPGM("?");
} }
#else #else
SERIAL_EOL; SERIAL_EOL();
#endif #endif
} }
@ -7327,7 +7327,7 @@ inline void gcode_M109() {
SERIAL_PROTOCOLLNPGM("?"); SERIAL_PROTOCOLLNPGM("?");
} }
#else #else
SERIAL_EOL; SERIAL_EOL();
#endif #endif
} }
@ -7407,7 +7407,7 @@ inline void gcode_M111() {
#endif #endif
}; };
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(MSG_DEBUG_PREFIX); SERIAL_ECHOPGM(MSG_DEBUG_PREFIX);
if (marlin_debug_flags) { if (marlin_debug_flags) {
uint8_t comma = 0; uint8_t comma = 0;
@ -7421,7 +7421,7 @@ inline void gcode_M111() {
else { else {
SERIAL_ECHOPGM(MSG_DEBUG_OFF); SERIAL_ECHOPGM(MSG_DEBUG_OFF);
} }
SERIAL_EOL; SERIAL_EOL();
} }
#if ENABLED(HOST_KEEPALIVE_FEATURE) #if ENABLED(HOST_KEEPALIVE_FEATURE)
@ -7437,7 +7437,7 @@ inline void gcode_M111() {
NOMORE(host_keepalive_interval, 60); NOMORE(host_keepalive_interval, 60);
} }
else { else {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPAIR("M113 S", (unsigned long)host_keepalive_interval); SERIAL_ECHOLNPAIR("M113 S", (unsigned long)host_keepalive_interval);
} }
} }
@ -7491,7 +7491,7 @@ inline void gcode_M140() {
inline void gcode_M145() { inline void gcode_M145() {
uint8_t material = parser.seen('S') ? (uint8_t)parser.value_int() : 0; uint8_t material = parser.seen('S') ? (uint8_t)parser.value_int() : 0;
if (material >= COUNT(lcd_preheat_hotend_temp)) { if (material >= COUNT(lcd_preheat_hotend_temp)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_MATERIAL_INDEX); SERIAL_ERRORLNPGM(MSG_ERR_MATERIAL_INDEX);
} }
else { else {
@ -7697,7 +7697,7 @@ void report_current_position() {
#if IS_SCARA #if IS_SCARA
SERIAL_PROTOCOLPAIR("SCARA Theta:", stepper.get_axis_position_degrees(A_AXIS)); SERIAL_PROTOCOLPAIR("SCARA Theta:", stepper.get_axis_position_degrees(A_AXIS));
SERIAL_PROTOCOLLNPAIR(" Psi+Theta:", stepper.get_axis_position_degrees(B_AXIS)); SERIAL_PROTOCOLLNPAIR(" Psi+Theta:", stepper.get_axis_position_degrees(B_AXIS));
SERIAL_EOL; SERIAL_EOL();
#endif #endif
} }
@ -7711,7 +7711,7 @@ void report_current_position() {
SERIAL_CHAR(':'); SERIAL_CHAR(':');
SERIAL_PROTOCOL(dtostrf(pos[i], 8, precision, str)); SERIAL_PROTOCOL(dtostrf(pos[i], 8, precision, str));
} }
SERIAL_EOL; SERIAL_EOL();
} }
inline void report_xyz(const float pos[XYZ]) { report_xyze(pos, 3); } inline void report_xyz(const float pos[XYZ]) { report_xyze(pos, 3); }
@ -8214,7 +8214,7 @@ inline void gcode_M205() {
if (sumAPX == 1) if (sumAPX == 1)
home_offset[A_AXIS] = parser.value_float(); home_offset[A_AXIS] = parser.value_float();
else if (sumAPX > 1) { else if (sumAPX > 1) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("Only one of A, P, or X is allowed."); SERIAL_ERRORLNPGM("Only one of A, P, or X is allowed.");
return; return;
} }
@ -8224,7 +8224,7 @@ inline void gcode_M205() {
if (sumBTY == 1) if (sumBTY == 1)
home_offset[B_AXIS] = parser.value_float(); home_offset[B_AXIS] = parser.value_float();
else if (sumBTY > 1) { else if (sumBTY > 1) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("Only one of B, T, or Y is allowed."); SERIAL_ERRORLNPGM("Only one of B, T, or Y is allowed.");
return; return;
} }
@ -8296,7 +8296,7 @@ inline void gcode_M205() {
* Usage: M211 S1 to enable, M211 S0 to disable, M211 alone for report * Usage: M211 S1 to enable, M211 S0 to disable, M211 alone for report
*/ */
inline void gcode_M211() { inline void gcode_M211() {
SERIAL_ECHO_START; SERIAL_ECHO_START();
#if HAS_SOFTWARE_ENDSTOPS #if HAS_SOFTWARE_ENDSTOPS
if (parser.seen('S')) soft_endstops_enabled = parser.value_bool(); if (parser.seen('S')) soft_endstops_enabled = parser.value_bool();
SERIAL_ECHOPGM(MSG_SOFT_ENDSTOPS); SERIAL_ECHOPGM(MSG_SOFT_ENDSTOPS);
@ -8335,7 +8335,7 @@ inline void gcode_M211() {
if (parser.seen('Z')) hotend_offset[Z_AXIS][target_extruder] = parser.value_linear_units(); if (parser.seen('Z')) hotend_offset[Z_AXIS][target_extruder] = parser.value_linear_units();
#endif #endif
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(MSG_HOTEND_OFFSET); SERIAL_ECHOPGM(MSG_HOTEND_OFFSET);
HOTEND_LOOP() { HOTEND_LOOP() {
SERIAL_CHAR(' '); SERIAL_CHAR(' ');
@ -8347,7 +8347,7 @@ inline void gcode_M211() {
SERIAL_ECHO(hotend_offset[Z_AXIS][e]); SERIAL_ECHO(hotend_offset[Z_AXIS][e]);
#endif #endif
} }
SERIAL_EOL; SERIAL_EOL();
} }
#endif // HOTENDS > 1 #endif // HOTENDS > 1
@ -8447,7 +8447,7 @@ inline void gcode_M226() {
i2c.relay(bytes); i2c.relay(bytes);
} }
else { else {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLN("Bad i2c request"); SERIAL_ERRORLN("Bad i2c request");
} }
} }
@ -8466,13 +8466,13 @@ inline void gcode_M226() {
if (parser.seen('S')) if (parser.seen('S'))
MOVE_SERVO(servo_index, parser.value_int()); MOVE_SERVO(servo_index, parser.value_int());
else { else {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR(" Servo ", servo_index); SERIAL_ECHOPAIR(" Servo ", servo_index);
SERIAL_ECHOLNPAIR(": ", servo[servo_index].read()); SERIAL_ECHOLNPAIR(": ", servo[servo_index].read());
} }
} }
else { else {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ECHOPAIR("Servo ", servo_index); SERIAL_ECHOPAIR("Servo ", servo_index);
SERIAL_ECHOLNPGM(" out of range"); SERIAL_ECHOLNPGM(" out of range");
} }
@ -8528,7 +8528,7 @@ inline void gcode_M226() {
#endif #endif
thermalManager.updatePID(); thermalManager.updatePID();
SERIAL_ECHO_START; SERIAL_ECHO_START();
#if ENABLED(PID_PARAMS_PER_HOTEND) #if ENABLED(PID_PARAMS_PER_HOTEND)
SERIAL_ECHOPAIR(" e:", e); // specify extruder in serial output SERIAL_ECHOPAIR(" e:", e); // specify extruder in serial output
#endif // PID_PARAMS_PER_HOTEND #endif // PID_PARAMS_PER_HOTEND
@ -8539,10 +8539,10 @@ inline void gcode_M226() {
//Kc does not have scaling applied above, or in resetting defaults //Kc does not have scaling applied above, or in resetting defaults
SERIAL_ECHOPAIR(" c:", PID_PARAM(Kc, e)); SERIAL_ECHOPAIR(" c:", PID_PARAM(Kc, e));
#endif #endif
SERIAL_EOL; SERIAL_EOL();
} }
else { else {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLN(MSG_INVALID_EXTRUDER); SERIAL_ERRORLN(MSG_INVALID_EXTRUDER);
} }
} }
@ -8558,7 +8558,7 @@ inline void gcode_M226() {
thermalManager.updatePID(); thermalManager.updatePID();
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR(" p:", thermalManager.bedKp); SERIAL_ECHOPAIR(" p:", thermalManager.bedKp);
SERIAL_ECHOPAIR(" i:", unscalePID_i(thermalManager.bedKi)); SERIAL_ECHOPAIR(" i:", unscalePID_i(thermalManager.bedKi));
SERIAL_ECHOLNPAIR(" d:", unscalePID_d(thermalManager.bedKd)); SERIAL_ECHOLNPAIR(" d:", unscalePID_d(thermalManager.bedKd));
@ -8611,7 +8611,7 @@ inline void gcode_M226() {
if (parser.seen('C')) set_lcd_contrast(parser.value_int()); if (parser.seen('C')) set_lcd_contrast(parser.value_int());
SERIAL_PROTOCOLPGM("lcd contrast value: "); SERIAL_PROTOCOLPGM("lcd contrast value: ");
SERIAL_PROTOCOL(lcd_contrast); SERIAL_PROTOCOL(lcd_contrast);
SERIAL_EOL; SERIAL_EOL();
} }
#endif // HAS_LCD_CONTRAST #endif // HAS_LCD_CONTRAST
@ -8644,7 +8644,7 @@ inline void gcode_M226() {
thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0) || parser.value_bool(); thermalManager.allow_cold_extrude = (thermalManager.extrude_min_temp == 0) || parser.value_bool();
else if (!seen_S) { else if (!seen_S) {
// Report current state // Report current state
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR("Cold extrudes are ", (thermalManager.allow_cold_extrude ? "en" : "dis")); SERIAL_ECHOPAIR("Cold extrudes are ", (thermalManager.allow_cold_extrude ? "en" : "dis"));
SERIAL_ECHOPAIR("abled (min temp ", thermalManager.extrude_min_temp); SERIAL_ECHOPAIR("abled (min temp ", thermalManager.extrude_min_temp);
SERIAL_ECHOLNPGM("C)"); SERIAL_ECHOLNPGM("C)");
@ -8678,7 +8678,7 @@ inline void gcode_M303() {
KEEPALIVE_STATE(IN_HANDLER); KEEPALIVE_STATE(IN_HANDLER);
#else #else
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_M303_DISABLED); SERIAL_ERRORLNPGM(MSG_ERR_M303_DISABLED);
#endif #endif
} }
@ -8767,7 +8767,7 @@ inline void gcode_M303() {
break; break;
#endif #endif
default: default:
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_INVALID_SOLENOID); SERIAL_ECHOLNPGM(MSG_INVALID_SOLENOID);
break; break;
} }
@ -8971,11 +8971,11 @@ void quickstop_stepper() {
const bool new_status = leveling_is_active(); const bool new_status = leveling_is_active();
if (to_enable && !new_status) { if (to_enable && !new_status) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_M420_FAILED); SERIAL_ERRORLNPGM(MSG_ERR_M420_FAILED);
} }
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPAIR("Bed Leveling ", new_status ? MSG_ON : MSG_OFF); SERIAL_ECHOLNPAIR("Bed Leveling ", new_status ? MSG_ON : MSG_OFF);
} }
#endif #endif
@ -8999,11 +8999,11 @@ void quickstop_stepper() {
const bool hasZ = parser.seen('Z'), hasQ = !hasZ && parser.seen('Q'); const bool hasZ = parser.seen('Z'), hasQ = !hasZ && parser.seen('Q');
if (int(hasI && hasJ) + int(hasX && hasY) != 1 || !(hasZ || hasQ)) { if (int(hasI && hasJ) + int(hasX && hasY) != 1 || !(hasZ || hasQ)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS); SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS);
} }
else if (ix < 0 || iy < 0) { else if (ix < 0 || iy < 0) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY); SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
} }
else else
@ -9027,11 +9027,11 @@ void quickstop_stepper() {
const bool hasZ = parser.seen('Z'), hasQ = !hasZ && parser.seen('Q'); const bool hasZ = parser.seen('Z'), hasQ = !hasZ && parser.seen('Q');
if (!hasI || !hasJ || !(hasZ || hasQ)) { if (!hasI || !hasJ || !(hasZ || hasQ)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS); SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS);
} }
else if (!WITHIN(ix, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(iy, 0, GRID_MAX_POINTS_Y - 1)) { else if (!WITHIN(ix, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(iy, 0, GRID_MAX_POINTS_Y - 1)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY); SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
} }
else { else {
@ -9067,11 +9067,11 @@ void quickstop_stepper() {
} }
if (int(hasC) + int(hasI && hasJ) != 1 || !(hasZ || hasQ)) { if (int(hasC) + int(hasI && hasJ) != 1 || !(hasZ || hasQ)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS); SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS);
} }
else if (!WITHIN(ix, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(iy, 0, GRID_MAX_POINTS_Y - 1)) { else if (!WITHIN(ix, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(iy, 0, GRID_MAX_POINTS_Y - 1)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY); SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
} }
else else
@ -9103,7 +9103,7 @@ void quickstop_stepper() {
set_home_offset((AxisEnum)i, diff); set_home_offset((AxisEnum)i, diff);
} }
else { else {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_M428_TOO_FAR); SERIAL_ERRORLNPGM(MSG_ERR_M428_TOO_FAR);
LCD_ALERTMESSAGEPGM("Err: Too far!"); LCD_ALERTMESSAGEPGM("Err: Too far!");
BUZZ(200, 40); BUZZ(200, 40);
@ -9202,7 +9202,7 @@ inline void gcode_M503() {
} }
inline void gcode_M851() { inline void gcode_M851() {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(MSG_ZPROBE_ZOFFSET " "); SERIAL_ECHOPGM(MSG_ZPROBE_ZOFFSET " ");
if (parser.seen('Z')) { if (parser.seen('Z')) {
const float value = parser.value_linear_units(); const float value = parser.value_linear_units();
@ -9217,7 +9217,7 @@ inline void gcode_M503() {
else else
SERIAL_ECHOPAIR(": ", zprobe_zoffset); SERIAL_ECHOPAIR(": ", zprobe_zoffset);
SERIAL_EOL; SERIAL_EOL();
} }
#endif // HAS_BED_PROBE #endif // HAS_BED_PROBE
@ -9327,7 +9327,7 @@ inline void gcode_M503() {
case DXC_DUPLICATION_MODE: case DXC_DUPLICATION_MODE:
if (parser.seen('X')) duplicate_extruder_x_offset = max(parser.value_linear_units(), X2_MIN_POS - x_home_pos(0)); if (parser.seen('X')) duplicate_extruder_x_offset = max(parser.value_linear_units(), X2_MIN_POS - x_home_pos(0));
if (parser.seen('R')) duplicate_extruder_temp_offset = parser.value_celsius_diff(); if (parser.seen('R')) duplicate_extruder_temp_offset = parser.value_celsius_diff();
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(MSG_HOTEND_OFFSET); SERIAL_ECHOPGM(MSG_HOTEND_OFFSET);
SERIAL_CHAR(' '); SERIAL_CHAR(' ');
SERIAL_ECHO(hotend_offset[X_AXIS][0]); SERIAL_ECHO(hotend_offset[X_AXIS][0]);
@ -9352,7 +9352,7 @@ inline void gcode_M503() {
inline void gcode_M605() { inline void gcode_M605() {
stepper.synchronize(); stepper.synchronize();
extruder_duplication_enabled = parser.seen('S') && parser.value_int() == (int)DXC_DUPLICATION_MODE; extruder_duplication_enabled = parser.seen('S') && parser.value_int() == (int)DXC_DUPLICATION_MODE;
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPAIR(MSG_DUPLICATION_MODE, extruder_duplication_enabled ? MSG_ON : MSG_OFF); SERIAL_ECHOLNPAIR(MSG_DUPLICATION_MODE, extruder_duplication_enabled ? MSG_ON : MSG_OFF);
} }
@ -9382,12 +9382,12 @@ inline void gcode_M503() {
} }
if (newR >= 0) planner.advance_ed_ratio = newR; if (newR >= 0) planner.advance_ed_ratio = newR;
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR("Advance K=", planner.extruder_advance_k); SERIAL_ECHOPAIR("Advance K=", planner.extruder_advance_k);
SERIAL_ECHOPGM(" E/D="); SERIAL_ECHOPGM(" E/D=");
const float ratio = planner.advance_ed_ratio; const float ratio = planner.advance_ed_ratio;
if (ratio) SERIAL_ECHO(ratio); else SERIAL_ECHOPGM("Auto"); if (ratio) SERIAL_ECHO(ratio); else SERIAL_ECHOPGM("Auto");
SERIAL_EOL; SERIAL_EOL();
} }
#endif // LIN_ADVANCE #endif // LIN_ADVANCE
@ -9407,7 +9407,7 @@ inline void gcode_M503() {
SERIAL_CHAR(name); SERIAL_CHAR(name);
SERIAL_ECHOPGM(" axis temperature prewarn triggered: "); SERIAL_ECHOPGM(" axis temperature prewarn triggered: ");
serialprintPGM(st.getOTPW() ? PSTR("true") : PSTR("false")); serialprintPGM(st.getOTPW() ? PSTR("true") : PSTR("false"));
SERIAL_EOL; SERIAL_EOL();
} }
static void tmc2130_clear_otpw(TMC2130Stepper &st, const char name) { static void tmc2130_clear_otpw(TMC2130Stepper &st, const char name) {
st.clear_otpw(); st.clear_otpw();
@ -9690,7 +9690,7 @@ inline void gcode_M355() {
if (args) update_case_light(); if (args) update_case_light();
// always report case light status // always report case light status
SERIAL_ECHO_START; SERIAL_ECHO_START();
if (!case_light_on) { if (!case_light_on) {
SERIAL_ECHOLN("Case light: off"); SERIAL_ECHOLN("Case light: off");
} }
@ -9700,7 +9700,7 @@ inline void gcode_M355() {
} }
#else #else
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_M355_NONE); SERIAL_ERRORLNPGM(MSG_ERR_M355_NONE);
#endif // HAS_CASE_LIGHT #endif // HAS_CASE_LIGHT
} }
@ -9799,7 +9799,7 @@ inline void gcode_M999() {
#endif #endif
inline void invalid_extruder_error(const uint8_t &e) { inline void invalid_extruder_error(const uint8_t &e) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_CHAR('T'); SERIAL_CHAR('T');
SERIAL_ECHO_F(e, DEC); SERIAL_ECHO_F(e, DEC);
SERIAL_ECHOLN(MSG_INVALID_EXTRUDER); SERIAL_ECHOLN(MSG_INVALID_EXTRUDER);
@ -10120,7 +10120,7 @@ void tool_change(const uint8_t tmp_extruder, const float fr_mm_s/*=0.0*/, bool n
#endif // HOTENDS <= 1 #endif // HOTENDS <= 1
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPAIR(MSG_ACTIVE_EXTRUDER, (int)active_extruder); SERIAL_ECHOLNPAIR(MSG_ACTIVE_EXTRUDER, (int)active_extruder);
#endif // !MIXING_EXTRUDER || MIXING_VIRTUAL_TOOLS <= 1 #endif // !MIXING_EXTRUDER || MIXING_VIRTUAL_TOOLS <= 1
@ -10138,7 +10138,7 @@ inline void gcode_T(uint8_t tmp_extruder) {
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPAIR(">>> gcode_T(", tmp_extruder); SERIAL_ECHOPAIR(">>> gcode_T(", tmp_extruder);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
DEBUG_POS("BEFORE", current_position); DEBUG_POS("BEFORE", current_position);
} }
#endif #endif
@ -10173,7 +10173,7 @@ void process_next_command() {
char * const current_command = command_queue[cmd_queue_index_r]; char * const current_command = command_queue[cmd_queue_index_r];
if (DEBUGGING(ECHO)) { if (DEBUGGING(ECHO)) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLN(current_command); SERIAL_ECHOLN(current_command);
#if ENABLED(M100_FREE_MEMORY_WATCHER) #if ENABLED(M100_FREE_MEMORY_WATCHER)
SERIAL_ECHOPAIR("slot:", cmd_queue_index_r); SERIAL_ECHOPAIR("slot:", cmd_queue_index_r);
@ -11021,7 +11021,7 @@ void ok_to_send() {
SERIAL_PROTOCOLPGM(" P"); SERIAL_PROTOCOL(int(BLOCK_BUFFER_SIZE - planner.movesplanned() - 1)); SERIAL_PROTOCOLPGM(" P"); SERIAL_PROTOCOL(int(BLOCK_BUFFER_SIZE - planner.movesplanned() - 1));
SERIAL_PROTOCOLPGM(" B"); SERIAL_PROTOCOL(BUFSIZE - commands_in_queue); SERIAL_PROTOCOLPGM(" B"); SERIAL_PROTOCOL(BUFSIZE - commands_in_queue);
#endif #endif
SERIAL_EOL; SERIAL_EOL();
} }
#if HAS_SOFTWARE_ENDSTOPS #if HAS_SOFTWARE_ENDSTOPS
@ -11813,13 +11813,13 @@ void prepare_move_to_destination() {
if (destination[E_AXIS] != current_position[E_AXIS]) { if (destination[E_AXIS] != current_position[E_AXIS]) {
if (thermalManager.tooColdToExtrude(active_extruder)) { if (thermalManager.tooColdToExtrude(active_extruder)) {
current_position[E_AXIS] = destination[E_AXIS]; // Behave as if the move really took place, but ignore E part current_position[E_AXIS] = destination[E_AXIS]; // Behave as if the move really took place, but ignore E part
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP); SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP);
} }
#if ENABLED(PREVENT_LENGTHY_EXTRUDE) #if ENABLED(PREVENT_LENGTHY_EXTRUDE)
if (labs(destination[E_AXIS] - current_position[E_AXIS]) > EXTRUDE_MAXLENGTH) { if (labs(destination[E_AXIS] - current_position[E_AXIS]) > EXTRUDE_MAXLENGTH) {
current_position[E_AXIS] = destination[E_AXIS]; // Behave as if the move really took place, but ignore E part current_position[E_AXIS] = destination[E_AXIS]; // Behave as if the move really took place, but ignore E part
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP); SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP);
} }
#endif #endif
@ -12300,7 +12300,7 @@ void disable_all_steppers() {
#endif #endif
} }
} }
SERIAL_EOL; SERIAL_EOL();
#endif #endif
} }
@ -12373,7 +12373,7 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
const millis_t ms = millis(); const millis_t ms = millis();
if (max_inactive_time && ELAPSED(ms, previous_cmd_ms + max_inactive_time)) { if (max_inactive_time && ELAPSED(ms, previous_cmd_ms + max_inactive_time)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ECHOLNPAIR(MSG_KILL_INACTIVE_TIME, parser.command_ptr); SERIAL_ECHOLNPAIR(MSG_KILL_INACTIVE_TIME, parser.command_ptr);
kill(PSTR(MSG_KILLED)); kill(PSTR(MSG_KILLED));
} }
@ -12424,7 +12424,7 @@ void manage_inactivity(bool ignore_stepper_queue/*=false*/) {
// KILL the machine // KILL the machine
// ---------------------------------------------------------------- // ----------------------------------------------------------------
if (killCount >= KILL_DELAY) { if (killCount >= KILL_DELAY) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_KILL_BUTTON); SERIAL_ERRORLNPGM(MSG_KILL_BUTTON);
kill(PSTR(MSG_KILLED)); kill(PSTR(MSG_KILLED));
} }
@ -12575,7 +12575,7 @@ void idle(
* After this the machine will need to be reset. * After this the machine will need to be reset.
*/ */
void kill(const char* lcd_msg) { void kill(const char* lcd_msg) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_KILLED); SERIAL_ERRORLNPGM(MSG_ERR_KILLED);
thermalManager.disable_all_heaters(); thermalManager.disable_all_heaters();
@ -12618,7 +12618,7 @@ void stop() {
if (IsRunning()) { if (IsRunning()) {
Stopped_gcode_LastN = gcode_LastN; // Save last g_code for restart Stopped_gcode_LastN = gcode_LastN; // Save last g_code for restart
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_ERR_STOPPED); SERIAL_ERRORLNPGM(MSG_ERR_STOPPED);
LCD_MESSAGEPGM(MSG_STOPPED); LCD_MESSAGEPGM(MSG_STOPPED);
safe_delay(350); // allow enough time for messages to get out before stopping safe_delay(350); // allow enough time for messages to get out before stopping
@ -12666,7 +12666,7 @@ void setup() {
MYSERIAL.begin(BAUDRATE); MYSERIAL.begin(BAUDRATE);
SERIAL_PROTOCOLLNPGM("start"); SERIAL_PROTOCOLLNPGM("start");
SERIAL_ECHO_START; SERIAL_ECHO_START();
// Check startup - does nothing if bootloader sets MCUSR to 0 // Check startup - does nothing if bootloader sets MCUSR to 0
byte mcu = MCUSR; byte mcu = MCUSR;
@ -12680,17 +12680,17 @@ void setup() {
SERIAL_ECHOPGM(MSG_MARLIN); SERIAL_ECHOPGM(MSG_MARLIN);
SERIAL_CHAR(' '); SERIAL_CHAR(' ');
SERIAL_ECHOLNPGM(SHORT_BUILD_VERSION); SERIAL_ECHOLNPGM(SHORT_BUILD_VERSION);
SERIAL_EOL; SERIAL_EOL();
#if defined(STRING_DISTRIBUTION_DATE) && defined(STRING_CONFIG_H_AUTHOR) #if defined(STRING_DISTRIBUTION_DATE) && defined(STRING_CONFIG_H_AUTHOR)
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(MSG_CONFIGURATION_VER); SERIAL_ECHOPGM(MSG_CONFIGURATION_VER);
SERIAL_ECHOPGM(STRING_DISTRIBUTION_DATE); SERIAL_ECHOPGM(STRING_DISTRIBUTION_DATE);
SERIAL_ECHOLNPGM(MSG_AUTHOR STRING_CONFIG_H_AUTHOR); SERIAL_ECHOLNPGM(MSG_AUTHOR STRING_CONFIG_H_AUTHOR);
SERIAL_ECHOLNPGM("Compiled: " __DATE__); SERIAL_ECHOLNPGM("Compiled: " __DATE__);
#endif #endif
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR(MSG_FREE_MEMORY, freeMemory()); SERIAL_ECHOPAIR(MSG_FREE_MEMORY, freeMemory());
SERIAL_ECHOLNPAIR(MSG_PLANNER_BUFFER_BYTES, (int)sizeof(block_t)*BLOCK_BUFFER_SIZE); SERIAL_ECHOLNPAIR(MSG_PLANNER_BUFFER_BYTES, (int)sizeof(block_t)*BLOCK_BUFFER_SIZE);

32
Marlin/cardreader.cpp
View File

@ -109,7 +109,7 @@ void CardReader::lsDive(const char *prepend, SdFile parent, const char * const m
SdFile dir; SdFile dir;
if (!dir.open(parent, lfilename, O_READ)) { if (!dir.open(parent, lfilename, O_READ)) {
if (lsAction == LS_SerialPrint) { if (lsAction == LS_SerialPrint) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(MSG_SD_CANT_OPEN_SUBDIR); SERIAL_ECHOPGM(MSG_SD_CANT_OPEN_SUBDIR);
SERIAL_ECHOLN(lfilename); SERIAL_ECHOLN(lfilename);
} }
@ -208,8 +208,8 @@ void CardReader::ls() {
// Open the sub-item as the new dive parent // Open the sub-item as the new dive parent
SdFile dir; SdFile dir;
if (!dir.open(diveDir, segment, O_READ)) { if (!dir.open(diveDir, segment, O_READ)) {
SERIAL_EOL; SERIAL_EOL();
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(MSG_SD_CANT_OPEN_SUBDIR); SERIAL_ECHOPGM(MSG_SD_CANT_OPEN_SUBDIR);
SERIAL_ECHO(segment); SERIAL_ECHO(segment);
break; break;
@ -220,7 +220,7 @@ void CardReader::ls() {
} // while i<pathLen } // while i<pathLen
SERIAL_EOL; SERIAL_EOL();
} }
#endif // LONG_FILENAME_HOST_SUPPORT #endif // LONG_FILENAME_HOST_SUPPORT
@ -239,20 +239,20 @@ void CardReader::initsd() {
#endif #endif
) { ) {
//if (!card.init(SPI_HALF_SPEED,SDSS)) //if (!card.init(SPI_HALF_SPEED,SDSS))
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_SD_INIT_FAIL); SERIAL_ECHOLNPGM(MSG_SD_INIT_FAIL);
} }
else if (!volume.init(&card)) { else if (!volume.init(&card)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_SD_VOL_INIT_FAIL); SERIAL_ERRORLNPGM(MSG_SD_VOL_INIT_FAIL);
} }
else if (!root.openRoot(&volume)) { else if (!root.openRoot(&volume)) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_SD_OPENROOT_FAIL); SERIAL_ERRORLNPGM(MSG_SD_OPENROOT_FAIL);
} }
else { else {
cardOK = true; cardOK = true;
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_SD_CARD_OK); SERIAL_ECHOLNPGM(MSG_SD_CARD_OK);
} }
workDir = root; workDir = root;
@ -331,7 +331,7 @@ void CardReader::openFile(char* name, bool read, bool push_current/*=false*/) {
if (isFileOpen()) { //replacing current file by new file, or subfile call if (isFileOpen()) { //replacing current file by new file, or subfile call
if (push_current) { if (push_current) {
if (file_subcall_ctr > SD_PROCEDURE_DEPTH - 1) { if (file_subcall_ctr > SD_PROCEDURE_DEPTH - 1) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORPGM("trying to call sub-gcode files with too many levels. MAX level is:"); SERIAL_ERRORPGM("trying to call sub-gcode files with too many levels. MAX level is:");
SERIAL_ERRORLN(SD_PROCEDURE_DEPTH); SERIAL_ERRORLN(SD_PROCEDURE_DEPTH);
kill(PSTR(MSG_KILLED)); kill(PSTR(MSG_KILLED));
@ -341,7 +341,7 @@ void CardReader::openFile(char* name, bool read, bool push_current/*=false*/) {
// Store current filename and position // Store current filename and position
getAbsFilename(proc_filenames[file_subcall_ctr]); getAbsFilename(proc_filenames[file_subcall_ctr]);
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR("SUBROUTINE CALL target:\"", name); SERIAL_ECHOPAIR("SUBROUTINE CALL target:\"", name);
SERIAL_ECHOPAIR("\" parent:\"", proc_filenames[file_subcall_ctr]); SERIAL_ECHOPAIR("\" parent:\"", proc_filenames[file_subcall_ctr]);
SERIAL_ECHOLNPAIR("\" pos", sdpos); SERIAL_ECHOLNPAIR("\" pos", sdpos);
@ -358,7 +358,7 @@ void CardReader::openFile(char* name, bool read, bool push_current/*=false*/) {
} }
if (doing) { if (doing) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM("Now "); SERIAL_ECHOPGM("Now ");
SERIAL_ECHO(doing == 1 ? "doing" : "fresh"); SERIAL_ECHO(doing == 1 ? "doing" : "fresh");
SERIAL_ECHOLNPAIR(" file: ", name); SERIAL_ECHOLNPAIR(" file: ", name);
@ -421,14 +421,14 @@ void CardReader::openFile(char* name, bool read, bool push_current/*=false*/) {
else { else {
SERIAL_PROTOCOLPAIR(MSG_SD_OPEN_FILE_FAIL, fname); SERIAL_PROTOCOLPAIR(MSG_SD_OPEN_FILE_FAIL, fname);
SERIAL_PROTOCOLCHAR('.'); SERIAL_PROTOCOLCHAR('.');
SERIAL_EOL; SERIAL_EOL();
} }
} }
else { //write else { //write
if (!file.open(curDir, fname, O_CREAT | O_APPEND | O_WRITE | O_TRUNC)) { if (!file.open(curDir, fname, O_CREAT | O_APPEND | O_WRITE | O_TRUNC)) {
SERIAL_PROTOCOLPAIR(MSG_SD_OPEN_FILE_FAIL, fname); SERIAL_PROTOCOLPAIR(MSG_SD_OPEN_FILE_FAIL, fname);
SERIAL_PROTOCOLCHAR('.'); SERIAL_PROTOCOLCHAR('.');
SERIAL_EOL; SERIAL_EOL();
} }
else { else {
saving = true; saving = true;
@ -462,7 +462,7 @@ void CardReader::removeFile(char* name) {
if (!myDir.open(curDir, subdirname, O_READ)) { if (!myDir.open(curDir, subdirname, O_READ)) {
SERIAL_PROTOCOLPAIR("open failed, File: ", subdirname); SERIAL_PROTOCOLPAIR("open failed, File: ", subdirname);
SERIAL_PROTOCOLCHAR('.'); SERIAL_PROTOCOLCHAR('.');
SERIAL_EOL; SERIAL_EOL();
return; return;
} }
else { else {
@ -526,7 +526,7 @@ void CardReader::write_command(char *buf) {
end[3] = '\0'; end[3] = '\0';
file.write(begin); file.write(begin);
if (file.writeError) { if (file.writeError) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM(MSG_SD_ERR_WRITE_TO_FILE); SERIAL_ERRORLNPGM(MSG_SD_ERR_WRITE_TO_FILE);
} }
} }
@ -617,7 +617,7 @@ void CardReader::chdir(const char * relpath) {
if (workDir.isOpen()) parent = &workDir; if (workDir.isOpen()) parent = &workDir;
if (!newfile.open(*parent, relpath, O_READ)) { if (!newfile.open(*parent, relpath, O_READ)) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(MSG_SD_CANT_ENTER_SUBDIR); SERIAL_ECHOPGM(MSG_SD_CANT_ENTER_SUBDIR);
SERIAL_ECHOLN(relpath); SERIAL_ECHOLN(relpath);
} }

66
Marlin/configuration_store.cpp
View File

@ -247,7 +247,7 @@ void MarlinSettings::postprocess() {
#define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR) #define EEPROM_SKIP(VAR) eeprom_index += sizeof(VAR)
#define EEPROM_WRITE(VAR) write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc) #define EEPROM_WRITE(VAR) write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
#define EEPROM_READ(VAR) read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc) #define EEPROM_READ(VAR) read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
#define EEPROM_ASSERT(TST,ERR) if (!(TST)) do{ SERIAL_ERROR_START; SERIAL_ERRORLNPGM(ERR); eeprom_read_error = true; }while(0) #define EEPROM_ASSERT(TST,ERR) if (!(TST)) do{ SERIAL_ERROR_START(); SERIAL_ERRORLNPGM(ERR); eeprom_read_error = true; }while(0)
const char version[4] = EEPROM_VERSION; const char version[4] = EEPROM_VERSION;
@ -267,7 +267,7 @@ void MarlinSettings::postprocess() {
if (v != eeprom_read_byte(p)) { if (v != eeprom_read_byte(p)) {
eeprom_write_byte(p, v); eeprom_write_byte(p, v);
if (eeprom_read_byte(p) != v) { if (eeprom_read_byte(p) != v) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE); SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
eeprom_error = true; eeprom_error = true;
return; return;
@ -638,7 +638,7 @@ void MarlinSettings::postprocess() {
EEPROM_WRITE(final_crc); EEPROM_WRITE(final_crc);
// Report storage size // Report storage size
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR("Settings Stored (", eeprom_size - (EEPROM_OFFSET)); SERIAL_ECHOPAIR("Settings Stored (", eeprom_size - (EEPROM_OFFSET));
SERIAL_ECHOPAIR(" bytes; crc ", final_crc); SERIAL_ECHOPAIR(" bytes; crc ", final_crc);
SERIAL_ECHOLNPGM(")"); SERIAL_ECHOLNPGM(")");
@ -672,7 +672,7 @@ void MarlinSettings::postprocess() {
stored_ver[0] = '?'; stored_ver[0] = '?';
stored_ver[1] = '\0'; stored_ver[1] = '\0';
} }
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM("EEPROM version mismatch "); SERIAL_ECHOPGM("EEPROM version mismatch ");
SERIAL_ECHOPAIR("(EEPROM=", stored_ver); SERIAL_ECHOPAIR("(EEPROM=", stored_ver);
SERIAL_ECHOLNPGM(" Marlin=" EEPROM_VERSION ")"); SERIAL_ECHOLNPGM(" Marlin=" EEPROM_VERSION ")");
@ -981,14 +981,14 @@ void MarlinSettings::postprocess() {
if (working_crc == stored_crc) { if (working_crc == stored_crc) {
postprocess(); postprocess();
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHO(version); SERIAL_ECHO(version);
SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index - (EEPROM_OFFSET)); SERIAL_ECHOPAIR(" stored settings retrieved (", eeprom_index - (EEPROM_OFFSET));
SERIAL_ECHOPAIR(" bytes; crc ", working_crc); SERIAL_ECHOPAIR(" bytes; crc ", working_crc);
SERIAL_ECHOLNPGM(")"); SERIAL_ECHOLNPGM(")");
} }
else { else {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORPGM("EEPROM CRC mismatch - (stored) "); SERIAL_ERRORPGM("EEPROM CRC mismatch - (stored) ");
SERIAL_ERROR(stored_crc); SERIAL_ERROR(stored_crc);
SERIAL_ERRORPGM(" != "); SERIAL_ERRORPGM(" != ");
@ -1004,7 +1004,7 @@ void MarlinSettings::postprocess() {
ubl.report_state(); ubl.report_state();
if (!ubl.sanity_check()) { if (!ubl.sanity_check()) {
SERIAL_EOL; SERIAL_EOL();
ubl.echo_name(); ubl.echo_name();
SERIAL_ECHOLNPGM(" initialized.\n"); SERIAL_ECHOLNPGM(" initialized.\n");
} }
@ -1059,7 +1059,7 @@ void MarlinSettings::postprocess() {
SERIAL_PROTOCOLPAIR("E2END=", E2END); SERIAL_PROTOCOLPAIR("E2END=", E2END);
SERIAL_PROTOCOLPAIR(" meshes_end=", meshes_end); SERIAL_PROTOCOLPAIR(" meshes_end=", meshes_end);
SERIAL_PROTOCOLLNPAIR(" slot=", slot); SERIAL_PROTOCOLLNPAIR(" slot=", slot);
SERIAL_EOL; SERIAL_EOL();
return; return;
} }
@ -1114,7 +1114,7 @@ void MarlinSettings::postprocess() {
#else // !EEPROM_SETTINGS #else // !EEPROM_SETTINGS
bool MarlinSettings::save() { bool MarlinSettings::save() {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("EEPROM disabled"); SERIAL_ERRORLNPGM("EEPROM disabled");
return false; return false;
} }
@ -1315,13 +1315,13 @@ void MarlinSettings::reset() {
postprocess(); postprocess();
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded"); SERIAL_ECHOLNPGM("Hardcoded Default Settings Loaded");
} }
#if DISABLED(DISABLE_M503) #if DISABLED(DISABLE_M503)
#define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START; }while(0) #define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START(); }while(0)
/** /**
* M503 - Report current settings in RAM * M503 - Report current settings in RAM
@ -1365,7 +1365,7 @@ void MarlinSettings::reset() {
#endif #endif
SERIAL_EOL; SERIAL_EOL();
/** /**
* Volumetric extrusion M200 * Volumetric extrusion M200
@ -1374,30 +1374,30 @@ void MarlinSettings::reset() {
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPGM("Filament settings:"); SERIAL_ECHOPGM("Filament settings:");
if (volumetric_enabled) if (volumetric_enabled)
SERIAL_EOL; SERIAL_EOL();
else else
SERIAL_ECHOLNPGM(" Disabled"); SERIAL_ECHOLNPGM(" Disabled");
} }
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M200 D", filament_size[0]); SERIAL_ECHOPAIR(" M200 D", filament_size[0]);
SERIAL_EOL; SERIAL_EOL();
#if EXTRUDERS > 1 #if EXTRUDERS > 1
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]); SERIAL_ECHOPAIR(" M200 T1 D", filament_size[1]);
SERIAL_EOL; SERIAL_EOL();
#if EXTRUDERS > 2 #if EXTRUDERS > 2
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]); SERIAL_ECHOPAIR(" M200 T2 D", filament_size[2]);
SERIAL_EOL; SERIAL_EOL();
#if EXTRUDERS > 3 #if EXTRUDERS > 3
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]); SERIAL_ECHOPAIR(" M200 T3 D", filament_size[3]);
SERIAL_EOL; SERIAL_EOL();
#if EXTRUDERS > 4 #if EXTRUDERS > 4
CONFIG_ECHO_START; CONFIG_ECHO_START;
SERIAL_ECHOPAIR(" M200 T4 D", filament_size[4]); SERIAL_ECHOPAIR(" M200 T4 D", filament_size[4]);
SERIAL_EOL; SERIAL_EOL();
#endif // EXTRUDERS > 4 #endif // EXTRUDERS > 4
#endif // EXTRUDERS > 3 #endif // EXTRUDERS > 3
#endif // EXTRUDERS > 2 #endif // EXTRUDERS > 2
@ -1419,7 +1419,7 @@ void MarlinSettings::reset() {
#if DISABLED(DISTINCT_E_FACTORS) #if DISABLED(DISTINCT_E_FACTORS)
SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS])); SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.axis_steps_per_mm[E_AXIS]));
#endif #endif
SERIAL_EOL; SERIAL_EOL();
#if ENABLED(DISTINCT_E_FACTORS) #if ENABLED(DISTINCT_E_FACTORS)
CONFIG_ECHO_START; CONFIG_ECHO_START;
for (uint8_t i = 0; i < E_STEPPERS; i++) { for (uint8_t i = 0; i < E_STEPPERS; i++) {
@ -1439,7 +1439,7 @@ void MarlinSettings::reset() {
#if DISABLED(DISTINCT_E_FACTORS) #if DISABLED(DISTINCT_E_FACTORS)
SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS])); SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_feedrate_mm_s[E_AXIS]));
#endif #endif
SERIAL_EOL; SERIAL_EOL();
#if ENABLED(DISTINCT_E_FACTORS) #if ENABLED(DISTINCT_E_FACTORS)
CONFIG_ECHO_START; CONFIG_ECHO_START;
for (uint8_t i = 0; i < E_STEPPERS; i++) { for (uint8_t i = 0; i < E_STEPPERS; i++) {
@ -1459,7 +1459,7 @@ void MarlinSettings::reset() {
#if DISABLED(DISTINCT_E_FACTORS) #if DISABLED(DISTINCT_E_FACTORS)
SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS])); SERIAL_ECHOPAIR(" E", VOLUMETRIC_UNIT(planner.max_acceleration_mm_per_s2[E_AXIS]));
#endif #endif
SERIAL_EOL; SERIAL_EOL();
#if ENABLED(DISTINCT_E_FACTORS) #if ENABLED(DISTINCT_E_FACTORS)
CONFIG_ECHO_START; CONFIG_ECHO_START;
for (uint8_t i = 0; i < E_STEPPERS; i++) { for (uint8_t i = 0; i < E_STEPPERS; i++) {
@ -1514,7 +1514,7 @@ void MarlinSettings::reset() {
#if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_NOZZLE) #if ENABLED(DUAL_X_CARRIAGE) || ENABLED(SWITCHING_NOZZLE)
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(hotend_offset[Z_AXIS][e])); SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(hotend_offset[Z_AXIS][e]));
#endif #endif
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -1529,7 +1529,7 @@ void MarlinSettings::reset() {
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height)); SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
#endif #endif
SERIAL_EOL; SERIAL_EOL();
for (uint8_t py = 0; py < GRID_MAX_POINTS_Y; py++) { for (uint8_t py = 0; py < GRID_MAX_POINTS_Y; py++) {
for (uint8_t px = 0; px < GRID_MAX_POINTS_X; px++) { for (uint8_t px = 0; px < GRID_MAX_POINTS_X; px++) {
CONFIG_ECHO_START; CONFIG_ECHO_START;
@ -1537,7 +1537,7 @@ void MarlinSettings::reset() {
SERIAL_ECHOPAIR(" Y", (int)py + 1); SERIAL_ECHOPAIR(" Y", (int)py + 1);
SERIAL_ECHOPGM(" Z"); SERIAL_ECHOPGM(" Z");
SERIAL_PROTOCOL_F(LINEAR_UNIT(mbl.z_values[px][py]), 5); SERIAL_PROTOCOL_F(LINEAR_UNIT(mbl.z_values[px][py]), 5);
SERIAL_EOL; SERIAL_EOL();
} }
} }
@ -1553,17 +1553,17 @@ void MarlinSettings::reset() {
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
SERIAL_ECHOPAIR(" Z", planner.z_fade_height); SERIAL_ECHOPAIR(" Z", planner.z_fade_height);
#endif #endif
SERIAL_EOL; SERIAL_EOL();
if (!forReplay) { if (!forReplay) {
SERIAL_EOL; SERIAL_EOL();
ubl.report_state(); ubl.report_state();
SERIAL_ECHOLNPAIR("\nActive Mesh Slot: ", ubl.state.storage_slot); SERIAL_ECHOLNPAIR("\nActive Mesh Slot: ", ubl.state.storage_slot);
SERIAL_ECHOPGM("z_offset: "); SERIAL_ECHOPGM("z_offset: ");
SERIAL_ECHO_F(ubl.state.z_offset, 6); SERIAL_ECHO_F(ubl.state.z_offset, 6);
SERIAL_EOL; SERIAL_EOL();
SERIAL_ECHOPAIR("EEPROM can hold ", calc_num_meshes()); SERIAL_ECHOPAIR("EEPROM can hold ", calc_num_meshes());
SERIAL_ECHOLNPGM(" meshes.\n"); SERIAL_ECHOLNPGM(" meshes.\n");
@ -1580,7 +1580,7 @@ void MarlinSettings::reset() {
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height)); SERIAL_ECHOPAIR(" Z", LINEAR_UNIT(planner.z_fade_height));
#endif #endif
SERIAL_EOL; SERIAL_EOL();
#endif #endif
@ -1606,7 +1606,7 @@ void MarlinSettings::reset() {
SERIAL_ECHOPAIR(" X", LINEAR_UNIT(delta_tower_angle_trim[A_AXIS])); SERIAL_ECHOPAIR(" X", LINEAR_UNIT(delta_tower_angle_trim[A_AXIS]));
SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(delta_tower_angle_trim[B_AXIS])); SERIAL_ECHOPAIR(" Y", LINEAR_UNIT(delta_tower_angle_trim[B_AXIS]));
SERIAL_ECHOPAIR(" Z", 0.00); SERIAL_ECHOPAIR(" Z", 0.00);
SERIAL_EOL; SERIAL_EOL();
#elif ENABLED(Z_DUAL_ENDSTOPS) #elif ENABLED(Z_DUAL_ENDSTOPS)
if (!forReplay) { if (!forReplay) {
CONFIG_ECHO_START; CONFIG_ECHO_START;
@ -1649,7 +1649,7 @@ void MarlinSettings::reset() {
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, e)); SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, e));
if (e == 0) SERIAL_ECHOPAIR(" L", lpq_len); if (e == 0) SERIAL_ECHOPAIR(" L", lpq_len);
#endif #endif
SERIAL_EOL; SERIAL_EOL();
} }
} }
else else
@ -1664,7 +1664,7 @@ void MarlinSettings::reset() {
SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, 0)); SERIAL_ECHOPAIR(" C", PID_PARAM(Kc, 0));
SERIAL_ECHOPAIR(" L", lpq_len); SERIAL_ECHOPAIR(" L", lpq_len);
#endif #endif
SERIAL_EOL; SERIAL_EOL();
} }
#endif // PIDTEMP #endif // PIDTEMP
@ -1673,7 +1673,7 @@ void MarlinSettings::reset() {
SERIAL_ECHOPAIR(" M304 P", thermalManager.bedKp); SERIAL_ECHOPAIR(" M304 P", thermalManager.bedKp);
SERIAL_ECHOPAIR(" I", unscalePID_i(thermalManager.bedKi)); SERIAL_ECHOPAIR(" I", unscalePID_i(thermalManager.bedKi));
SERIAL_ECHOPAIR(" D", unscalePID_d(thermalManager.bedKd)); SERIAL_ECHOPAIR(" D", unscalePID_d(thermalManager.bedKd));
SERIAL_EOL; SERIAL_EOL();
#endif #endif
#endif // PIDTEMP || PIDTEMPBED #endif // PIDTEMP || PIDTEMPBED
@ -1773,7 +1773,7 @@ void MarlinSettings::reset() {
#if ENABLED(E3_IS_TMC2130) #if ENABLED(E3_IS_TMC2130)
SERIAL_ECHOPAIR(" E3", stepperE3.getCurrent()); SERIAL_ECHOPAIR(" E3", stepperE3.getCurrent());
#endif #endif
SERIAL_EOL; SERIAL_EOL();
#endif #endif
/** /**

4
Marlin/endstops.cpp
View File

@ -161,7 +161,7 @@ void Endstops::report_state() {
#define ENDSTOP_HIT_TEST_Y() _ENDSTOP_HIT_TEST(Y,'Y') #define ENDSTOP_HIT_TEST_Y() _ENDSTOP_HIT_TEST(Y,'Y')
#define ENDSTOP_HIT_TEST_Z() _ENDSTOP_HIT_TEST(Z,'Z') #define ENDSTOP_HIT_TEST_Z() _ENDSTOP_HIT_TEST(Z,'Z')
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(MSG_ENDSTOPS_HIT); SERIAL_ECHOPGM(MSG_ENDSTOPS_HIT);
ENDSTOP_HIT_TEST_X(); ENDSTOP_HIT_TEST_X();
ENDSTOP_HIT_TEST_Y(); ENDSTOP_HIT_TEST_Y();
@ -171,7 +171,7 @@ void Endstops::report_state() {
#define P_AXIS Z_AXIS #define P_AXIS Z_AXIS
if (TEST(endstop_hit_bits, Z_MIN_PROBE)) _ENDSTOP_HIT_ECHO(P, 'P'); if (TEST(endstop_hit_bits, Z_MIN_PROBE)) _ENDSTOP_HIT_ECHO(P, 'P');
#endif #endif
SERIAL_EOL; SERIAL_EOL();
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTRA_LCD)
lcd_status_printf_P(0, PSTR(MSG_LCD_ENDSTOPS " %c %c %c %c"), chrX, chrY, chrZ, chrP); lcd_status_printf_P(0, PSTR(MSG_LCD_ENDSTOPS " %c %c %c %c"), chrX, chrY, chrZ, chrP);

6
Marlin/gcode.cpp
View File

@ -203,7 +203,7 @@ void GCodeParser::parse(char *p) {
} }
#if ENABLED(DEBUG_GCODE_PARSER) #if ENABLED(DEBUG_GCODE_PARSER)
if (debug) SERIAL_EOL; if (debug) SERIAL_EOL();
#endif #endif
#if ENABLED(FASTER_GCODE_PARSER) #if ENABLED(FASTER_GCODE_PARSER)
@ -229,10 +229,10 @@ void GCodeParser::parse(char *p) {
} }
void GCodeParser::unknown_command_error() { void GCodeParser::unknown_command_error() {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR(MSG_UNKNOWN_COMMAND, command_ptr); SERIAL_ECHOPAIR(MSG_UNKNOWN_COMMAND, command_ptr);
SERIAL_CHAR('"'); SERIAL_CHAR('"');
SERIAL_EOL; SERIAL_EOL();
} }
#if ENABLED(DEBUG_GCODE_PARSER) #if ENABLED(DEBUG_GCODE_PARSER)

10
Marlin/gcode.h
View File

@ -128,9 +128,7 @@ public:
return b; return b;
} }
static volatile bool seen_any() { static volatile bool seen_any() { return codebits[3] || codebits[2] || codebits[1] || codebits[0]; }
return codebits[3] || codebits[2] || codebits[1] || codebits[0];
}
#define SEEN_TEST(L) TEST(codebits[(L - 'A') >> 3], (L - 'A') & 0x7) #define SEEN_TEST(L) TEST(codebits[(L - 'A') >> 3], (L - 'A') & 0x7)
@ -145,9 +143,7 @@ public:
return b; return b;
} }
static volatile bool seen_any() { static volatile bool seen_any() { return *command_args == '\0'; }
return *command_args == '\0';
}
#define SEEN_TEST(L) !!strchr(command_args, L) #define SEEN_TEST(L) !!strchr(command_args, L)
@ -207,7 +203,7 @@ public:
#if ENABLED(INCH_MODE_SUPPORT) #if ENABLED(INCH_MODE_SUPPORT)
inline static void set_input_linear_units(LinearUnit units) { inline static void set_input_linear_units(const LinearUnit units) {
switch (units) { switch (units) {
case LINEARUNIT_INCH: case LINEARUNIT_INCH:
linear_unit_factor = 25.4; linear_unit_factor = 25.4;

338
Marlin/language_en.h
View File

@ -163,176 +163,174 @@
#define MSG_USER_MENU _UxGT("Custom Commands") #define MSG_USER_MENU _UxGT("Custom Commands")
#endif #endif
#if ENABLED(AUTO_BED_LEVELING_UBL) #ifndef MSG_UBL_DOING_G29
#ifndef MSG_UBL_DOING_G29 #define MSG_UBL_DOING_G29 _UxGT("Doing G29")
#define MSG_UBL_DOING_G29 _UxGT("Doing G29 UBL!") #endif
#endif #ifndef MSG_UBL_UNHOMED
#ifndef MSG_UBL_UNHOMED #define MSG_UBL_UNHOMED _UxGT("Home XYZ first")
#define MSG_UBL_UNHOMED _UxGT("Home XYZ first") #endif
#endif #ifndef MSG_UBL_TOOLS
#ifndef MSG_UBL_TOOLS #define MSG_UBL_TOOLS _UxGT("UBL Tools")
#define MSG_UBL_TOOLS _UxGT("UBL Tools") #endif
#endif #ifndef MSG_UBL_LEVEL_BED
#ifndef MSG_UBL_LEVEL_BED #define MSG_UBL_LEVEL_BED _UxGT("Unified Bed Leveling")
#define MSG_UBL_LEVEL_BED _UxGT("Unified Bed Leveling") #endif
#endif #ifndef MSG_UBL_MANUAL_MESH
#ifndef MSG_UBL_MANUAL_MESH #define MSG_UBL_MANUAL_MESH _UxGT("Manually Build Mesh")
#define MSG_UBL_MANUAL_MESH _UxGT("Manually Build Mesh") #endif
#endif #ifndef MSG_UBL_BC_INSERT
#ifndef MSG_UBL_BC_INSERT #define MSG_UBL_BC_INSERT _UxGT("Place shim & measure")
#define MSG_UBL_BC_INSERT _UxGT("Place shim & measure") #endif
#endif #ifndef MSG_UBL_BC_INSERT2
#ifndef MSG_UBL_BC_INSERT2 #define MSG_UBL_BC_INSERT2 _UxGT("Measure")
#define MSG_UBL_BC_INSERT2 _UxGT("Measure") #endif
#endif #ifndef MSG_UBL_BC_REMOVE
#ifndef MSG_UBL_BC_REMOVE #define MSG_UBL_BC_REMOVE _UxGT("Remove & measure bed")
#define MSG_UBL_BC_REMOVE _UxGT("Remove & measure bed") #endif
#endif #ifndef MSG_UBL_MOVING_TO_NEXT
#ifndef MSG_UBL_MOVING_TO_NEXT #define MSG_UBL_MOVING_TO_NEXT _UxGT("Moving to next")
#define MSG_UBL_MOVING_TO_NEXT _UxGT("Moving to next") #endif
#endif #ifndef MSG_UBL_ACTIVATE_MESH
#ifndef MSG_UBL_ACTIVATE_MESH #define MSG_UBL_ACTIVATE_MESH _UxGT("Activate UBL")
#define MSG_UBL_ACTIVATE_MESH _UxGT("Activate UBL") #endif
#endif #ifndef MSG_UBL_DEACTIVATE_MESH
#ifndef MSG_UBL_DEACTIVATE_MESH #define MSG_UBL_DEACTIVATE_MESH _UxGT("Deactivate UBL")
#define MSG_UBL_DEACTIVATE_MESH _UxGT("Deactivate UBL") #endif
#endif #ifndef MSG_UBL_SET_BED_TEMP
#ifndef MSG_UBL_SET_BED_TEMP #define MSG_UBL_SET_BED_TEMP _UxGT("Bed Temp")
#define MSG_UBL_SET_BED_TEMP _UxGT("Bed Temp") #endif
#endif #ifndef MSG_UBL_CUSTOM_BED_TEMP
#ifndef MSG_UBL_CUSTOM_BED_TEMP #define MSG_UBL_CUSTOM_BED_TEMP MSG_UBL_SET_BED_TEMP
#define MSG_UBL_CUSTOM_BED_TEMP MSG_UBL_SET_BED_TEMP #endif
#endif #ifndef MSG_UBL_SET_HOTEND_TEMP
#ifndef MSG_UBL_SET_HOTEND_TEMP #define MSG_UBL_SET_HOTEND_TEMP _UxGT("Hotend Temp")
#define MSG_UBL_SET_HOTEND_TEMP _UxGT("Hotend Temp") #endif
#endif #ifndef MSG_UBL_CUSTOM_HOTEND_TEMP
#ifndef MSG_UBL_CUSTOM_HOTEND_TEMP #define MSG_UBL_CUSTOM_HOTEND_TEMP MSG_UBL_SET_HOTEND_TEMP
#define MSG_UBL_CUSTOM_HOTEND_TEMP MSG_UBL_SET_HOTEND_TEMP #endif
#endif #ifndef MSG_UBL_EDIT_CUSTOM_MESH
#ifndef MSG_UBL_EDIT_CUSTOM_MESH #define MSG_UBL_EDIT_CUSTOM_MESH _UxGT("Edit Custom Mesh")
#define MSG_UBL_EDIT_CUSTOM_MESH _UxGT("Edit Custom Mesh") #endif
#endif #ifndef MSG_UBL_FINE_TUNE_MESH
#ifndef MSG_UBL_FINE_TUNE_MESH #define MSG_UBL_FINE_TUNE_MESH _UxGT("Fine Tuning Mesh")
#define MSG_UBL_FINE_TUNE_MESH _UxGT("Fine Tuning Mesh") #endif
#endif #ifndef MSG_UBL_DONE_EDITING_MESH
#ifndef MSG_UBL_DONE_EDITING_MESH #define MSG_UBL_DONE_EDITING_MESH _UxGT("Done Editing Mesh")
#define MSG_UBL_DONE_EDITING_MESH _UxGT("Done Editing Mesh") #endif
#endif #ifndef MSG_UBL_BUILD_CUSTOM_MESH
#ifndef MSG_UBL_BUILD_CUSTOM_MESH #define MSG_UBL_BUILD_CUSTOM_MESH _UxGT("Build Custom Mesh")
#define MSG_UBL_BUILD_CUSTOM_MESH _UxGT("Build Custom Mesh") #endif
#endif #ifndef MSG_UBL_BUILD_MESH_MENU
#ifndef MSG_UBL_BUILD_MESH_MENU #define MSG_UBL_BUILD_MESH_MENU _UxGT("Build Mesh")
#define MSG_UBL_BUILD_MESH_MENU _UxGT("Build Mesh") #endif
#endif #ifndef MSG_UBL_BUILD_PLA_MESH
#ifndef MSG_UBL_BUILD_PLA_MESH #define MSG_UBL_BUILD_PLA_MESH _UxGT("Build PLA Mesh")
#define MSG_UBL_BUILD_PLA_MESH _UxGT("Build PLA Mesh") #endif
#endif #ifndef MSG_UBL_BUILD_ABS_MESH
#ifndef MSG_UBL_BUILD_ABS_MESH #define MSG_UBL_BUILD_ABS_MESH _UxGT("Build ABS Mesh")
#define MSG_UBL_BUILD_ABS_MESH _UxGT("Build ABS Mesh") #endif
#endif #ifndef MSG_UBL_BUILD_COLD_MESH
#ifndef MSG_UBL_BUILD_COLD_MESH #define MSG_UBL_BUILD_COLD_MESH _UxGT("Build Cold Mesh")
#define MSG_UBL_BUILD_COLD_MESH _UxGT("Build Cold Mesh") #endif
#endif #ifndef MSG_UBL_MESH_HEIGHT_ADJUST
#ifndef MSG_UBL_MESH_HEIGHT_ADJUST #define MSG_UBL_MESH_HEIGHT_ADJUST _UxGT("Adjust Mesh Height")
#define MSG_UBL_MESH_HEIGHT_ADJUST _UxGT("Adjust Mesh Height") #endif
#endif #ifndef MSG_UBL_MESH_HEIGHT_AMOUNT
#ifndef MSG_UBL_MESH_HEIGHT_AMOUNT #define MSG_UBL_MESH_HEIGHT_AMOUNT _UxGT("Height Amount")
#define MSG_UBL_MESH_HEIGHT_AMOUNT _UxGT("Height Amount") #endif
#endif #ifndef MSG_UBL_VALIDATE_MESH_MENU
#ifndef MSG_UBL_VALIDATE_MESH_MENU #define MSG_UBL_VALIDATE_MESH_MENU _UxGT("Validate Mesh")
#define MSG_UBL_VALIDATE_MESH_MENU _UxGT("Validate Mesh") #endif
#endif #ifndef MSG_UBL_VALIDATE_PLA_MESH
#ifndef MSG_UBL_VALIDATE_PLA_MESH #define MSG_UBL_VALIDATE_PLA_MESH _UxGT("Validate PLA Mesh")
#define MSG_UBL_VALIDATE_PLA_MESH _UxGT("Validate PLA Mesh") #endif
#endif #ifndef MSG_UBL_VALIDATE_ABS_MESH
#ifndef MSG_UBL_VALIDATE_ABS_MESH #define MSG_UBL_VALIDATE_ABS_MESH _UxGT("Validate ABS Mesh")
#define MSG_UBL_VALIDATE_ABS_MESH _UxGT("Validate ABS Mesh") #endif
#endif #ifndef MSG_UBL_VALIDATE_CUSTOM_MESH
#ifndef MSG_UBL_VALIDATE_CUSTOM_MESH #define MSG_UBL_VALIDATE_CUSTOM_MESH _UxGT("Validate Custom Mesh")
#define MSG_UBL_VALIDATE_CUSTOM_MESH _UxGT("Validate Custom Mesh") #endif
#endif #ifndef MSG_UBL_CONTINUE_MESH
#ifndef MSG_UBL_CONTINUE_MESH #define MSG_UBL_CONTINUE_MESH _UxGT("Continue Bed Mesh")
#define MSG_UBL_CONTINUE_MESH _UxGT("Continue Bed Mesh") #endif
#endif #ifndef MSG_UBL_MESH_LEVELING
#ifndef MSG_UBL_MESH_LEVELING #define MSG_UBL_MESH_LEVELING _UxGT("Mesh Leveling")
#define MSG_UBL_MESH_LEVELING _UxGT("Mesh Leveling") #endif
#endif #ifndef MSG_UBL_3POINT_MESH_LEVELING
#ifndef MSG_UBL_3POINT_MESH_LEVELING #define MSG_UBL_3POINT_MESH_LEVELING _UxGT("3-Point Leveling")
#define MSG_UBL_3POINT_MESH_LEVELING _UxGT("3-Point Leveling") #endif
#endif #ifndef MSG_UBL_GRID_MESH_LEVELING
#ifndef MSG_UBL_GRID_MESH_LEVELING #define MSG_UBL_GRID_MESH_LEVELING _UxGT("Grid Mesh Leveling")
#define MSG_UBL_GRID_MESH_LEVELING _UxGT("Grid Mesh Leveling") #endif
#endif #ifndef MSG_UBL_MESH_LEVEL
#ifndef MSG_UBL_MESH_LEVEL #define MSG_UBL_MESH_LEVEL _UxGT("Level Mesh")
#define MSG_UBL_MESH_LEVEL _UxGT("Level Mesh") #endif
#endif #ifndef MSG_UBL_SIDE_POINTS
#ifndef MSG_UBL_SIDE_POINTS #define MSG_UBL_SIDE_POINTS _UxGT("Side Points")
#define MSG_UBL_SIDE_POINTS _UxGT("Side Points") #endif
#endif #ifndef MSG_UBL_MAP_TYPE
#ifndef MSG_UBL_MAP_TYPE #define MSG_UBL_MAP_TYPE _UxGT("Map Type")
#define MSG_UBL_MAP_TYPE _UxGT("Map Type") #endif
#endif #ifndef MSG_UBL_OUTPUT_MAP
#ifndef MSG_UBL_OUTPUT_MAP #define MSG_UBL_OUTPUT_MAP _UxGT("Output Mesh Map")
#define MSG_UBL_OUTPUT_MAP _UxGT("Output Mesh Map") #endif
#endif #ifndef MSG_UBL_OUTPUT_MAP_HOST
#ifndef MSG_UBL_OUTPUT_MAP_HOST #define MSG_UBL_OUTPUT_MAP_HOST _UxGT("Output for Host")
#define MSG_UBL_OUTPUT_MAP_HOST _UxGT("Output for Host") #endif
#endif #ifndef MSG_UBL_OUTPUT_MAP_CSV
#ifndef MSG_UBL_OUTPUT_MAP_CSV #define MSG_UBL_OUTPUT_MAP_CSV _UxGT("Output for CSV")
#define MSG_UBL_OUTPUT_MAP_CSV _UxGT("Output for CSV") #endif
#endif #ifndef MSG_UBL_INFO_UBL
#ifndef MSG_UBL_INFO_UBL #define MSG_UBL_INFO_UBL _UxGT("Output UBL Info")
#define MSG_UBL_INFO_UBL _UxGT("Output UBL Info") #endif
#endif #ifndef MSG_UBL_EDIT_MESH_MENU
#ifndef MSG_UBL_EDIT_MESH_MENU #define MSG_UBL_EDIT_MESH_MENU _UxGT("Edit Mesh")
#define MSG_UBL_EDIT_MESH_MENU _UxGT("Edit Mesh") #endif
#endif #ifndef MSG_UBL_FILLIN_AMOUNT
#ifndef MSG_UBL_FILLIN_AMOUNT #define MSG_UBL_FILLIN_AMOUNT _UxGT("Fill-in Amount")
#define MSG_UBL_FILLIN_AMOUNT _UxGT("Fill-in Amount") #endif
#endif #ifndef MSG_UBL_MANUAL_FILLIN
#ifndef MSG_UBL_MANUAL_FILLIN #define MSG_UBL_MANUAL_FILLIN _UxGT("Manual Fill-in")
#define MSG_UBL_MANUAL_FILLIN _UxGT("Manual Fill-in") #endif
#endif #ifndef MSG_UBL_SMART_FILLIN
#ifndef MSG_UBL_SMART_FILLIN #define MSG_UBL_SMART_FILLIN _UxGT("Smart Fill-in")
#define MSG_UBL_SMART_FILLIN _UxGT("Smart Fill-in") #endif
#endif #ifndef MSG_UBL_FILLIN_MESH
#ifndef MSG_UBL_FILLIN_MESH #define MSG_UBL_FILLIN_MESH _UxGT("Fill-in Mesh")
#define MSG_UBL_FILLIN_MESH _UxGT("Fill-in Mesh") #endif
#endif #ifndef MSG_UBL_INVALIDATE_ALL
#ifndef MSG_UBL_INVALIDATE_ALL #define MSG_UBL_INVALIDATE_ALL _UxGT("Invalidate All")
#define MSG_UBL_INVALIDATE_ALL _UxGT("Invalidate All") #endif
#endif #ifndef MSG_UBL_INVALIDATE_CLOSEST
#ifndef MSG_UBL_INVALIDATE_CLOSEST #define MSG_UBL_INVALIDATE_CLOSEST _UxGT("Invalidate Closest")
#define MSG_UBL_INVALIDATE_CLOSEST _UxGT("Invalidate Closest") #endif
#endif #ifndef MSG_UBL_FINE_TUNE_ALL
#ifndef MSG_UBL_FINE_TUNE_ALL #define MSG_UBL_FINE_TUNE_ALL _UxGT("Fine Tune All")
#define MSG_UBL_FINE_TUNE_ALL _UxGT("Fine Tune All") #endif
#endif #ifndef MSG_UBL_FINE_TUNE_CLOSEST
#ifndef MSG_UBL_FINE_TUNE_CLOSEST #define MSG_UBL_FINE_TUNE_CLOSEST _UxGT("Fine Tune Closest")
#define MSG_UBL_FINE_TUNE_CLOSEST _UxGT("Fine Tune Closest") #endif
#endif #ifndef MSG_UBL_STORAGE_MESH_MENU
#ifndef MSG_UBL_STORAGE_MESH_MENU #define MSG_UBL_STORAGE_MESH_MENU _UxGT("Mesh Storage")
#define MSG_UBL_STORAGE_MESH_MENU _UxGT("Mesh Storage") #endif
#endif #ifndef MSG_UBL_STORAGE_SLOT
#ifndef MSG_UBL_STORAGE_SLOT #define MSG_UBL_STORAGE_SLOT _UxGT("Memory Slot")
#define MSG_UBL_STORAGE_SLOT _UxGT("Memory Slot") #endif
#endif #ifndef MSG_UBL_LOAD_MESH
#ifndef MSG_UBL_LOAD_MESH #define MSG_UBL_LOAD_MESH _UxGT("Load Bed Mesh")
#define MSG_UBL_LOAD_MESH _UxGT("Load Bed Mesh") #endif
#endif #ifndef MSG_UBL_SAVE_MESH
#ifndef MSG_UBL_SAVE_MESH #define MSG_UBL_SAVE_MESH _UxGT("Save Bed Mesh")
#define MSG_UBL_SAVE_MESH _UxGT("Save Bed Mesh") #endif
#endif #ifndef MSG_UBL_SAVE_ERROR
#ifndef MSG_UBL_SAVE_ERROR #define MSG_UBL_SAVE_ERROR _UxGT("Err: UBL Save")
#define MSG_UBL_SAVE_ERROR _UxGT("save_UBL_active() error") #endif
#endif #ifndef MSG_UBL_RESTORE_ERROR
#ifndef MSG_UBL_RESTORE_ERROR #define MSG_UBL_RESTORE_ERROR _UxGT("Err: UBL Restore")
#define MSG_UBL_RESTORE_ERROR _UxGT("restore_UBL_active() error") #endif
#endif #ifndef MSG_UBL_Z_OFFSET_STOPPED
#ifndef MSG_UBL_Z_OFFSET_STOPPED #define MSG_UBL_Z_OFFSET_STOPPED _UxGT("Z-Offset Stopped")
#define MSG_UBL_Z_OFFSET_STOPPED _UxGT("Z-Offset Stopped") #endif
#endif
#endif // AUTO_BED_LEVELING_UBL
#ifndef MSG_MOVING #ifndef MSG_MOVING
#define MSG_MOVING _UxGT("Moving...") #define MSG_MOVING _UxGT("Moving...")

4
Marlin/pinsDebug.h
View File

@ -452,7 +452,7 @@ inline void report_pin_state_extended(int8_t pin, bool ignore, bool extended = t
} }
if (!multi_name_pin && extended) pwm_details(pin); // report PWM capabilities only on the first pass & only if doing an extended report if (!multi_name_pin && extended) pwm_details(pin); // report PWM capabilities only on the first pass & only if doing an extended report
} }
SERIAL_EOL; SERIAL_EOL();
} // end of IF } // end of IF
} // end of for loop } // end of for loop
@ -483,7 +483,7 @@ inline void report_pin_state_extended(int8_t pin, bool ignore, bool extended = t
} }
//if (!pwm_status(pin)) SERIAL_CHAR(' '); // add padding if it's not a PWM pin //if (!pwm_status(pin)) SERIAL_CHAR(' '); // add padding if it's not a PWM pin
if (extended) pwm_details(pin); // report PWM capabilities only if doing an extended report if (extended) pwm_details(pin); // report PWM capabilities only if doing an extended report
SERIAL_EOL; SERIAL_EOL();
} }
} }

8
Marlin/planner.cpp
View File

@ -740,7 +740,7 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
#endif #endif
SERIAL_ECHOPAIR(" (", dc); SERIAL_ECHOPAIR(" (", dc);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
//*/ //*/
// DRYRUN ignores all temperature constraints and assures that the extruder is instantly satisfied // DRYRUN ignores all temperature constraints and assures that the extruder is instantly satisfied
@ -766,7 +766,7 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
position_float[E_AXIS] = e; position_float[E_AXIS] = e;
de_float = 0; de_float = 0;
#endif #endif
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP); SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP);
} }
#if ENABLED(PREVENT_LENGTHY_EXTRUDE) #if ENABLED(PREVENT_LENGTHY_EXTRUDE)
@ -777,7 +777,7 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
position_float[E_AXIS] = e; position_float[E_AXIS] = e;
de_float = 0; de_float = 0;
#endif #endif
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP); SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP);
} }
#endif #endif
@ -1420,7 +1420,7 @@ void Planner::_buffer_line(const float &a, const float &b, const float &c, const
block->advance_rate = block->advance = 0; block->advance_rate = block->advance = 0;
/** /**
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM("advance :"); SERIAL_ECHOPGM("advance :");
SERIAL_ECHO(block->advance/256.0); SERIAL_ECHO(block->advance/256.0);
SERIAL_ECHOPGM("advance rate :"); SERIAL_ECHOPGM("advance rate :");

6
Marlin/printcounter.cpp
View File

@ -108,7 +108,7 @@ void PrintCounter::showStats() {
SERIAL_ECHO(this->data.totalPrints - this->data.finishedPrints SERIAL_ECHO(this->data.totalPrints - this->data.finishedPrints
- ((this->isRunning() || this->isPaused()) ? 1 : 0)); - ((this->isRunning() || this->isPaused()) ? 1 : 0));
SERIAL_EOL; SERIAL_EOL();
SERIAL_PROTOCOLPGM(MSG_STATS); SERIAL_PROTOCOLPGM(MSG_STATS);
elapsed = this->data.printTime; elapsed = this->data.printTime;
@ -135,14 +135,14 @@ void PrintCounter::showStats() {
SERIAL_CHAR(')'); SERIAL_CHAR(')');
#endif #endif
SERIAL_EOL; SERIAL_EOL();
SERIAL_PROTOCOLPGM(MSG_STATS); SERIAL_PROTOCOLPGM(MSG_STATS);
SERIAL_ECHOPGM("Filament used: "); SERIAL_ECHOPGM("Filament used: ");
SERIAL_ECHO(this->data.filamentUsed / 1000); SERIAL_ECHO(this->data.filamentUsed / 1000);
SERIAL_ECHOPGM("m"); SERIAL_ECHOPGM("m");
SERIAL_EOL; SERIAL_EOL();
} }
void PrintCounter::tick() { void PrintCounter::tick() {

10
Marlin/serial.h
View File

@ -41,18 +41,18 @@ extern const char echomagic[] PROGMEM;
extern const char errormagic[] PROGMEM; extern const char errormagic[] PROGMEM;
#define SERIAL_CHAR(x) (MYSERIAL.write(x)) #define SERIAL_CHAR(x) (MYSERIAL.write(x))
#define SERIAL_EOL SERIAL_CHAR('\n') #define SERIAL_EOL() SERIAL_CHAR('\n')
#define SERIAL_PROTOCOLCHAR(x) SERIAL_CHAR(x) #define SERIAL_PROTOCOLCHAR(x) SERIAL_CHAR(x)
#define SERIAL_PROTOCOL(x) (MYSERIAL.print(x)) #define SERIAL_PROTOCOL(x) (MYSERIAL.print(x))
#define SERIAL_PROTOCOL_F(x,y) (MYSERIAL.print(x,y)) #define SERIAL_PROTOCOL_F(x,y) (MYSERIAL.print(x,y))
#define SERIAL_PROTOCOLPGM(x) (serialprintPGM(PSTR(x))) #define SERIAL_PROTOCOLPGM(x) (serialprintPGM(PSTR(x)))
#define SERIAL_PROTOCOLLN(x) do{ MYSERIAL.print(x); SERIAL_EOL; }while(0) #define SERIAL_PROTOCOLLN(x) do{ MYSERIAL.print(x); SERIAL_EOL(); }while(0)
#define SERIAL_PROTOCOLLNPGM(x) (serialprintPGM(PSTR(x "\n"))) #define SERIAL_PROTOCOLLNPGM(x) (serialprintPGM(PSTR(x "\n")))
#define SERIAL_PROTOCOLPAIR(name, value) (serial_echopair_P(PSTR(name),(value))) #define SERIAL_PROTOCOLPAIR(name, value) (serial_echopair_P(PSTR(name),(value)))
#define SERIAL_PROTOCOLLNPAIR(name, value) do{ SERIAL_PROTOCOLPAIR(name, value); SERIAL_EOL; }while(0) #define SERIAL_PROTOCOLLNPAIR(name, value) do{ SERIAL_PROTOCOLPAIR(name, value); SERIAL_EOL(); }while(0)
#define SERIAL_ECHO_START (serialprintPGM(echomagic)) #define SERIAL_ECHO_START() (serialprintPGM(echomagic))
#define SERIAL_ECHO(x) SERIAL_PROTOCOL(x) #define SERIAL_ECHO(x) SERIAL_PROTOCOL(x)
#define SERIAL_ECHOPGM(x) SERIAL_PROTOCOLPGM(x) #define SERIAL_ECHOPGM(x) SERIAL_PROTOCOLPGM(x)
#define SERIAL_ECHOLN(x) SERIAL_PROTOCOLLN(x) #define SERIAL_ECHOLN(x) SERIAL_PROTOCOLLN(x)
@ -61,7 +61,7 @@ extern const char errormagic[] PROGMEM;
#define SERIAL_ECHOLNPAIR(name, value) SERIAL_PROTOCOLLNPAIR(name, value) #define SERIAL_ECHOLNPAIR(name, value) SERIAL_PROTOCOLLNPAIR(name, value)
#define SERIAL_ECHO_F(x,y) SERIAL_PROTOCOL_F(x,y) #define SERIAL_ECHO_F(x,y) SERIAL_PROTOCOL_F(x,y)
#define SERIAL_ERROR_START (serialprintPGM(errormagic)) #define SERIAL_ERROR_START() (serialprintPGM(errormagic))
#define SERIAL_ERROR(x) SERIAL_PROTOCOL(x) #define SERIAL_ERROR(x) SERIAL_PROTOCOL(x)
#define SERIAL_ERRORPGM(x) SERIAL_PROTOCOLPGM(x) #define SERIAL_ERRORPGM(x) SERIAL_PROTOCOLPGM(x)
#define SERIAL_ERRORLN(x) SERIAL_PROTOCOLLN(x) #define SERIAL_ERRORLN(x) SERIAL_PROTOCOLLN(x)

2
Marlin/stepper.cpp
View File

@ -1305,7 +1305,7 @@ void Stepper::report_positions() {
#endif #endif
SERIAL_PROTOCOL(zpos); SERIAL_PROTOCOL(zpos);
SERIAL_EOL; SERIAL_EOL();
} }
#if ENABLED(BABYSTEPPING) #if ENABLED(BABYSTEPPING)

2
Marlin/stepper.h
View File

@ -369,7 +369,7 @@ class Stepper {
} }
#endif #endif
// SERIAL_ECHO_START; // SERIAL_ECHO_START();
// SERIAL_ECHOPGM("advance :"); // SERIAL_ECHOPGM("advance :");
// SERIAL_ECHO(current_block->advance/256.0); // SERIAL_ECHO(current_block->advance/256.0);
// SERIAL_ECHOPGM("advance rate :"); // SERIAL_ECHOPGM("advance rate :");

4
Marlin/stepper_dac.cpp
View File

@ -103,9 +103,9 @@
void dac_print_values() { void dac_print_values() {
if (!dac_present) return; if (!dac_present) return;
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM("Stepper current values in % (Amps):"); SERIAL_ECHOLNPGM("Stepper current values in % (Amps):");
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR(" X:", dac_perc(X_AXIS)); SERIAL_ECHOPAIR(" X:", dac_perc(X_AXIS));
SERIAL_ECHOPAIR(" (", dac_amps(X_AXIS)); SERIAL_ECHOPAIR(" (", dac_amps(X_AXIS));
SERIAL_ECHOPAIR(") Y:", dac_perc(Y_AXIS)); SERIAL_ECHOPAIR(") Y:", dac_perc(Y_AXIS));

36
Marlin/temperature.cpp
View File

@ -389,7 +389,7 @@ uint8_t Temperature::soft_pwm_amount[HOTENDS],
if (ELAPSED(ms, temp_ms + 2000UL)) { if (ELAPSED(ms, temp_ms + 2000UL)) {
#if HAS_TEMP_HOTEND || HAS_TEMP_BED #if HAS_TEMP_HOTEND || HAS_TEMP_BED
print_heaterstates(); print_heaterstates();
SERIAL_EOL; SERIAL_EOL();
#endif #endif
temp_ms = ms; temp_ms = ms;
@ -404,17 +404,17 @@ uint8_t Temperature::soft_pwm_amount[HOTENDS],
#if HAS_PID_FOR_BOTH #if HAS_PID_FOR_BOTH
const char* estring = hotend < 0 ? "bed" : ""; const char* estring = hotend < 0 ? "bed" : "";
SERIAL_PROTOCOLPAIR("#define DEFAULT_", estring); SERIAL_PROTOCOLPAIR("Kp ", workKp); SERIAL_EOL; SERIAL_PROTOCOLPAIR("#define DEFAULT_", estring); SERIAL_PROTOCOLPAIR("Kp ", workKp); SERIAL_EOL();
SERIAL_PROTOCOLPAIR("#define DEFAULT_", estring); SERIAL_PROTOCOLPAIR("Ki ", workKi); SERIAL_EOL; SERIAL_PROTOCOLPAIR("#define DEFAULT_", estring); SERIAL_PROTOCOLPAIR("Ki ", workKi); SERIAL_EOL();
SERIAL_PROTOCOLPAIR("#define DEFAULT_", estring); SERIAL_PROTOCOLPAIR("Kd ", workKd); SERIAL_EOL; SERIAL_PROTOCOLPAIR("#define DEFAULT_", estring); SERIAL_PROTOCOLPAIR("Kd ", workKd); SERIAL_EOL();
#elif ENABLED(PIDTEMP) #elif ENABLED(PIDTEMP)
SERIAL_PROTOCOLPAIR("#define DEFAULT_Kp ", workKp); SERIAL_EOL; SERIAL_PROTOCOLPAIR("#define DEFAULT_Kp ", workKp); SERIAL_EOL();
SERIAL_PROTOCOLPAIR("#define DEFAULT_Ki ", workKi); SERIAL_EOL; SERIAL_PROTOCOLPAIR("#define DEFAULT_Ki ", workKi); SERIAL_EOL();
SERIAL_PROTOCOLPAIR("#define DEFAULT_Kd ", workKd); SERIAL_EOL; SERIAL_PROTOCOLPAIR("#define DEFAULT_Kd ", workKd); SERIAL_EOL();
#else #else
SERIAL_PROTOCOLPAIR("#define DEFAULT_bedKp ", workKp); SERIAL_EOL; SERIAL_PROTOCOLPAIR("#define DEFAULT_bedKp ", workKp); SERIAL_EOL();
SERIAL_PROTOCOLPAIR("#define DEFAULT_bedKi ", workKi); SERIAL_EOL; SERIAL_PROTOCOLPAIR("#define DEFAULT_bedKi ", workKi); SERIAL_EOL();
SERIAL_PROTOCOLPAIR("#define DEFAULT_bedKd ", workKd); SERIAL_EOL; SERIAL_PROTOCOLPAIR("#define DEFAULT_bedKd ", workKd); SERIAL_EOL();
#endif #endif
#define _SET_BED_PID() do { \ #define _SET_BED_PID() do { \
@ -508,7 +508,7 @@ int Temperature::getHeaterPower(int heater) {
void Temperature::_temp_error(int e, const char* serial_msg, const char* lcd_msg) { void Temperature::_temp_error(int e, const char* serial_msg, const char* lcd_msg) {
static bool killed = false; static bool killed = false;
if (IsRunning()) { if (IsRunning()) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
serialprintPGM(serial_msg); serialprintPGM(serial_msg);
SERIAL_ERRORPGM(MSG_STOPPED_HEATER); SERIAL_ERRORPGM(MSG_STOPPED_HEATER);
if (e >= 0) SERIAL_ERRORLN((int)e); else SERIAL_ERRORLNPGM(MSG_HEATER_BED); if (e >= 0) SERIAL_ERRORLN((int)e); else SERIAL_ERRORLNPGM(MSG_HEATER_BED);
@ -619,7 +619,7 @@ float Temperature::get_pid_output(int e) {
#endif // PID_OPENLOOP #endif // PID_OPENLOOP
#if ENABLED(PID_DEBUG) #if ENABLED(PID_DEBUG)
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR(MSG_PID_DEBUG, HOTEND_INDEX); SERIAL_ECHOPAIR(MSG_PID_DEBUG, HOTEND_INDEX);
SERIAL_ECHOPAIR(MSG_PID_DEBUG_INPUT, current_temperature[HOTEND_INDEX]); SERIAL_ECHOPAIR(MSG_PID_DEBUG_INPUT, current_temperature[HOTEND_INDEX]);
SERIAL_ECHOPAIR(MSG_PID_DEBUG_OUTPUT, pid_output); SERIAL_ECHOPAIR(MSG_PID_DEBUG_OUTPUT, pid_output);
@ -629,7 +629,7 @@ float Temperature::get_pid_output(int e) {
#if ENABLED(PID_EXTRUSION_SCALING) #if ENABLED(PID_EXTRUSION_SCALING)
SERIAL_ECHOPAIR(MSG_PID_DEBUG_CTERM, cTerm[HOTEND_INDEX]); SERIAL_ECHOPAIR(MSG_PID_DEBUG_CTERM, cTerm[HOTEND_INDEX]);
#endif #endif
SERIAL_EOL; SERIAL_EOL();
#endif // PID_DEBUG #endif // PID_DEBUG
#else /* PID off */ #else /* PID off */
@ -670,7 +670,7 @@ float Temperature::get_pid_output(int e) {
#endif // PID_OPENLOOP #endif // PID_OPENLOOP
#if ENABLED(PID_BED_DEBUG) #if ENABLED(PID_BED_DEBUG)
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM(" PID_BED_DEBUG "); SERIAL_ECHOPGM(" PID_BED_DEBUG ");
SERIAL_ECHOPGM(": Input "); SERIAL_ECHOPGM(": Input ");
SERIAL_ECHO(current_temperature_bed); SERIAL_ECHO(current_temperature_bed);
@ -854,7 +854,7 @@ float Temperature::analog2temp(int raw, uint8_t e) {
if (e >= HOTENDS) if (e >= HOTENDS)
#endif #endif
{ {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERROR((int)e); SERIAL_ERROR((int)e);
SERIAL_ERRORLNPGM(MSG_INVALID_EXTRUDER_NUM); SERIAL_ERRORLNPGM(MSG_INVALID_EXTRUDER_NUM);
kill(PSTR(MSG_KILLED)); kill(PSTR(MSG_KILLED));
@ -1278,7 +1278,7 @@ void Temperature::init() {
static float tr_target_temperature[HOTENDS + 1] = { 0.0 }; static float tr_target_temperature[HOTENDS + 1] = { 0.0 };
/** /**
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPGM("Thermal Thermal Runaway Running. Heater ID: "); SERIAL_ECHOPGM("Thermal Thermal Runaway Running. Heater ID: ");
if (heater_id < 0) SERIAL_ECHOPGM("bed"); else SERIAL_ECHO(heater_id); if (heater_id < 0) SERIAL_ECHOPGM("bed"); else SERIAL_ECHO(heater_id);
SERIAL_ECHOPAIR(" ; State:", *state); SERIAL_ECHOPAIR(" ; State:", *state);
@ -1289,7 +1289,7 @@ void Temperature::init() {
SERIAL_ECHOPAIR(" ; Idle Timeout:", heater_idle_timeout_exceeded[heater_id]); SERIAL_ECHOPAIR(" ; Idle Timeout:", heater_idle_timeout_exceeded[heater_id]);
else else
SERIAL_ECHOPAIR(" ; Idle Timeout:", bed_idle_timeout_exceeded); SERIAL_ECHOPAIR(" ; Idle Timeout:", bed_idle_timeout_exceeded);
SERIAL_EOL; SERIAL_EOL();
*/ */
int heater_index = heater_id >= 0 ? heater_id : HOTENDS; int heater_index = heater_id >= 0 ? heater_id : HOTENDS;
@ -1457,7 +1457,7 @@ void Temperature::disable_all_heaters() {
WRITE(MAX6675_SS, 1); // disable TT_MAX6675 WRITE(MAX6675_SS, 1); // disable TT_MAX6675
if (max6675_temp & MAX6675_ERROR_MASK) { if (max6675_temp & MAX6675_ERROR_MASK) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORPGM("Temp measurement error! "); SERIAL_ERRORPGM("Temp measurement error! ");
#if MAX6675_ERROR_MASK == 7 #if MAX6675_ERROR_MASK == 7
SERIAL_ERRORPGM("MAX31855 "); SERIAL_ERRORPGM("MAX31855 ");

8
Marlin/twibus.cpp
View File

@ -43,7 +43,7 @@ void TWIBus::reset() {
void TWIBus::address(const uint8_t adr) { void TWIBus::address(const uint8_t adr) {
if (!WITHIN(adr, 8, 127)) { if (!WITHIN(adr, 8, 127)) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM("Bad I2C address (8-127)"); SERIAL_ECHOLNPGM("Bad I2C address (8-127)");
} }
@ -90,7 +90,7 @@ void TWIBus::send() {
// static // static
void TWIBus::echoprefix(uint8_t bytes, const char prefix[], uint8_t adr) { void TWIBus::echoprefix(uint8_t bytes, const char prefix[], uint8_t adr) {
SERIAL_ECHO_START; SERIAL_ECHO_START();
serialprintPGM(prefix); serialprintPGM(prefix);
SERIAL_ECHOPAIR(": from:", adr); SERIAL_ECHOPAIR(": from:", adr);
SERIAL_ECHOPAIR(" bytes:", bytes); SERIAL_ECHOPAIR(" bytes:", bytes);
@ -101,13 +101,13 @@ void TWIBus::echoprefix(uint8_t bytes, const char prefix[], uint8_t adr) {
void TWIBus::echodata(uint8_t bytes, const char prefix[], uint8_t adr) { void TWIBus::echodata(uint8_t bytes, const char prefix[], uint8_t adr) {
echoprefix(bytes, prefix, adr); echoprefix(bytes, prefix, adr);
while (bytes-- && Wire.available()) SERIAL_CHAR(Wire.read()); while (bytes-- && Wire.available()) SERIAL_CHAR(Wire.read());
SERIAL_EOL; SERIAL_EOL();
} }
void TWIBus::echobuffer(const char prefix[], uint8_t adr) { void TWIBus::echobuffer(const char prefix[], uint8_t adr) {
echoprefix(this->buffer_s, prefix, adr); echoprefix(this->buffer_s, prefix, adr);
for (uint8_t i = 0; i < this->buffer_s; i++) SERIAL_CHAR(this->buffer[i]); for (uint8_t i = 0; i < this->buffer_s; i++) SERIAL_CHAR(this->buffer[i]);
SERIAL_EOL; SERIAL_EOL();
} }
bool TWIBus::request(const uint8_t bytes) { bool TWIBus::request(const uint8_t bytes) {

12
Marlin/ubl.cpp
View File

@ -116,11 +116,11 @@
serial_echo_xy(0, GRID_MAX_POINTS_Y - 1); serial_echo_xy(0, GRID_MAX_POINTS_Y - 1);
SERIAL_ECHO_SP(spaces + 3); SERIAL_ECHO_SP(spaces + 3);
serial_echo_xy(GRID_MAX_POINTS_X - 1, GRID_MAX_POINTS_Y - 1); serial_echo_xy(GRID_MAX_POINTS_X - 1, GRID_MAX_POINTS_Y - 1);
SERIAL_EOL; SERIAL_EOL();
serial_echo_xy(UBL_MESH_MIN_X, UBL_MESH_MAX_Y); serial_echo_xy(UBL_MESH_MIN_X, UBL_MESH_MAX_Y);
SERIAL_ECHO_SP(spaces); SERIAL_ECHO_SP(spaces);
serial_echo_xy(UBL_MESH_MAX_X, UBL_MESH_MAX_Y); serial_echo_xy(UBL_MESH_MAX_X, UBL_MESH_MAX_Y);
SERIAL_EOL; SERIAL_EOL();
} }
const float current_xi = get_cell_index_x(current_position[X_AXIS] + (MESH_X_DIST) / 2.0), const float current_xi = get_cell_index_x(current_position[X_AXIS] + (MESH_X_DIST) / 2.0),
@ -154,10 +154,10 @@
SERIAL_CHAR(' '); SERIAL_CHAR(' ');
} }
} }
SERIAL_EOL; SERIAL_EOL();
if (j && map0) { // we want the (0,0) up tight against the block of numbers if (j && map0) { // we want the (0,0) up tight against the block of numbers
SERIAL_CHAR(' '); SERIAL_CHAR(' ');
SERIAL_EOL; SERIAL_EOL();
} }
} }
@ -165,11 +165,11 @@
serial_echo_xy(UBL_MESH_MIN_X, UBL_MESH_MIN_Y); serial_echo_xy(UBL_MESH_MIN_X, UBL_MESH_MIN_Y);
SERIAL_ECHO_SP(spaces + 4); SERIAL_ECHO_SP(spaces + 4);
serial_echo_xy(UBL_MESH_MAX_X, UBL_MESH_MIN_Y); serial_echo_xy(UBL_MESH_MAX_X, UBL_MESH_MIN_Y);
SERIAL_EOL; SERIAL_EOL();
serial_echo_xy(0, 0); serial_echo_xy(0, 0);
SERIAL_ECHO_SP(spaces + 5); SERIAL_ECHO_SP(spaces + 5);
serial_echo_xy(GRID_MAX_POINTS_X - 1, 0); serial_echo_xy(GRID_MAX_POINTS_X - 1, 0);
SERIAL_EOL; SERIAL_EOL();
} }
} }

10
Marlin/ubl.h
View File

@ -256,7 +256,7 @@
SERIAL_ECHOPAIR(",x1_i=", x1_i); SERIAL_ECHOPAIR(",x1_i=", x1_i);
SERIAL_ECHOPAIR(",yi=", yi); SERIAL_ECHOPAIR(",yi=", yi);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
return NAN; return NAN;
} }
@ -276,7 +276,7 @@
SERIAL_ECHOPAIR(", xi=", xi); SERIAL_ECHOPAIR(", xi=", xi);
SERIAL_ECHOPAIR(", y1_i=", y1_i); SERIAL_ECHOPAIR(", y1_i=", y1_i);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
return NAN; return NAN;
} }
@ -301,7 +301,7 @@
SERIAL_ECHOPAIR("? in get_z_correction(lx0=", lx0); SERIAL_ECHOPAIR("? in get_z_correction(lx0=", lx0);
SERIAL_ECHOPAIR(", ly0=", ly0); SERIAL_ECHOPAIR(", ly0=", ly0);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
#if ENABLED(ULTRA_LCD) #if ENABLED(ULTRA_LCD)
strcpy(lcd_status_message, "get_z_correction() indexes out of range."); strcpy(lcd_status_message, "get_z_correction() indexes out of range.");
@ -336,7 +336,7 @@
if (DEBUGGING(MESH_ADJUST)) { if (DEBUGGING(MESH_ADJUST)) {
SERIAL_ECHOPGM(" >>>---> "); SERIAL_ECHOPGM(" >>>---> ");
SERIAL_ECHO_F(z0, 6); SERIAL_ECHO_F(z0, 6);
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -352,7 +352,7 @@
SERIAL_CHAR(','); SERIAL_CHAR(',');
SERIAL_ECHO(ly0); SERIAL_ECHO(ly0);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
} }

50
Marlin/ubl_G29.cpp
View File

@ -406,7 +406,7 @@
} }
if (isnan(z1) || isnan(z2) || isnan(z3)) { // probe_pt will return NAN if unreachable if (isnan(z1) || isnan(z2) || isnan(z3)) { // probe_pt will return NAN if unreachable
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("Attempt to probe off the bed."); SERIAL_ERRORLNPGM("Attempt to probe off the bed.");
goto LEAVE; goto LEAVE;
} }
@ -643,7 +643,7 @@
SERIAL_ECHO_F(z_values[x][y], 6); SERIAL_ECHO_F(z_values[x][y], 6);
SERIAL_ECHOPAIR(" ; X ", LOGICAL_X_POSITION(mesh_index_to_xpos(x))); SERIAL_ECHOPAIR(" ; X ", LOGICAL_X_POSITION(mesh_index_to_xpos(x)));
SERIAL_ECHOPAIR(", Y ", LOGICAL_Y_POSITION(mesh_index_to_ypos(y))); SERIAL_ECHOPAIR(", Y ", LOGICAL_Y_POSITION(mesh_index_to_ypos(y)));
SERIAL_EOL; SERIAL_EOL();
} }
return; return;
} }
@ -766,12 +766,12 @@
SERIAL_ECHOLNPAIR("# of samples: ", n); SERIAL_ECHOLNPAIR("# of samples: ", n);
SERIAL_ECHOPGM("Mean Mesh Height: "); SERIAL_ECHOPGM("Mean Mesh Height: ");
SERIAL_ECHO_F(mean, 6); SERIAL_ECHO_F(mean, 6);
SERIAL_EOL; SERIAL_EOL();
const float sigma = sqrt(sum_of_diff_squared / (n + 1)); const float sigma = sqrt(sum_of_diff_squared / (n + 1));
SERIAL_ECHOPGM("Standard Deviation: "); SERIAL_ECHOPGM("Standard Deviation: ");
SERIAL_ECHO_F(sigma, 6); SERIAL_ECHO_F(sigma, 6);
SERIAL_EOL; SERIAL_EOL();
if (g29_c_flag) if (g29_c_flag)
for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++) for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++)
@ -892,17 +892,17 @@
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPGM("d from 1st point: "); SERIAL_ECHOPGM("d from 1st point: ");
SERIAL_ECHO_F(d, 6); SERIAL_ECHO_F(d, 6);
SERIAL_EOL; SERIAL_EOL();
t = normal.x * (UBL_PROBE_PT_2_X) + normal.y * (UBL_PROBE_PT_2_Y); t = normal.x * (UBL_PROBE_PT_2_X) + normal.y * (UBL_PROBE_PT_2_Y);
d = t + normal.z * z2; d = t + normal.z * z2;
SERIAL_ECHOPGM("d from 2nd point: "); SERIAL_ECHOPGM("d from 2nd point: ");
SERIAL_ECHO_F(d, 6); SERIAL_ECHO_F(d, 6);
SERIAL_EOL; SERIAL_EOL();
t = normal.x * (UBL_PROBE_PT_3_X) + normal.y * (UBL_PROBE_PT_3_Y); t = normal.x * (UBL_PROBE_PT_3_X) + normal.y * (UBL_PROBE_PT_3_Y);
d = t + normal.z * z3; d = t + normal.z * z3;
SERIAL_ECHOPGM("d from 3rd point: "); SERIAL_ECHOPGM("d from 3rd point: ");
SERIAL_ECHO_F(d, 6); SERIAL_ECHO_F(d, 6);
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -1080,7 +1080,7 @@
if (g29_verbose_level > 2) { if (g29_verbose_level > 2) {
SERIAL_PROTOCOLPGM("Mesh Point Measured at: "); SERIAL_PROTOCOLPGM("Mesh Point Measured at: ");
SERIAL_PROTOCOL_F(z_values[location.x_index][location.y_index], 6); SERIAL_PROTOCOL_F(z_values[location.x_index][location.y_index], 6);
SERIAL_EOL; SERIAL_EOL();
} }
} while (location.x_index >= 0 && location.y_index >= 0); } while (location.x_index >= 0 && location.y_index >= 0);
@ -1244,7 +1244,7 @@
SERIAL_PROTOCOLPAIR("Mesh ", state.storage_slot); SERIAL_PROTOCOLPAIR("Mesh ", state.storage_slot);
SERIAL_PROTOCOLPGM(" Loaded."); SERIAL_PROTOCOLPGM(" Loaded.");
} }
SERIAL_EOL; SERIAL_EOL();
safe_delay(50); safe_delay(50);
SERIAL_PROTOCOLLNPAIR("UBL object count: ", (int)ubl_cnt); SERIAL_PROTOCOLLNPAIR("UBL object count: ", (int)ubl_cnt);
@ -1252,13 +1252,13 @@
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT) #if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
SERIAL_PROTOCOL("planner.z_fade_height : "); SERIAL_PROTOCOL("planner.z_fade_height : ");
SERIAL_PROTOCOL_F(planner.z_fade_height, 4); SERIAL_PROTOCOL_F(planner.z_fade_height, 4);
SERIAL_EOL; SERIAL_EOL();
#endif #endif
#if HAS_BED_PROBE #if HAS_BED_PROBE
SERIAL_PROTOCOLPGM("zprobe_zoffset: "); SERIAL_PROTOCOLPGM("zprobe_zoffset: ");
SERIAL_PROTOCOL_F(zprobe_zoffset, 7); SERIAL_PROTOCOL_F(zprobe_zoffset, 7);
SERIAL_EOL; SERIAL_EOL();
#endif #endif
SERIAL_ECHOLNPAIR("UBL_MESH_MIN_X " STRINGIFY(UBL_MESH_MIN_X) "=", UBL_MESH_MIN_X); SERIAL_ECHOLNPAIR("UBL_MESH_MIN_X " STRINGIFY(UBL_MESH_MIN_X) "=", UBL_MESH_MIN_X);
@ -1280,7 +1280,7 @@
SERIAL_PROTOCOLPGM(" "); SERIAL_PROTOCOLPGM(" ");
safe_delay(25); safe_delay(25);
} }
SERIAL_EOL; SERIAL_EOL();
SERIAL_PROTOCOLPGM("Y-Axis Mesh Points at: "); SERIAL_PROTOCOLPGM("Y-Axis Mesh Points at: ");
for (uint8_t i = 0; i < GRID_MAX_POINTS_Y; i++) { for (uint8_t i = 0; i < GRID_MAX_POINTS_Y; i++) {
@ -1288,19 +1288,19 @@
SERIAL_PROTOCOLPGM(" "); SERIAL_PROTOCOLPGM(" ");
safe_delay(25); safe_delay(25);
} }
SERIAL_EOL; SERIAL_EOL();
#if HAS_KILL #if HAS_KILL
SERIAL_PROTOCOLPAIR("Kill pin on :", KILL_PIN); SERIAL_PROTOCOLPAIR("Kill pin on :", KILL_PIN);
SERIAL_PROTOCOLLNPAIR(" state:", READ(KILL_PIN)); SERIAL_PROTOCOLLNPAIR(" state:", READ(KILL_PIN));
#endif #endif
SERIAL_EOL; SERIAL_EOL();
safe_delay(50); safe_delay(50);
SERIAL_PROTOCOLLNPAIR("ubl_state_at_invocation :", ubl_state_at_invocation); SERIAL_PROTOCOLLNPAIR("ubl_state_at_invocation :", ubl_state_at_invocation);
SERIAL_EOL; SERIAL_EOL();
SERIAL_PROTOCOLLNPAIR("ubl_state_recursion_chk :", ubl_state_recursion_chk); SERIAL_PROTOCOLLNPAIR("ubl_state_recursion_chk :", ubl_state_recursion_chk);
SERIAL_EOL; SERIAL_EOL();
safe_delay(50); safe_delay(50);
SERIAL_PROTOCOLPAIR("Meshes go from ", hex_address((void*)settings.get_start_of_meshes())); SERIAL_PROTOCOLPAIR("Meshes go from ", hex_address((void*)settings.get_start_of_meshes()));
@ -1308,9 +1308,9 @@
safe_delay(50); safe_delay(50);
SERIAL_PROTOCOLLNPAIR("sizeof(ubl) : ", (int)sizeof(ubl)); SERIAL_PROTOCOLLNPAIR("sizeof(ubl) : ", (int)sizeof(ubl));
SERIAL_EOL; SERIAL_EOL();
SERIAL_PROTOCOLLNPAIR("z_value[][] size: ", (int)sizeof(z_values)); SERIAL_PROTOCOLLNPAIR("z_value[][] size: ", (int)sizeof(z_values));
SERIAL_EOL; SERIAL_EOL();
safe_delay(25); safe_delay(25);
SERIAL_PROTOCOLLNPAIR("EEPROM free for UBL: ", hex_address((void*)(settings.get_end_of_meshes() - settings.get_start_of_meshes()))); SERIAL_PROTOCOLLNPAIR("EEPROM free for UBL: ", hex_address((void*)(settings.get_end_of_meshes() - settings.get_start_of_meshes())));
@ -1334,7 +1334,7 @@
unsigned char cccc; unsigned char cccc;
uint16_t kkkk; uint16_t kkkk;
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOLNPGM("EEPROM Dump:"); SERIAL_ECHOLNPGM("EEPROM Dump:");
for (uint16_t i = 0; i < E2END + 1; i += 16) { for (uint16_t i = 0; i < E2END + 1; i += 16) {
if (!(i & 0x3)) idle(); if (!(i & 0x3)) idle();
@ -1346,9 +1346,9 @@
print_hex_byte(cccc); print_hex_byte(cccc);
SERIAL_ECHO(' '); SERIAL_ECHO(' ');
} }
SERIAL_EOL; SERIAL_EOL();
} }
SERIAL_EOL; SERIAL_EOL();
} }
/** /**
@ -1667,7 +1667,7 @@
if (DEBUGGING(LEVELING)) { if (DEBUGGING(LEVELING)) {
SERIAL_ECHOPGM(" final >>>---> "); SERIAL_ECHOPGM(" final >>>---> ");
SERIAL_PROTOCOL_F(measured_z, 7); SERIAL_PROTOCOL_F(measured_z, 7);
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif
@ -1689,7 +1689,7 @@
SERIAL_PROTOCOL_F(lsf_results.B, 7); SERIAL_PROTOCOL_F(lsf_results.B, 7);
SERIAL_ECHOPGM(" D="); SERIAL_ECHOPGM(" D=");
SERIAL_PROTOCOL_F(lsf_results.D, 7); SERIAL_PROTOCOL_F(lsf_results.D, 7);
SERIAL_EOL; SERIAL_EOL();
} }
vector_3 normal = vector_3(lsf_results.A, lsf_results.B, 1.0000).get_normal(); vector_3 normal = vector_3(lsf_results.A, lsf_results.B, 1.0000).get_normal();
@ -1753,7 +1753,7 @@
SERIAL_PROTOCOL_F(lsf_results.B, 7); SERIAL_PROTOCOL_F(lsf_results.B, 7);
SERIAL_ECHOPGM(" D="); SERIAL_ECHOPGM(" D=");
SERIAL_PROTOCOL_F(lsf_results.D, 7); SERIAL_PROTOCOL_F(lsf_results.D, 7);
SERIAL_EOL; SERIAL_EOL();
safe_delay(55); safe_delay(55);
SERIAL_ECHOPGM("bed plane normal = ["); SERIAL_ECHOPGM("bed plane normal = [");
@ -1763,7 +1763,7 @@
SERIAL_PROTOCOLCHAR(','); SERIAL_PROTOCOLCHAR(',');
SERIAL_PROTOCOL_F(normal.z, 7); SERIAL_PROTOCOL_F(normal.z, 7);
SERIAL_ECHOPGM("]\n"); SERIAL_ECHOPGM("]\n");
SERIAL_EOL; SERIAL_EOL();
} }
#endif #endif

4
Marlin/ubl_motion.cpp
View File

@ -97,7 +97,7 @@
debug_echo_axis(E_AXIS); debug_echo_axis(E_AXIS);
SERIAL_ECHOPGM(" ) "); SERIAL_ECHOPGM(" ) ");
SERIAL_ECHO(title); SERIAL_ECHO(title);
SERIAL_EOL; SERIAL_EOL();
} }
@ -131,7 +131,7 @@
SERIAL_ECHOPAIR(", ze=", end[Z_AXIS]); SERIAL_ECHOPAIR(", ze=", end[Z_AXIS]);
SERIAL_ECHOPAIR(", ee=", end[E_AXIS]); SERIAL_ECHOPAIR(", ee=", end[E_AXIS]);
SERIAL_CHAR(')'); SERIAL_CHAR(')');
SERIAL_EOL; SERIAL_EOL();
debug_current_and_destination(PSTR("Start of ubl.line_to_destination()")); debug_current_and_destination(PSTR("Start of ubl.line_to_destination()"));
} }

4
Marlin/ultralcd.cpp
View File

@ -4043,12 +4043,12 @@ void lcd_update() {
else if (encoderStepRate >= ENCODER_10X_STEPS_PER_SEC) encoderMultiplier = 10; else if (encoderStepRate >= ENCODER_10X_STEPS_PER_SEC) encoderMultiplier = 10;
#if ENABLED(ENCODER_RATE_MULTIPLIER_DEBUG) #if ENABLED(ENCODER_RATE_MULTIPLIER_DEBUG)
SERIAL_ECHO_START; SERIAL_ECHO_START();
SERIAL_ECHOPAIR("Enc Step Rate: ", encoderStepRate); SERIAL_ECHOPAIR("Enc Step Rate: ", encoderStepRate);
SERIAL_ECHOPAIR(" Multiplier: ", encoderMultiplier); SERIAL_ECHOPAIR(" Multiplier: ", encoderMultiplier);
SERIAL_ECHOPAIR(" ENCODER_10X_STEPS_PER_SEC: ", ENCODER_10X_STEPS_PER_SEC); SERIAL_ECHOPAIR(" ENCODER_10X_STEPS_PER_SEC: ", ENCODER_10X_STEPS_PER_SEC);
SERIAL_ECHOPAIR(" ENCODER_100X_STEPS_PER_SEC: ", ENCODER_100X_STEPS_PER_SEC); SERIAL_ECHOPAIR(" ENCODER_100X_STEPS_PER_SEC: ", ENCODER_100X_STEPS_PER_SEC);
SERIAL_EOL; SERIAL_EOL();
#endif // ENCODER_RATE_MULTIPLIER_DEBUG #endif // ENCODER_RATE_MULTIPLIER_DEBUG
} }

4
Marlin/vector_3.cpp
View File

@ -89,7 +89,7 @@ void vector_3::debug(const char * const title) {
SERIAL_PROTOCOL_F(y, 6); SERIAL_PROTOCOL_F(y, 6);
SERIAL_PROTOCOLPGM(" z: "); SERIAL_PROTOCOLPGM(" z: ");
SERIAL_PROTOCOL_F(z, 6); SERIAL_PROTOCOL_F(z, 6);
SERIAL_EOL; SERIAL_EOL();
} }
void apply_rotation_xyz(matrix_3x3 matrix, float &x, float &y, float &z) { void apply_rotation_xyz(matrix_3x3 matrix, float &x, float &y, float &z) {
@ -152,7 +152,7 @@ void matrix_3x3::debug(const char * const title) {
SERIAL_PROTOCOLCHAR(' '); SERIAL_PROTOCOLCHAR(' ');
count++; count++;
} }
SERIAL_EOL; SERIAL_EOL();
} }
} }

2
Marlin/watchdog.cpp
View File

@ -46,7 +46,7 @@ void watchdog_init() {
// Watchdog timer interrupt, called if main program blocks >4sec and manual reset is enabled. // Watchdog timer interrupt, called if main program blocks >4sec and manual reset is enabled.
#if ENABLED(WATCHDOG_RESET_MANUAL) #if ENABLED(WATCHDOG_RESET_MANUAL)
ISR(WDT_vect) { ISR(WDT_vect) {
SERIAL_ERROR_START; SERIAL_ERROR_START();
SERIAL_ERRORLNPGM("Something is wrong, please turn off the printer."); SERIAL_ERRORLNPGM("Something is wrong, please turn off the printer.");
kill(PSTR("ERR:Please Reset")); //kill blocks //16 characters so it fits on a 16x2 display kill(PSTR("ERR:Please Reset")); //kill blocks //16 characters so it fits on a 16x2 display
while (1); //wait for user or serial reset while (1); //wait for user or serial reset