A single SERIAL_ECHO macro type (#12557)
This commit is contained in:
parent
69d869c3d9
commit
c986239837
86 changed files with 1016 additions and 1356 deletions
|
@ -39,8 +39,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
|
||||||
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_MSG(MSG_ERR_EEPROM_WRITE);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -150,7 +150,7 @@ static bool pwm_status(uint8_t pin) {
|
||||||
default:
|
default:
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
SERIAL_PROTOCOL_SP(2);
|
SERIAL_ECHO_SP(2);
|
||||||
} // pwm_status
|
} // pwm_status
|
||||||
|
|
||||||
|
|
||||||
|
@ -222,24 +222,24 @@ const volatile uint8_t* const PWM_OCR[][3] PROGMEM = {
|
||||||
|
|
||||||
#define OCR_VAL(T, L) pgm_read_word(&PWM_OCR[T][L])
|
#define OCR_VAL(T, L) pgm_read_word(&PWM_OCR[T][L])
|
||||||
|
|
||||||
static void err_is_counter() { SERIAL_PROTOCOLPGM(" non-standard PWM mode"); }
|
static void err_is_counter() { SERIAL_ECHOPGM(" non-standard PWM mode"); }
|
||||||
static void err_is_interrupt() { SERIAL_PROTOCOLPGM(" compare interrupt enabled"); }
|
static void err_is_interrupt() { SERIAL_ECHOPGM(" compare interrupt enabled"); }
|
||||||
static void err_prob_interrupt() { SERIAL_PROTOCOLPGM(" overflow interrupt enabled"); }
|
static void err_prob_interrupt() { SERIAL_ECHOPGM(" overflow interrupt enabled"); }
|
||||||
static void print_is_also_tied() { SERIAL_PROTOCOLPGM(" is also tied to this pin"); SERIAL_PROTOCOL_SP(14); }
|
static void print_is_also_tied() { SERIAL_ECHOPGM(" is also tied to this pin"); SERIAL_ECHO_SP(14); }
|
||||||
|
|
||||||
void com_print(uint8_t N, uint8_t Z) {
|
void com_print(uint8_t N, uint8_t Z) {
|
||||||
const uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
|
const uint8_t *TCCRA = (uint8_t*)TCCR_A(N);
|
||||||
SERIAL_PROTOCOLPGM(" COM");
|
SERIAL_ECHOPGM(" COM");
|
||||||
SERIAL_PROTOCOLCHAR(N + '0');
|
SERIAL_CHAR(N + '0');
|
||||||
switch (Z) {
|
switch (Z) {
|
||||||
case 'A':
|
case 'A':
|
||||||
SERIAL_PROTOCOLPAIR("A: ", ((*TCCRA & (_BV(7) | _BV(6))) >> 6));
|
SERIAL_ECHOPAIR("A: ", ((*TCCRA & (_BV(7) | _BV(6))) >> 6));
|
||||||
break;
|
break;
|
||||||
case 'B':
|
case 'B':
|
||||||
SERIAL_PROTOCOLPAIR("B: ", ((*TCCRA & (_BV(5) | _BV(4))) >> 4));
|
SERIAL_ECHOPAIR("B: ", ((*TCCRA & (_BV(5) | _BV(4))) >> 4));
|
||||||
break;
|
break;
|
||||||
case 'C':
|
case 'C':
|
||||||
SERIAL_PROTOCOLPAIR("C: ", ((*TCCRA & (_BV(3) | _BV(2))) >> 2));
|
SERIAL_ECHOPAIR("C: ", ((*TCCRA & (_BV(3) | _BV(2))) >> 2));
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -251,10 +251,10 @@ void timer_prefix(uint8_t T, char L, uint8_t N) { // T - timer L - pwm N -
|
||||||
uint8_t WGM = (((*TCCRB & _BV(WGM_2)) >> 1) | (*TCCRA & (_BV(WGM_0) | _BV(WGM_1))));
|
uint8_t WGM = (((*TCCRB & _BV(WGM_2)) >> 1) | (*TCCRA & (_BV(WGM_0) | _BV(WGM_1))));
|
||||||
if (N == 4) WGM |= ((*TCCRB & _BV(WGM_3)) >> 1);
|
if (N == 4) WGM |= ((*TCCRB & _BV(WGM_3)) >> 1);
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM(" TIMER");
|
SERIAL_ECHOPGM(" TIMER");
|
||||||
SERIAL_PROTOCOLCHAR(T + '0');
|
SERIAL_CHAR(T + '0');
|
||||||
SERIAL_PROTOCOLCHAR(L);
|
SERIAL_CHAR(L);
|
||||||
SERIAL_PROTOCOL_SP(3);
|
SERIAL_ECHO_SP(3);
|
||||||
|
|
||||||
if (N == 3) {
|
if (N == 3) {
|
||||||
const uint8_t *OCRVAL8 = (uint8_t*)OCR_VAL(T, L - 'A');
|
const uint8_t *OCRVAL8 = (uint8_t*)OCR_VAL(T, L - 'A');
|
||||||
|
@ -264,22 +264,22 @@ void timer_prefix(uint8_t T, char L, uint8_t N) { // T - timer L - pwm N -
|
||||||
const uint16_t *OCRVAL16 = (uint16_t*)OCR_VAL(T, L - 'A');
|
const uint16_t *OCRVAL16 = (uint16_t*)OCR_VAL(T, L - 'A');
|
||||||
PWM_PRINT(*OCRVAL16);
|
PWM_PRINT(*OCRVAL16);
|
||||||
}
|
}
|
||||||
SERIAL_PROTOCOLPAIR(" WGM: ", WGM);
|
SERIAL_ECHOPAIR(" WGM: ", WGM);
|
||||||
com_print(T,L);
|
com_print(T,L);
|
||||||
SERIAL_PROTOCOLPAIR(" CS: ", (*TCCRB & (_BV(CS_0) | _BV(CS_1) | _BV(CS_2)) ));
|
SERIAL_ECHOPAIR(" CS: ", (*TCCRB & (_BV(CS_0) | _BV(CS_1) | _BV(CS_2)) ));
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM(" TCCR");
|
SERIAL_ECHOPGM(" TCCR");
|
||||||
SERIAL_PROTOCOLCHAR(T + '0');
|
SERIAL_CHAR(T + '0');
|
||||||
SERIAL_PROTOCOLPAIR("A: ", *TCCRA);
|
SERIAL_ECHOPAIR("A: ", *TCCRA);
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM(" TCCR");
|
SERIAL_ECHOPGM(" TCCR");
|
||||||
SERIAL_PROTOCOLCHAR(T + '0');
|
SERIAL_CHAR(T + '0');
|
||||||
SERIAL_PROTOCOLPAIR("B: ", *TCCRB);
|
SERIAL_ECHOPAIR("B: ", *TCCRB);
|
||||||
|
|
||||||
const uint8_t *TMSK = (uint8_t*)TIMSK(T);
|
const uint8_t *TMSK = (uint8_t*)TIMSK(T);
|
||||||
SERIAL_PROTOCOLPGM(" TIMSK");
|
SERIAL_ECHOPGM(" TIMSK");
|
||||||
SERIAL_PROTOCOLCHAR(T + '0');
|
SERIAL_CHAR(T + '0');
|
||||||
SERIAL_PROTOCOLPAIR(": ", *TMSK);
|
SERIAL_ECHOPAIR(": ", *TMSK);
|
||||||
|
|
||||||
const uint8_t OCIE = L - 'A' + 1;
|
const uint8_t OCIE = L - 'A' + 1;
|
||||||
if (N == 3) { if (WGM == 0 || WGM == 2 || WGM == 4 || WGM == 6) err_is_counter(); }
|
if (N == 3) { if (WGM == 0 || WGM == 2 || WGM == 4 || WGM == 6) err_is_counter(); }
|
||||||
|
@ -336,22 +336,22 @@ static void pwm_details(uint8_t pin) {
|
||||||
case NOT_ON_TIMER: break;
|
case NOT_ON_TIMER: break;
|
||||||
|
|
||||||
}
|
}
|
||||||
SERIAL_PROTOCOLPGM(" ");
|
SERIAL_ECHOPGM(" ");
|
||||||
|
|
||||||
// on pins that have two PWMs, print info on second PWM
|
// on pins that have two PWMs, print info on second PWM
|
||||||
#if AVR_ATmega2560_FAMILY || AVR_AT90USB1286_FAMILY
|
#if AVR_ATmega2560_FAMILY || AVR_AT90USB1286_FAMILY
|
||||||
// looking for port B7 - PWMs 0A and 1C
|
// looking for port B7 - PWMs 0A and 1C
|
||||||
if (digitalPinToPort_DEBUG(pin) == 'B' - 64 && 0x80 == digitalPinToBitMask_DEBUG(pin)) {
|
if (digitalPinToPort_DEBUG(pin) == 'B' - 64 && 0x80 == digitalPinToBitMask_DEBUG(pin)) {
|
||||||
#if !AVR_AT90USB1286_FAMILY
|
#if !AVR_AT90USB1286_FAMILY
|
||||||
SERIAL_PROTOCOLPGM("\n .");
|
SERIAL_ECHOPGM("\n .");
|
||||||
SERIAL_PROTOCOL_SP(18);
|
SERIAL_ECHO_SP(18);
|
||||||
SERIAL_PROTOCOLPGM("TIMER1C");
|
SERIAL_ECHOPGM("TIMER1C");
|
||||||
print_is_also_tied();
|
print_is_also_tied();
|
||||||
timer_prefix(1, 'C', 4);
|
timer_prefix(1, 'C', 4);
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOLPGM("\n .");
|
SERIAL_ECHOPGM("\n .");
|
||||||
SERIAL_PROTOCOL_SP(18);
|
SERIAL_ECHO_SP(18);
|
||||||
SERIAL_PROTOCOLPGM("TIMER0A");
|
SERIAL_ECHOPGM("TIMER0A");
|
||||||
print_is_also_tied();
|
print_is_also_tied();
|
||||||
timer_prefix(0, 'A', 3);
|
timer_prefix(0, 'A', 3);
|
||||||
#endif
|
#endif
|
||||||
|
@ -372,7 +372,7 @@ static void pwm_details(uint8_t pin) {
|
||||||
void print_port(int8_t pin) { // print port number
|
void print_port(int8_t pin) { // print port number
|
||||||
#ifdef digitalPinToPort_DEBUG
|
#ifdef digitalPinToPort_DEBUG
|
||||||
uint8_t x;
|
uint8_t x;
|
||||||
SERIAL_PROTOCOLPGM(" Port: ");
|
SERIAL_ECHOPGM(" Port: ");
|
||||||
#if AVR_AT90USB1286_FAMILY
|
#if AVR_AT90USB1286_FAMILY
|
||||||
x = (pin == 46 || pin == 47) ? 'E' : digitalPinToPort_DEBUG(pin) + 64;
|
x = (pin == 46 || pin == 47) ? 'E' : digitalPinToPort_DEBUG(pin) + 64;
|
||||||
#else
|
#else
|
||||||
|
@ -395,7 +395,7 @@ static void pwm_details(uint8_t pin) {
|
||||||
#endif
|
#endif
|
||||||
SERIAL_CHAR(x);
|
SERIAL_CHAR(x);
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOL_SP(10);
|
SERIAL_ECHO_SP(10);
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -62,8 +62,7 @@ void watchdog_init() {
|
||||||
#if ENABLED(WATCHDOG_RESET_MANUAL)
|
#if ENABLED(WATCHDOG_RESET_MANUAL)
|
||||||
ISR(WDT_vect) {
|
ISR(WDT_vect) {
|
||||||
sei(); // With the interrupt driven serial we need to allow interrupts.
|
sei(); // With the interrupt driven serial we need to allow interrupts.
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_WATCHDOG_FIRED);
|
||||||
SERIAL_ERRORLNPGM(MSG_WATCHDOG_FIRED);
|
|
||||||
minkill(); // interrupt-safe final kill and infinite loop
|
minkill(); // interrupt-safe final kill and infinite loop
|
||||||
}
|
}
|
||||||
#endif // WATCHDOG_RESET_MANUAL
|
#endif // WATCHDOG_RESET_MANUAL
|
||||||
|
|
|
@ -121,7 +121,7 @@ static uint8_t buffer[256] = {0}, // The RAM buffer to accumulate writes
|
||||||
char buffer[80];
|
char buffer[80];
|
||||||
|
|
||||||
sprintf(buffer, "Page: %d (0x%04x)\n", page, page);
|
sprintf(buffer, "Page: %d (0x%04x)\n", page, page);
|
||||||
SERIAL_PROTOCOL(buffer);
|
SERIAL_ECHO(buffer);
|
||||||
|
|
||||||
char* p = &buffer[0];
|
char* p = &buffer[0];
|
||||||
for (int i = 0; i< PageSize; ++i) {
|
for (int i = 0; i< PageSize; ++i) {
|
||||||
|
@ -131,7 +131,7 @@ static uint8_t buffer[256] = {0}, // The RAM buffer to accumulate writes
|
||||||
if ((i & 0xF) == 0xF) {
|
if ((i & 0xF) == 0xF) {
|
||||||
*p++ = '\n';
|
*p++ = '\n';
|
||||||
*p = 0;
|
*p = 0;
|
||||||
SERIAL_PROTOCOL(buffer);
|
SERIAL_ECHO(buffer);
|
||||||
p = &buffer[0];
|
p = &buffer[0];
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -53,8 +53,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
|
||||||
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_MSG(MSG_ERR_EEPROM_WRITE);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -93,7 +93,7 @@ bool GET_ARRAY_IS_DIGITAL(int8_t pin) {
|
||||||
void pwm_details(int32_t pin) {
|
void pwm_details(int32_t pin) {
|
||||||
if (pwm_status(pin)) {
|
if (pwm_status(pin)) {
|
||||||
uint32_t chan = g_APinDescription[pin].ulPWMChannel;
|
uint32_t chan = g_APinDescription[pin].ulPWMChannel;
|
||||||
SERIAL_PROTOCOLPAIR("PWM = ", PWM_INTERFACE->PWM_CH_NUM[chan].PWM_CDTY);
|
SERIAL_ECHOPAIR("PWM = ", PWM_INTERFACE->PWM_CH_NUM[chan].PWM_CDTY);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -67,7 +67,7 @@ Ctrl_status sd_mmc_spi_usb_read_10(uint32_t addr, uint16_t nb_sector) {
|
||||||
#ifdef DEBUG_MMC
|
#ifdef DEBUG_MMC
|
||||||
char buffer[80];
|
char buffer[80];
|
||||||
sprintf(buffer, "SDRD: %d @ 0x%08x\n", nb_sector, addr);
|
sprintf(buffer, "SDRD: %d @ 0x%08x\n", nb_sector, addr);
|
||||||
SERIAL_PROTOCOL_P(0, buffer);
|
SERIAL_ECHO_P(0, buffer);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// Start reading
|
// Start reading
|
||||||
|
@ -101,7 +101,7 @@ Ctrl_status sd_mmc_spi_usb_write_10(uint32_t addr, uint16_t nb_sector) {
|
||||||
#ifdef DEBUG_MMC
|
#ifdef DEBUG_MMC
|
||||||
char buffer[80];
|
char buffer[80];
|
||||||
sprintf(buffer, "SDWR: %d @ 0x%08x\n", nb_sector, addr);
|
sprintf(buffer, "SDWR: %d @ 0x%08x\n", nb_sector, addr);
|
||||||
SERIAL_PROTOCOL_P(0, buffer);
|
SERIAL_ECHO_P(0, buffer);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
if (!card.getSd2Card().writeStart(addr, nb_sector))
|
if (!card.getSd2Card().writeStart(addr, nb_sector))
|
||||||
|
|
|
@ -80,23 +80,23 @@ bool PersistentStore::access_finish() {
|
||||||
// to see errors that are happening in read_data / write_data
|
// to see errors that are happening in read_data / write_data
|
||||||
static void debug_rw(const bool write, int &pos, const uint8_t *value, const size_t size, const FRESULT s, const size_t total=0) {
|
static void debug_rw(const bool write, int &pos, const uint8_t *value, const size_t size, const FRESULT s, const size_t total=0) {
|
||||||
PGM_P const rw_str = write ? PSTR("write") : PSTR("read");
|
PGM_P const rw_str = write ? PSTR("write") : PSTR("read");
|
||||||
SERIAL_PROTOCOLCHAR(' ');
|
SERIAL_CHAR(' ');
|
||||||
serialprintPGM(rw_str);
|
serialprintPGM(rw_str);
|
||||||
SERIAL_PROTOCOLPAIR("_data(", pos);
|
SERIAL_ECHOPAIR("_data(", pos);
|
||||||
SERIAL_PROTOCOLPAIR(",", (int)value);
|
SERIAL_ECHOPAIR(",", (int)value);
|
||||||
SERIAL_PROTOCOLPAIR(",", (int)size);
|
SERIAL_ECHOPAIR(",", (int)size);
|
||||||
SERIAL_PROTOCOLLNPGM(", ...)");
|
SERIAL_ECHOLNPGM(", ...)");
|
||||||
if (total) {
|
if (total) {
|
||||||
SERIAL_PROTOCOLPGM(" f_");
|
SERIAL_ECHOPGM(" f_");
|
||||||
serialprintPGM(rw_str);
|
serialprintPGM(rw_str);
|
||||||
SERIAL_PROTOCOLPAIR("()=", (int)s);
|
SERIAL_ECHOPAIR("()=", (int)s);
|
||||||
SERIAL_PROTOCOLPAIR("\n size=", size);
|
SERIAL_ECHOPAIR("\n size=", size);
|
||||||
SERIAL_PROTOCOLPGM("\n bytes_");
|
SERIAL_ECHOPGM("\n bytes_");
|
||||||
serialprintPGM(write ? PSTR("written=") : PSTR("read="));
|
serialprintPGM(write ? PSTR("written=") : PSTR("read="));
|
||||||
SERIAL_PROTOCOLLN(total);
|
SERIAL_ECHOLN(total);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
SERIAL_PROTOCOLLNPAIR(" f_lseek()=", (int)s);
|
SERIAL_ECHOLNPAIR(" f_lseek()=", (int)s);
|
||||||
}
|
}
|
||||||
|
|
||||||
// File function return codes for type FRESULT. This goes away soon, but
|
// File function return codes for type FRESULT. This goes away soon, but
|
||||||
|
|
|
@ -62,8 +62,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
|
||||||
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_MSG(MSG_ERR_EEPROM_WRITE);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -41,8 +41,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
|
||||||
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_MSG(MSG_ERR_EEPROM_WRITE);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -41,8 +41,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
|
||||||
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_MSG(MSG_ERR_EEPROM_WRITE);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -21,8 +21,7 @@ bool write_data(int &pos, const uint8_t *value, uint16_t size, uint16_t *crc) {
|
||||||
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_MSG(MSG_ERR_EEPROM_WRITE);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -42,8 +42,7 @@ bool PersistentStore::write_data(int &pos, const uint8_t *value, size_t size, ui
|
||||||
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_MSG(MSG_ERR_EEPROM_WRITE);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -21,8 +21,7 @@ bool write_data(int &pos, const uint8_t *value, uint16_t size, uint16_t *crc) {
|
||||||
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_MSG(MSG_ERR_EEPROM_WRITE);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_EEPROM_WRITE);
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -102,7 +102,7 @@ bool HAL_pwm_status(int8_t pin) {
|
||||||
default:
|
default:
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
SERIAL_PROTOCOLPGM(" ");
|
SERIAL_ECHOPGM(" ");
|
||||||
}
|
}
|
||||||
|
|
||||||
static void HAL_pwm_details(uint8_t pin) { /* TODO */ }
|
static void HAL_pwm_details(uint8_t pin) { /* TODO */ }
|
||||||
|
|
|
@ -88,8 +88,7 @@ void backtrace(void) {
|
||||||
btf.pc = pc | 1; // Force Thumb, as CORTEX only support it
|
btf.pc = pc | 1; // Force Thumb, as CORTEX only support it
|
||||||
|
|
||||||
// Perform a backtrace
|
// Perform a backtrace
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG("Backtrace:");
|
||||||
SERIAL_ERRORLNPGM("Backtrace:");
|
|
||||||
int ctr = 0;
|
int ctr = 0;
|
||||||
UnwindStart(&btf, &UnwCallbacks, &ctr);
|
UnwindStart(&btf, &UnwCallbacks, &ctr);
|
||||||
}
|
}
|
||||||
|
|
|
@ -264,8 +264,7 @@ bool pin_is_protected(const pin_t pin) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void protected_pin_err() {
|
void protected_pin_err() {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_PROTECTED_PIN);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_PROTECTED_PIN);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void quickstop_stepper() {
|
void quickstop_stepper() {
|
||||||
|
@ -400,8 +399,7 @@ void manage_inactivity(const bool ignore_stepper_queue/*=false*/) {
|
||||||
// KILL the machine
|
// KILL the machine
|
||||||
// ----------------------------------------------------------------
|
// ----------------------------------------------------------------
|
||||||
if (killCount >= KILL_DELAY) {
|
if (killCount >= KILL_DELAY) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_KILL_BUTTON);
|
||||||
SERIAL_ERRORLNPGM(MSG_KILL_BUTTON);
|
|
||||||
kill();
|
kill();
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -606,8 +604,7 @@ void idle(
|
||||||
void kill(PGM_P const lcd_msg/*=NULL*/) {
|
void kill(PGM_P const lcd_msg/*=NULL*/) {
|
||||||
thermalManager.disable_all_heaters();
|
thermalManager.disable_all_heaters();
|
||||||
|
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_KILLED);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_KILLED);
|
|
||||||
|
|
||||||
#if HAS_SPI_LCD || ENABLED(EXTENSIBLE_UI)
|
#if HAS_SPI_LCD || ENABLED(EXTENSIBLE_UI)
|
||||||
ui.kill_screen(lcd_msg ? lcd_msg : PSTR(MSG_KILLED));
|
ui.kill_screen(lcd_msg ? lcd_msg : PSTR(MSG_KILLED));
|
||||||
|
@ -663,8 +660,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_MSG(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
|
||||||
Running = false;
|
Running = false;
|
||||||
|
@ -745,7 +741,7 @@ void setup() {
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("start");
|
SERIAL_ECHOLNPGM("start");
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_START();
|
||||||
|
|
||||||
#if TMC_HAS_SPI
|
#if TMC_HAS_SPI
|
||||||
|
@ -781,8 +777,7 @@ void setup() {
|
||||||
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_ECHO_START();
|
SERIAL_ECHO_MSG("Compiled: " __DATE__);
|
||||||
SERIAL_ECHOLNPGM("Compiled: " __DATE__);
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_START();
|
||||||
|
|
|
@ -33,14 +33,14 @@ static const char echomagic[] PROGMEM = "echo:";
|
||||||
while (char ch = pgm_read_byte(str++)) SERIAL_CHAR_P(p, ch);
|
while (char ch = pgm_read_byte(str++)) SERIAL_CHAR_P(p, ch);
|
||||||
}
|
}
|
||||||
|
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, const char *v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, const char *v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, char v) { serialprintPGM_P(p, s_P); SERIAL_CHAR_P(p, v); }
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, char v) { serialprintPGM_P(p, s_P); SERIAL_CHAR_P(p, v); }
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, int v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, int v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, long v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, long v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, float v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, float v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, double v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, double v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, unsigned int v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, unsigned int v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, unsigned long v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, unsigned long v) { serialprintPGM_P(p, s_P); SERIAL_ECHO_P(p, v); }
|
||||||
|
|
||||||
void serial_spaces_P(const int8_t p, uint8_t count) { count *= (PROPORTIONAL_FONT_RATIO); while (count--) SERIAL_CHAR_P(p, ' '); }
|
void serial_spaces_P(const int8_t p, uint8_t count) { count *= (PROPORTIONAL_FONT_RATIO); while (count--) SERIAL_CHAR_P(p, ' '); }
|
||||||
|
|
||||||
|
@ -56,14 +56,14 @@ void serialprintPGM(PGM_P str) {
|
||||||
void serial_echo_start() { serialprintPGM(echomagic); }
|
void serial_echo_start() { serialprintPGM(echomagic); }
|
||||||
void serial_error_start() { serialprintPGM(errormagic); }
|
void serial_error_start() { serialprintPGM(errormagic); }
|
||||||
|
|
||||||
void serial_echopair_PGM(PGM_P s_P, const char *v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
void serial_echopair_PGM(PGM_P const s_P, const char *v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
||||||
void serial_echopair_PGM(PGM_P s_P, char v) { serialprintPGM(s_P); SERIAL_CHAR(v); }
|
void serial_echopair_PGM(PGM_P const s_P, char v) { serialprintPGM(s_P); SERIAL_CHAR(v); }
|
||||||
void serial_echopair_PGM(PGM_P s_P, int v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
void serial_echopair_PGM(PGM_P const s_P, int v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
||||||
void serial_echopair_PGM(PGM_P s_P, long v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
void serial_echopair_PGM(PGM_P const s_P, long v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
||||||
void serial_echopair_PGM(PGM_P s_P, float v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
void serial_echopair_PGM(PGM_P const s_P, float v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
||||||
void serial_echopair_PGM(PGM_P s_P, double v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
void serial_echopair_PGM(PGM_P const s_P, double v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
||||||
void serial_echopair_PGM(PGM_P s_P, unsigned int v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
void serial_echopair_PGM(PGM_P const s_P, unsigned int v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
||||||
void serial_echopair_PGM(PGM_P s_P, unsigned long v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
void serial_echopair_PGM(PGM_P const s_P, unsigned long v) { serialprintPGM(s_P); SERIAL_ECHO(v); }
|
||||||
|
|
||||||
void serial_spaces(uint8_t count) { count *= (PROPORTIONAL_FONT_RATIO); while (count--) SERIAL_CHAR(' '); }
|
void serial_spaces(uint8_t count) { count *= (PROPORTIONAL_FONT_RATIO); while (count--) SERIAL_CHAR(' '); }
|
||||||
|
|
||||||
|
@ -74,7 +74,7 @@ void serialprintln_onoff(const bool onoff) { serialprint_onoff(onoff); SERIAL_EO
|
||||||
|
|
||||||
#include "enum.h"
|
#include "enum.h"
|
||||||
|
|
||||||
void print_xyz(PGM_P prefix, PGM_P suffix, const float x, const float y, const float z) {
|
void print_xyz(PGM_P const prefix, PGM_P const suffix, const float x, const float y, const float z) {
|
||||||
serialprintPGM(prefix);
|
serialprintPGM(prefix);
|
||||||
SERIAL_CHAR('(');
|
SERIAL_CHAR('(');
|
||||||
SERIAL_ECHO(x);
|
SERIAL_ECHO(x);
|
||||||
|
@ -84,7 +84,7 @@ void serialprintln_onoff(const bool onoff) { serialprint_onoff(onoff); SERIAL_EO
|
||||||
if (suffix) serialprintPGM(suffix); else SERIAL_EOL();
|
if (suffix) serialprintPGM(suffix); else SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
|
||||||
void print_xyz(PGM_P prefix, PGM_P suffix, const float xyz[]) {
|
void print_xyz(PGM_P const prefix, PGM_P const suffix, const float xyz[]) {
|
||||||
print_xyz(prefix, suffix, xyz[X_AXIS], xyz[Y_AXIS], xyz[Z_AXIS]);
|
print_xyz(prefix, suffix, xyz[X_AXIS], xyz[Y_AXIS], xyz[Z_AXIS]);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -48,193 +48,159 @@ extern uint8_t marlin_debug_flags;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if NUM_SERIAL > 1
|
#if NUM_SERIAL > 1
|
||||||
#define SERIAL_CHAR_P(p,x) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.write(x) : MYSERIAL1.write(x)) : SERIAL_CHAR(x))
|
|
||||||
#define SERIAL_PROTOCOL_P(p,x) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.print(x) : MYSERIAL1.print(x)) : SERIAL_PROTOCOL(x))
|
|
||||||
#define SERIAL_PROTOCOL_F_P(p,x,y) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.print(x,y) : MYSERIAL1.print(x,y)) : SERIAL_PROTOCOL_F(x,y))
|
|
||||||
#define SERIAL_PROTOCOLLN_P(p,x) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.println(x) : MYSERIAL1.println(x)) : SERIAL_PROTOCOLLN(x))
|
|
||||||
#define SERIAL_PRINT_P(p,x,b) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.print(x,b) : MYSERIAL1.print(x,b)) : SERIAL_PRINT(x,b))
|
|
||||||
#define SERIAL_PRINTLN_P(p,x,b) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.println(x,b) : MYSERIAL1.println(x,b)) : SERIAL_PRINTLN(x,b))
|
|
||||||
#define SERIAL_PRINTF_P(p,args...) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.printf(args) : MYSERIAL1.printf(args)) : SERIAL_PRINTF(args))
|
|
||||||
|
|
||||||
#define SERIAL_CHAR(x) (MYSERIAL0.write(x), MYSERIAL1.write(x))
|
//
|
||||||
#define SERIAL_PROTOCOL(x) (MYSERIAL0.print(x), MYSERIAL1.print(x))
|
// Serial out to all ports
|
||||||
#define SERIAL_PROTOCOL_F(x,y) (MYSERIAL0.print(x,y), MYSERIAL1.print(x,y))
|
//
|
||||||
#define SERIAL_PROTOCOLLN(x) (MYSERIAL0.println(x), MYSERIAL1.println(x))
|
#define SERIAL_CHAR(x) (MYSERIAL0.write(x), MYSERIAL1.write(x))
|
||||||
#define SERIAL_PRINT(x,b) (MYSERIAL0.print(x,b), MYSERIAL1.print(x,b))
|
#define SERIAL_ECHO(x) (MYSERIAL0.print(x), MYSERIAL1.print(x))
|
||||||
#define SERIAL_PRINTLN(x,b) (MYSERIAL0.println(x,b), MYSERIAL1.println(x,b))
|
#define SERIAL_ECHO_F(x,y) (MYSERIAL0.print(x,y), MYSERIAL1.print(x,y))
|
||||||
#define SERIAL_PRINTF(args...) (MYSERIAL0.printf(args), MYSERIAL1.printf(args))
|
#define SERIAL_ECHOLN(x) (MYSERIAL0.println(x), MYSERIAL1.println(x))
|
||||||
|
#define SERIAL_PRINT(x,b) (MYSERIAL0.print(x,b), MYSERIAL1.print(x,b))
|
||||||
#define SERIAL_FLUSH_P(p) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.flush() : MYSERIAL1.flush()) : SERIAL_FLUSH())
|
#define SERIAL_PRINTLN(x,b) (MYSERIAL0.println(x,b), MYSERIAL1.println(x,b))
|
||||||
#define SERIAL_FLUSH() (MYSERIAL0.flush(), MYSERIAL1.flush())
|
#define SERIAL_PRINTF(args...) (MYSERIAL0.printf(args), MYSERIAL1.printf(args))
|
||||||
|
#define SERIAL_FLUSH() (MYSERIAL0.flush(), MYSERIAL1.flush())
|
||||||
#if TX_BUFFER_SIZE > 0
|
#if TX_BUFFER_SIZE > 0
|
||||||
#define SERIAL_FLUSHTX_P(p) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.flushTX() : MYSERIAL1.flushTX()) : SERIAL_FLUSHTX())
|
#define SERIAL_FLUSHTX() (MYSERIAL0.flushTX(), MYSERIAL1.flushTX())
|
||||||
#define SERIAL_FLUSHTX() (MYSERIAL0.flushTX(), MYSERIAL1.flushTX())
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define SERIAL_EOL_P(p) SERIAL_CHAR_P(p,'\n')
|
//
|
||||||
|
// Serial out with port redirect
|
||||||
|
//
|
||||||
|
#define SERIAL_CHAR_P(p,x) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.write(x) : MYSERIAL1.write(x)) : SERIAL_CHAR(x))
|
||||||
|
#define SERIAL_ECHO_P(p,x) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.print(x) : MYSERIAL1.print(x)) : SERIAL_ECHO(x))
|
||||||
|
#define SERIAL_ECHO_F_P(p,x,y) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.print(x,y) : MYSERIAL1.print(x,y)) : SERIAL_ECHO_F(x,y))
|
||||||
|
#define SERIAL_ECHOLN_P(p,x) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.println(x) : MYSERIAL1.println(x)) : SERIAL_ECHOLN(x))
|
||||||
|
#define SERIAL_PRINT_P(p,x,b) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.print(x,b) : MYSERIAL1.print(x,b)) : SERIAL_PRINT(x,b))
|
||||||
|
#define SERIAL_PRINTLN_P(p,x,b) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.println(x,b) : MYSERIAL1.println(x,b)) : SERIAL_PRINTLN(x,b))
|
||||||
|
#define SERIAL_PRINTF_P(p,args...) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.printf(args) : MYSERIAL1.printf(args)) : SERIAL_PRINTF(args))
|
||||||
|
#define SERIAL_FLUSH_P(p) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.flush() : MYSERIAL1.flush()) : SERIAL_FLUSH())
|
||||||
|
#if TX_BUFFER_SIZE > 0
|
||||||
|
#define SERIAL_FLUSHTX_P(p) (WITHIN(p, 0, NUM_SERIAL-1) ? (p == 0 ? MYSERIAL0.flushTX() : MYSERIAL1.flushTX()) : SERIAL_FLUSHTX())
|
||||||
|
#endif
|
||||||
|
|
||||||
#define SERIAL_PROTOCOLCHAR_P(p,x) SERIAL_CHAR_P(p,x)
|
#define SERIAL_ECHOPGM_P(p,x) (serialprintPGM_P(p,PSTR(x)))
|
||||||
#define SERIAL_PROTOCOLPGM_P(p,x) (serialprintPGM_P(p,PSTR(x)))
|
#define SERIAL_ECHOLNPGM_P(p,x) (serialprintPGM_P(p,PSTR(x "\n")))
|
||||||
#define SERIAL_PROTOCOLLNPGM_P(p,x) (serialprintPGM_P(p,PSTR(x "\n")))
|
#define SERIAL_ECHOPAIR_P(p, pre, value) (serial_echopair_PGM_P(p,PSTR(pre),(value)))
|
||||||
#define SERIAL_PROTOCOLPAIR_P(p, pre, value) (serial_echopair_PGM_P(p,PSTR(pre),(value)))
|
|
||||||
#define SERIAL_PROTOCOLLNPAIR_P(p, pre, value) do{ SERIAL_PROTOCOLPAIR_P(p, pre, value); SERIAL_EOL_P(p); }while(0)
|
|
||||||
|
|
||||||
#define SERIAL_ECHO_START_P(p) serial_echo_start_P(p)
|
#define SERIAL_ECHO_START_P(p) serial_echo_start_P(p)
|
||||||
#define SERIAL_ECHO_P(p,x) SERIAL_PROTOCOL_P(p,x)
|
#define SERIAL_ERROR_START_P(p) serial_error_start_P(p)
|
||||||
#define SERIAL_ECHOPGM_P(p,x) SERIAL_PROTOCOLPGM_P(p,x)
|
#define SERIAL_EOL_P(p) SERIAL_CHAR_P(p,'\n')
|
||||||
#define SERIAL_ECHOLN_P(p,x) SERIAL_PROTOCOLLN_P(p,x)
|
|
||||||
#define SERIAL_ECHOLNPGM_P(p,x) SERIAL_PROTOCOLLNPGM_P(p,x)
|
|
||||||
#define SERIAL_ECHOPAIR_P(p,pre,value) SERIAL_PROTOCOLPAIR_P(p, pre, value)
|
|
||||||
#define SERIAL_ECHOLNPAIR_P(p,pre, value) SERIAL_PROTOCOLLNPAIR_P(p, pre, value)
|
|
||||||
#define SERIAL_ECHO_F_P(p,x,y) SERIAL_PROTOCOL_F_P(p,x,y)
|
|
||||||
|
|
||||||
#define SERIAL_ERROR_START_P(p) serial_error_start_P(p)
|
#define SERIAL_ECHOPAIR_F_P(p, pre, value, y) do{ SERIAL_ECHO_P(p, pre); SERIAL_ECHO_F_P(p, value, y); }while(0)
|
||||||
#define SERIAL_ERROR_P(p,x) SERIAL_PROTOCOL_P(p,x)
|
#define SERIAL_ECHOLNPAIR_F_P(p, pre, value, y) do{ SERIAL_ECHOPAIR_F_P(p, pre, value, y); SERIAL_EOL_P(p); }while(0)
|
||||||
#define SERIAL_ERRORPGM_P(p,x) SERIAL_PROTOCOLPGM_P(p,x)
|
|
||||||
#define SERIAL_ERRORLN_P(p,x) SERIAL_PROTOCOLLN_P(p,x)
|
|
||||||
#define SERIAL_ERRORLNPGM_P(p,x) SERIAL_PROTOCOLLNPGM_P(p,x)
|
|
||||||
|
|
||||||
// These macros compensate for float imprecision
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, const char *v);
|
||||||
#define SERIAL_PROTOCOLPAIR_F_P(p, pre, value) SERIAL_PROTOCOLPAIR_P(p, pre, FIXFLOAT(value))
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, char v);
|
||||||
#define SERIAL_PROTOCOLLNPAIR_F_P(p, pre, value) SERIAL_PROTOCOLLNPAIR_P(p, pre, FIXFLOAT(value))
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, int v);
|
||||||
#define SERIAL_ECHOPAIR_F_P(p,pre,value) SERIAL_ECHOPAIR_P(p, pre, FIXFLOAT(value))
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, long v);
|
||||||
#define SERIAL_ECHOLNPAIR_F_P(p,pre, value) SERIAL_ECHOLNPAIR_P(p, pre, FIXFLOAT(value))
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, float v);
|
||||||
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, double v);
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, const char *v);
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, unsigned int v);
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, char v);
|
void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, unsigned long v);
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, int v);
|
inline void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, uint8_t v) { serial_echopair_PGM_P(p, s_P, (int)v); }
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, long v);
|
inline void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, bool v) { serial_echopair_PGM_P(p, s_P, (int)v); }
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, float v);
|
inline void serial_echopair_PGM_P(const int8_t p, PGM_P const s_P, void *v) { serial_echopair_PGM_P(p, s_P, (unsigned long)v); }
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, double v);
|
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, unsigned int v);
|
|
||||||
void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, unsigned long v);
|
|
||||||
inline void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, uint8_t v) { serial_echopair_PGM_P(p, s_P, (int)v); }
|
|
||||||
inline void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, bool v) { serial_echopair_PGM_P(p, s_P, (int)v); }
|
|
||||||
inline void serial_echopair_PGM_P(const int8_t p, PGM_P s_P, void *v) { serial_echopair_PGM_P(p, s_P, (unsigned long)v); }
|
|
||||||
|
|
||||||
void serial_spaces_P(const int8_t p, uint8_t count);
|
void serial_spaces_P(const int8_t p, uint8_t count);
|
||||||
#define SERIAL_ECHO_SP_P(p,C) serial_spaces_P(p,C)
|
#define SERIAL_ECHO_SP_P(p,C) serial_spaces_P(p,C)
|
||||||
#define SERIAL_ERROR_SP_P(p,C) serial_spaces_P(p,C)
|
|
||||||
#define SERIAL_PROTOCOL_SP_P(p,C) serial_spaces_P(p,C)
|
|
||||||
|
|
||||||
void serialprintPGM_P(const int8_t p, PGM_P str);
|
void serialprintPGM_P(const int8_t p, PGM_P str);
|
||||||
void serial_echo_start_P(const int8_t p);
|
void serial_echo_start_P(const int8_t p);
|
||||||
void serial_error_start_P(const int8_t p);
|
void serial_error_start_P(const int8_t p);
|
||||||
|
|
||||||
#else // NUM_SERIAL < 2
|
#else // NUM_SERIAL <= 1
|
||||||
|
|
||||||
#define SERIAL_CHAR_P(p,x) SERIAL_CHAR(x)
|
//
|
||||||
#define SERIAL_PROTOCOL_P(p,x) SERIAL_PROTOCOL(x)
|
// Serial out to all ports
|
||||||
#define SERIAL_PROTOCOL_F_P(p,x,y) SERIAL_PROTOCOL_F(x,y)
|
//
|
||||||
#define SERIAL_PROTOCOLLN_P(p,x) SERIAL_PROTOCOLLN(x)
|
#define SERIAL_CHAR(x) MYSERIAL0.write(x)
|
||||||
#define SERIAL_PRINT_P(p,x,b) SERIAL_PRINT(x,b)
|
#define SERIAL_ECHO(x) MYSERIAL0.print(x)
|
||||||
#define SERIAL_PRINTLN_P(p,x,b) SERIAL_PRINTLN(x,b)
|
#define SERIAL_ECHO_F(x,y) MYSERIAL0.print(x,y)
|
||||||
#define SERIAL_PRINTF_P(p,args...) SERIAL_PRINTF(args)
|
#define SERIAL_ECHOLN(x) MYSERIAL0.println(x)
|
||||||
|
#define SERIAL_PRINT(x,b) MYSERIAL0.print(x,b)
|
||||||
#define SERIAL_CHAR(x) MYSERIAL0.write(x)
|
#define SERIAL_PRINTLN(x,b) MYSERIAL0.println(x,b)
|
||||||
#define SERIAL_PROTOCOL(x) MYSERIAL0.print(x)
|
#define SERIAL_PRINTF(args...) MYSERIAL0.printf(args)
|
||||||
#define SERIAL_PROTOCOL_F(x,y) MYSERIAL0.print(x,y)
|
#define SERIAL_FLUSH() MYSERIAL0.flush()
|
||||||
#define SERIAL_PROTOCOLLN(x) MYSERIAL0.println(x)
|
|
||||||
#define SERIAL_PRINT(x,b) MYSERIAL0.print(x,b)
|
|
||||||
#define SERIAL_PRINTLN(x,b) MYSERIAL0.println(x,b)
|
|
||||||
#define SERIAL_PRINTF(args...) MYSERIAL0.printf(args)
|
|
||||||
|
|
||||||
#define SERIAL_FLUSH_P(p) SERIAL_FLUSH()
|
|
||||||
#define SERIAL_FLUSH() MYSERIAL0.flush()
|
|
||||||
#if TX_BUFFER_SIZE > 0
|
#if TX_BUFFER_SIZE > 0
|
||||||
#define SERIAL_FLUSHTX_P(p) SERIAL_FLUSHTX()
|
#define SERIAL_FLUSHTX() MYSERIAL0.flushTX()
|
||||||
#define SERIAL_FLUSHTX() MYSERIAL0.flushTX()
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define SERIAL_EOL_P(p) SERIAL_EOL()
|
//
|
||||||
|
// Serial out with port redirect
|
||||||
|
//
|
||||||
|
#define SERIAL_CHAR_P(p,x) SERIAL_CHAR(x)
|
||||||
|
#define SERIAL_ECHO_P(p,x) SERIAL_ECHO(x)
|
||||||
|
#define SERIAL_ECHO_F_P(p,x,y) SERIAL_ECHO_F(x,y)
|
||||||
|
#define SERIAL_ECHOLN_P(p,x) SERIAL_ECHOLN(x)
|
||||||
|
#define SERIAL_PRINT_P(p,x,b) SERIAL_PRINT(x,b)
|
||||||
|
#define SERIAL_PRINTLN_P(p,x,b) SERIAL_PRINTLN(x,b)
|
||||||
|
#define SERIAL_PRINTF_P(p,args...) SERIAL_PRINTF(args)
|
||||||
|
#define SERIAL_FLUSH_P(p) SERIAL_FLUSH()
|
||||||
|
#if TX_BUFFER_SIZE > 0
|
||||||
|
#define SERIAL_FLUSHTX_P(p) SERIAL_FLUSHTX()
|
||||||
|
#endif
|
||||||
|
|
||||||
#define SERIAL_PROTOCOLCHAR_P(p,x) SERIAL_PROTOCOLCHAR(x)
|
#define SERIAL_ECHOPGM_P(p,x) SERIAL_ECHOPGM(x)
|
||||||
#define SERIAL_PROTOCOLPGM_P(p,x) SERIAL_PROTOCOLPGM(x)
|
#define SERIAL_ECHOLNPGM_P(p,x) SERIAL_ECHOLNPGM(x)
|
||||||
#define SERIAL_PROTOCOLLNPGM_P(p,x) SERIAL_PROTOCOLLNPGM(x)
|
#define SERIAL_ECHOPAIR_P(p, pre, value) SERIAL_ECHOPAIR(pre, value)
|
||||||
#define SERIAL_PROTOCOLPAIR_P(p, pre, value) SERIAL_PROTOCOLPAIR(pre, value)
|
|
||||||
#define SERIAL_PROTOCOLLNPAIR_P(p, pre, value) SERIAL_PROTOCOLLNPAIR(pre, value)
|
|
||||||
|
|
||||||
#define SERIAL_ECHO_START_P(p) SERIAL_ECHO_START()
|
#define SERIAL_ECHO_P(p,x) SERIAL_ECHO(x)
|
||||||
#define SERIAL_ECHO_P(p,x) SERIAL_ECHO(x)
|
#define SERIAL_ECHOLN_P(p,x) SERIAL_ECHOLN(x)
|
||||||
#define SERIAL_ECHOPGM_P(p,x) SERIAL_ECHOPGM(x)
|
|
||||||
#define SERIAL_ECHOLN_P(p,x) SERIAL_ECHOLN(x)
|
|
||||||
#define SERIAL_ECHOLNPGM_P(p,x) SERIAL_ECHOLNPGM(x)
|
|
||||||
#define SERIAL_ECHOPAIR_P(p,pre,value) SERIAL_ECHOPAIR(pre, value)
|
|
||||||
#define SERIAL_ECHOLNPAIR_P(p,pre, value) SERIAL_ECHOLNPAIR(pre, value)
|
|
||||||
#define SERIAL_ECHO_F_P(p,x,y) SERIAL_ECHO_F(x,y)
|
|
||||||
|
|
||||||
#define SERIAL_ERROR_START_P(p) SERIAL_ERROR_START()
|
#define SERIAL_ECHO_START_P(p) SERIAL_ECHO_START()
|
||||||
#define SERIAL_ERROR_P(p,x) SERIAL_ERROR(x)
|
#define SERIAL_ERROR_START_P(p) SERIAL_ERROR_START()
|
||||||
#define SERIAL_ERRORPGM_P(p,x) SERIAL_ERRORPGM(x)
|
#define SERIAL_EOL_P(p) SERIAL_EOL()
|
||||||
#define SERIAL_ERRORLN_P(p,x) SERIAL_ERRORLN(x)
|
|
||||||
#define SERIAL_ERRORLNPGM_P(p,x) SERIAL_ERRORLNPGM(x)
|
|
||||||
|
|
||||||
// These macros compensate for float imprecision
|
#define SERIAL_ECHOPAIR_F_P(p, pre, value, y) SERIAL_ECHOPAIR_F(pre, value, y)
|
||||||
#define SERIAL_PROTOCOLPAIR_F_P(p, pre, value) SERIAL_PROTOCOLPAIR_F(pre, value)
|
#define SERIAL_ECHOLNPAIR_F_P(p, pre, value, y) SERIAL_ECHOLNPAIR_F(pre, value, y)
|
||||||
#define SERIAL_PROTOCOLLNPAIR_F_P(p, pre, value) SERIAL_PROTOCOLLNPAIR_F(pre, value)
|
|
||||||
#define SERIAL_ECHOPAIR_F_P(p,pre,value) SERIAL_ECHOPAIR_F(pre, value)
|
|
||||||
#define SERIAL_ECHOLNPAIR_F_P(p,pre, value) SERIAL_ECHOLNPAIR_F(pre, value)
|
|
||||||
|
|
||||||
#define serial_echopair_PGM_P(p,s_P,v) serial_echopair_PGM(s_P, v)
|
#define serial_echopair_PGM_P(p,s_P,v) serial_echopair_PGM(s_P, v)
|
||||||
|
|
||||||
#define serial_spaces_P(p,c) serial_spaces(c)
|
#define serial_spaces_P(p,c) serial_spaces(c)
|
||||||
#define SERIAL_ECHO_SP_P(p,C) SERIAL_ECHO_SP(C)
|
#define SERIAL_ECHO_SP_P(p,C) SERIAL_ECHO_SP(C)
|
||||||
#define SERIAL_ERROR_SP_P(p,C) SERIAL_ERROR_SP(C)
|
|
||||||
#define SERIAL_PROTOCOL_SP_P(p,C) SERIAL_PROTOCOL_SP(C)
|
|
||||||
|
|
||||||
#define serialprintPGM_P(p,s) serialprintPGM(s)
|
#define serialprintPGM_P(p,s) serialprintPGM(s)
|
||||||
|
|
||||||
#endif // NUM_SERIAL < 2
|
#endif // NUM_SERIAL < 2
|
||||||
|
|
||||||
#define SERIAL_EOL() SERIAL_CHAR('\n')
|
#define SERIAL_ECHOPGM(x) (serialprintPGM(PSTR(x)))
|
||||||
|
#define SERIAL_ECHOLNPGM(x) (serialprintPGM(PSTR(x "\n")))
|
||||||
|
#define SERIAL_ECHOPAIR(pre, value) (serial_echopair_PGM(PSTR(pre), value))
|
||||||
|
#define SERIAL_ECHOLNPAIR(pre, value) do { SERIAL_ECHOPAIR(pre, value); SERIAL_EOL(); } while(0)
|
||||||
|
|
||||||
#define SERIAL_PROTOCOLCHAR(x) SERIAL_CHAR(x)
|
#define SERIAL_ECHOPAIR_F(pre, value, y) do{ SERIAL_ECHO(pre); SERIAL_ECHO_F(value, y); }while(0)
|
||||||
#define SERIAL_PROTOCOLPGM(x) (serialprintPGM(PSTR(x)))
|
#define SERIAL_ECHOLNPAIR_F(pre, value, y) do{ SERIAL_ECHOPAIR_F(pre, value, y); SERIAL_EOL(); }while(0)
|
||||||
#define SERIAL_PROTOCOLLNPGM(x) (serialprintPGM(PSTR(x "\n")))
|
|
||||||
#define SERIAL_PROTOCOLPAIR(pre, value) (serial_echopair_PGM(PSTR(pre), value))
|
|
||||||
#define SERIAL_PROTOCOLLNPAIR(pre, value) do { SERIAL_PROTOCOLPAIR(pre, value); SERIAL_EOL(); } while(0)
|
|
||||||
|
|
||||||
#define SERIAL_ECHO_START() serial_echo_start()
|
#define SERIAL_ECHO_START() serial_echo_start()
|
||||||
#define SERIAL_ECHO(x) SERIAL_PROTOCOL(x)
|
#define SERIAL_ERROR_START() serial_error_start()
|
||||||
#define SERIAL_ECHOPGM(x) SERIAL_PROTOCOLPGM(x)
|
#define SERIAL_EOL() SERIAL_CHAR('\n')
|
||||||
#define SERIAL_ECHOLN(x) SERIAL_PROTOCOLLN(x)
|
|
||||||
#define SERIAL_ECHOLNPGM(x) SERIAL_PROTOCOLLNPGM(x)
|
|
||||||
#define SERIAL_ECHOPAIR(pre,value) SERIAL_PROTOCOLPAIR(pre, value)
|
|
||||||
#define SERIAL_ECHOLNPAIR(pre, value) SERIAL_PROTOCOLLNPAIR(pre, value)
|
|
||||||
#define SERIAL_ECHO_F(x,y) SERIAL_PROTOCOL_F(x, y)
|
|
||||||
|
|
||||||
#define SERIAL_ERROR_START() serial_error_start()
|
#define SERIAL_ECHO_MSG(STR) do{ SERIAL_ECHO_START(); SERIAL_ECHOLNPGM(STR); }while(0)
|
||||||
#define SERIAL_ERROR(x) SERIAL_PROTOCOL(x)
|
#define SERIAL_ECHO_MSG_P(p, STR) do{ SERIAL_ECHO_START_P(p); SERIAL_ECHOLNPGM_P(p, STR); }while(0)
|
||||||
#define SERIAL_ERRORPGM(x) SERIAL_PROTOCOLPGM(x)
|
#define SERIAL_ERROR_MSG(STR) do{ SERIAL_ERROR_START(); SERIAL_ECHOLNPGM(STR); }while(0)
|
||||||
#define SERIAL_ERRORLN(x) SERIAL_PROTOCOLLN(x)
|
#define SERIAL_ERROR_MSG_P(p, STR) do{ SERIAL_ERROR_START_P(p); SERIAL_ECHOLNPGM_P(p, STR); }while(0)
|
||||||
#define SERIAL_ERRORLNPGM(x) SERIAL_PROTOCOLLNPGM(x)
|
|
||||||
|
|
||||||
// These macros compensate for float imprecision
|
#define SERIAL_ECHOLNPAIR_P(p, pre, value) do{ SERIAL_ECHOPAIR_P(p, pre, value); SERIAL_EOL_P(p); }while(0)
|
||||||
#define SERIAL_PROTOCOLPAIR_F(pre, value) SERIAL_PROTOCOLPAIR(pre, FIXFLOAT(value))
|
|
||||||
#define SERIAL_PROTOCOLLNPAIR_F(pre, value) SERIAL_PROTOCOLLNPAIR(pre, FIXFLOAT(value))
|
|
||||||
#define SERIAL_ECHOPAIR_F(pre,value) SERIAL_ECHOPAIR(pre, FIXFLOAT(value))
|
|
||||||
#define SERIAL_ECHOLNPAIR_F(pre, value) SERIAL_ECHOLNPAIR(pre, FIXFLOAT(value))
|
|
||||||
|
|
||||||
void serial_echopair_PGM(PGM_P s_P, const char *v);
|
|
||||||
void serial_echopair_PGM(PGM_P s_P, char v);
|
|
||||||
void serial_echopair_PGM(PGM_P s_P, int v);
|
|
||||||
void serial_echopair_PGM(PGM_P s_P, long v);
|
|
||||||
void serial_echopair_PGM(PGM_P s_P, float v);
|
|
||||||
void serial_echopair_PGM(PGM_P s_P, double v);
|
|
||||||
void serial_echopair_PGM(PGM_P s_P, unsigned int v);
|
|
||||||
void serial_echopair_PGM(PGM_P s_P, unsigned long v);
|
|
||||||
inline void serial_echopair_PGM(PGM_P s_P, uint8_t v) { serial_echopair_PGM(s_P, (int)v); }
|
|
||||||
inline void serial_echopair_PGM(PGM_P s_P, bool v) { serial_echopair_PGM(s_P, (int)v); }
|
|
||||||
inline void serial_echopair_PGM(PGM_P s_P, void *v) { serial_echopair_PGM(s_P, (unsigned long)v); }
|
|
||||||
|
|
||||||
void serial_spaces(uint8_t count);
|
void serial_spaces(uint8_t count);
|
||||||
#define SERIAL_ECHO_SP(C) serial_spaces(C)
|
#define SERIAL_ECHO_SP(C) serial_spaces(C)
|
||||||
#define SERIAL_ERROR_SP(C) serial_spaces(C)
|
|
||||||
#define SERIAL_PROTOCOL_SP(C) serial_spaces(C)
|
|
||||||
|
|
||||||
//
|
//
|
||||||
// Functions for serial printing from PROGMEM. (Saves loads of SRAM.)
|
// Functions for serial printing from PROGMEM. (Saves loads of SRAM.)
|
||||||
//
|
//
|
||||||
|
void serial_echopair_PGM(PGM_P const s_P, const char *v);
|
||||||
|
void serial_echopair_PGM(PGM_P const s_P, char v);
|
||||||
|
void serial_echopair_PGM(PGM_P const s_P, int v);
|
||||||
|
void serial_echopair_PGM(PGM_P const s_P, long v);
|
||||||
|
void serial_echopair_PGM(PGM_P const s_P, float v);
|
||||||
|
void serial_echopair_PGM(PGM_P const s_P, double v);
|
||||||
|
void serial_echopair_PGM(PGM_P const s_P, unsigned int v);
|
||||||
|
void serial_echopair_PGM(PGM_P const s_P, unsigned long v);
|
||||||
|
inline void serial_echopair_PGM(PGM_P const s_P, uint8_t v) { serial_echopair_PGM(s_P, (int)v); }
|
||||||
|
inline void serial_echopair_PGM(PGM_P const s_P, bool v) { serial_echopair_PGM(s_P, (int)v); }
|
||||||
|
inline void serial_echopair_PGM(PGM_P const s_P, void *v) { serial_echopair_PGM(s_P, (unsigned long)v); }
|
||||||
|
|
||||||
void serialprintPGM(PGM_P str);
|
void serialprintPGM(PGM_P str);
|
||||||
void serial_echo_start();
|
void serial_echo_start();
|
||||||
void serial_error_start();
|
void serial_error_start();
|
||||||
|
@ -242,7 +208,7 @@ void serialprint_onoff(const bool onoff);
|
||||||
void serialprintln_onoff(const bool onoff);
|
void serialprintln_onoff(const bool onoff);
|
||||||
|
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
void print_xyz(PGM_P prefix, PGM_P suffix, const float x, const float y, const float z);
|
void print_xyz(PGM_P const prefix, PGM_P const suffix, const float x, const float y, const float z);
|
||||||
void print_xyz(PGM_P prefix, PGM_P suffix, const float xyz[]);
|
void print_xyz(PGM_P const prefix, PGM_P const suffix, const float xyz[]);
|
||||||
#define DEBUG_POS(SUFFIX,VAR) do { print_xyz(PSTR(" " STRINGIFY(VAR) "="), PSTR(" : " SUFFIX "\n"), VAR); } while(0)
|
#define DEBUG_POS(SUFFIX,VAR) do { print_xyz(PSTR(" " STRINGIFY(VAR) "="), PSTR(" : " SUFFIX "\n"), VAR); } while(0)
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -66,8 +66,7 @@ void I2CPositionEncoder::update() {
|
||||||
/*
|
/*
|
||||||
if (trusted) { //commented out as part of the note below
|
if (trusted) { //commented out as part of the note below
|
||||||
trusted = false;
|
trusted = false;
|
||||||
SERIAL_ECHOPGM("Fault detected on ");
|
SERIAL_ECHOPAIR("Fault detected on ", axis_codes[encoderAxis]);
|
||||||
SERIAL_ECHO(axis_codes[encoderAxis]);
|
|
||||||
SERIAL_ECHOLNPGM(" axis encoder. Disengaging error correction until module is trusted again.");
|
SERIAL_ECHOLNPGM(" axis encoder. Disengaging error correction until module is trusted again.");
|
||||||
}
|
}
|
||||||
*/
|
*/
|
||||||
|
@ -93,8 +92,7 @@ void I2CPositionEncoder::update() {
|
||||||
if (millis() - lastErrorTime > I2CPE_TIME_TRUSTED) {
|
if (millis() - lastErrorTime > I2CPE_TIME_TRUSTED) {
|
||||||
trusted = true;
|
trusted = true;
|
||||||
|
|
||||||
SERIAL_ECHOPGM("Untrusted encoder module on ");
|
SERIAL_ECHOPAIR("Untrusted encoder module on ", axis_codes[encoderAxis]);
|
||||||
SERIAL_ECHO(axis_codes[encoderAxis]);
|
|
||||||
SERIAL_ECHOLNPGM(" axis has been fault-free for set duration, reinstating error correction.");
|
SERIAL_ECHOLNPGM(" axis has been fault-free for set duration, reinstating error correction.");
|
||||||
|
|
||||||
//the encoder likely lost its place when the error occured, so we'll reset and use the printer's
|
//the encoder likely lost its place when the error occured, so we'll reset and use the printer's
|
||||||
|
@ -106,17 +104,10 @@ void I2CPositionEncoder::update() {
|
||||||
zeroOffset -= (positionInTicks - get_position());
|
zeroOffset -= (positionInTicks - get_position());
|
||||||
|
|
||||||
#ifdef I2CPE_DEBUG
|
#ifdef I2CPE_DEBUG
|
||||||
SERIAL_ECHOPGM("Current position is ");
|
SERIAL_ECHOLNPAIR("Current position is ", pos);
|
||||||
SERIAL_ECHOLN(pos);
|
SERIAL_ECHOLNPAIR("Position in encoder ticks is ", positionInTicks);
|
||||||
|
SERIAL_ECHOLNPAIR("New zero-offset of ", zeroOffset);
|
||||||
SERIAL_ECHOPGM("Position in encoder ticks is ");
|
SERIAL_ECHOPAIR("New position reads as ", get_position());
|
||||||
SERIAL_ECHOLN(positionInTicks);
|
|
||||||
|
|
||||||
SERIAL_ECHOPGM("New zero-offset of ");
|
|
||||||
SERIAL_ECHOLN(zeroOffset);
|
|
||||||
|
|
||||||
SERIAL_ECHOPGM("New position reads as ");
|
|
||||||
SERIAL_ECHO(get_position());
|
|
||||||
SERIAL_CHAR('(');
|
SERIAL_CHAR('(');
|
||||||
SERIAL_ECHO(mm_from_count(get_position()));
|
SERIAL_ECHO(mm_from_count(get_position()));
|
||||||
SERIAL_ECHOLNPGM(")");
|
SERIAL_ECHOLNPGM(")");
|
||||||
|
@ -159,14 +150,12 @@ void I2CPositionEncoder::update() {
|
||||||
const int32_t error = get_axis_error_steps(false);
|
const int32_t error = get_axis_error_steps(false);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
//SERIAL_ECHOPGM("Axis error steps: ");
|
//SERIAL_ECHOLNPAIR("Axis error steps: ", error);
|
||||||
//SERIAL_ECHOLN(error);
|
|
||||||
|
|
||||||
#ifdef I2CPE_ERR_THRESH_ABORT
|
#ifdef I2CPE_ERR_THRESH_ABORT
|
||||||
if (ABS(error) > I2CPE_ERR_THRESH_ABORT * planner.settings.axis_steps_per_mm[encoderAxis]) {
|
if (ABS(error) > I2CPE_ERR_THRESH_ABORT * planner.settings.axis_steps_per_mm[encoderAxis]) {
|
||||||
//kill(PSTR("Significant Error"));
|
//kill(PSTR("Significant Error"));
|
||||||
SERIAL_ECHOPGM("Axis error greater than set threshold, aborting!");
|
SERIAL_ECHOLNPAIR("Axis error greater than set threshold, aborting!", error);
|
||||||
SERIAL_ECHOLN(error);
|
|
||||||
safe_delay(5000);
|
safe_delay(5000);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -800,33 +789,33 @@ int8_t I2CPositionEncodersMgr::parse() {
|
||||||
if (parser.seen('A')) {
|
if (parser.seen('A')) {
|
||||||
|
|
||||||
if (!parser.has_value()) {
|
if (!parser.has_value()) {
|
||||||
SERIAL_PROTOCOLLNPGM("?A seen, but no address specified! [30-200]");
|
SERIAL_ECHOLNPGM("?A seen, but no address specified! [30-200]");
|
||||||
return I2CPE_PARSE_ERR;
|
return I2CPE_PARSE_ERR;
|
||||||
};
|
};
|
||||||
|
|
||||||
I2CPE_addr = parser.value_byte();
|
I2CPE_addr = parser.value_byte();
|
||||||
if (!WITHIN(I2CPE_addr, 30, 200)) { // reserve the first 30 and last 55
|
if (!WITHIN(I2CPE_addr, 30, 200)) { // reserve the first 30 and last 55
|
||||||
SERIAL_PROTOCOLLNPGM("?Address out of range. [30-200]");
|
SERIAL_ECHOLNPGM("?Address out of range. [30-200]");
|
||||||
return I2CPE_PARSE_ERR;
|
return I2CPE_PARSE_ERR;
|
||||||
}
|
}
|
||||||
|
|
||||||
I2CPE_idx = idx_from_addr(I2CPE_addr);
|
I2CPE_idx = idx_from_addr(I2CPE_addr);
|
||||||
if (I2CPE_idx >= I2CPE_ENCODER_CNT) {
|
if (I2CPE_idx >= I2CPE_ENCODER_CNT) {
|
||||||
SERIAL_PROTOCOLLNPGM("?No device with this address!");
|
SERIAL_ECHOLNPGM("?No device with this address!");
|
||||||
return I2CPE_PARSE_ERR;
|
return I2CPE_PARSE_ERR;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if (parser.seenval('I')) {
|
else if (parser.seenval('I')) {
|
||||||
|
|
||||||
if (!parser.has_value()) {
|
if (!parser.has_value()) {
|
||||||
SERIAL_PROTOCOLLNPAIR("?I seen, but no index specified! [0-", I2CPE_ENCODER_CNT - 1);
|
SERIAL_ECHOLNPAIR("?I seen, but no index specified! [0-", I2CPE_ENCODER_CNT - 1);
|
||||||
SERIAL_PROTOCOLLNPGM("]");
|
SERIAL_ECHOLNPGM("]");
|
||||||
return I2CPE_PARSE_ERR;
|
return I2CPE_PARSE_ERR;
|
||||||
};
|
};
|
||||||
|
|
||||||
I2CPE_idx = parser.value_byte();
|
I2CPE_idx = parser.value_byte();
|
||||||
if (I2CPE_idx >= I2CPE_ENCODER_CNT) {
|
if (I2CPE_idx >= I2CPE_ENCODER_CNT) {
|
||||||
SERIAL_PROTOCOLLNPAIR("?Index out of range. [0-", I2CPE_ENCODER_CNT - 1);
|
SERIAL_ECHOLNPAIR("?Index out of range. [0-", I2CPE_ENCODER_CNT - 1);
|
||||||
SERIAL_ECHOLNPGM("]");
|
SERIAL_ECHOLNPGM("]");
|
||||||
return I2CPE_PARSE_ERR;
|
return I2CPE_PARSE_ERR;
|
||||||
}
|
}
|
||||||
|
@ -984,18 +973,18 @@ void I2CPositionEncodersMgr::M864() {
|
||||||
|
|
||||||
if (parser.seen('S')) {
|
if (parser.seen('S')) {
|
||||||
if (!parser.has_value()) {
|
if (!parser.has_value()) {
|
||||||
SERIAL_PROTOCOLLNPGM("?S seen, but no address specified! [30-200]");
|
SERIAL_ECHOLNPGM("?S seen, but no address specified! [30-200]");
|
||||||
return;
|
return;
|
||||||
};
|
};
|
||||||
|
|
||||||
newAddress = parser.value_byte();
|
newAddress = parser.value_byte();
|
||||||
if (!WITHIN(newAddress, 30, 200)) {
|
if (!WITHIN(newAddress, 30, 200)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?New address out of range. [30-200]");
|
SERIAL_ECHOLNPGM("?New address out of range. [30-200]");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if (!I2CPE_anyaxis) {
|
else if (!I2CPE_anyaxis) {
|
||||||
SERIAL_PROTOCOLLNPGM("?You must specify S or [XYZE].");
|
SERIAL_ECHOLNPGM("?You must specify S or [XYZE].");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
|
|
|
@ -288,7 +288,7 @@ class I2CPositionEncodersMgr {
|
||||||
CHECK_IDX();
|
CHECK_IDX();
|
||||||
encoders[idx].set_ec_threshold(newThreshold);
|
encoders[idx].set_ec_threshold(newThreshold);
|
||||||
SERIAL_ECHOPAIR("Error correct threshold for ", axis_codes[axis]);
|
SERIAL_ECHOPAIR("Error correct threshold for ", axis_codes[axis]);
|
||||||
SERIAL_ECHOPAIR_F(" axis set to ", newThreshold);
|
SERIAL_ECHOPAIR(" axis set to ", FIXFLOAT(newThreshold));
|
||||||
SERIAL_ECHOLNPGM("mm.");
|
SERIAL_ECHOLNPGM("mm.");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -296,7 +296,7 @@ class I2CPositionEncodersMgr {
|
||||||
CHECK_IDX();
|
CHECK_IDX();
|
||||||
const float threshold = encoders[idx].get_ec_threshold();
|
const float threshold = encoders[idx].get_ec_threshold();
|
||||||
SERIAL_ECHOPAIR("Error correct threshold for ", axis_codes[axis]);
|
SERIAL_ECHOPAIR("Error correct threshold for ", axis_codes[axis]);
|
||||||
SERIAL_ECHOPAIR_F(" axis is ", threshold);
|
SERIAL_ECHOPAIR(" axis is ", FIXFLOAT(threshold));
|
||||||
SERIAL_ECHOLNPGM("mm.");
|
SERIAL_ECHOLNPGM("mm.");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -160,50 +160,50 @@ void reset_bed_level() {
|
||||||
#ifndef SCAD_MESH_OUTPUT
|
#ifndef SCAD_MESH_OUTPUT
|
||||||
for (uint8_t x = 0; x < sx; x++) {
|
for (uint8_t x = 0; x < sx; x++) {
|
||||||
serial_spaces(precision + (x < 10 ? 3 : 2));
|
serial_spaces(precision + (x < 10 ? 3 : 2));
|
||||||
SERIAL_PROTOCOL(int(x));
|
SERIAL_ECHO(int(x));
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
#endif
|
#endif
|
||||||
#ifdef SCAD_MESH_OUTPUT
|
#ifdef SCAD_MESH_OUTPUT
|
||||||
SERIAL_PROTOCOLLNPGM("measured_z = ["); // open 2D array
|
SERIAL_ECHOLNPGM("measured_z = ["); // open 2D array
|
||||||
#endif
|
#endif
|
||||||
for (uint8_t y = 0; y < sy; y++) {
|
for (uint8_t y = 0; y < sy; y++) {
|
||||||
#ifdef SCAD_MESH_OUTPUT
|
#ifdef SCAD_MESH_OUTPUT
|
||||||
SERIAL_PROTOCOLPGM(" ["); // open sub-array
|
SERIAL_ECHOPGM(" ["); // open sub-array
|
||||||
#else
|
#else
|
||||||
if (y < 10) SERIAL_PROTOCOLCHAR(' ');
|
if (y < 10) SERIAL_CHAR(' ');
|
||||||
SERIAL_PROTOCOL(int(y));
|
SERIAL_ECHO(int(y));
|
||||||
#endif
|
#endif
|
||||||
for (uint8_t x = 0; x < sx; x++) {
|
for (uint8_t x = 0; x < sx; x++) {
|
||||||
SERIAL_PROTOCOLCHAR(' ');
|
SERIAL_CHAR(' ');
|
||||||
const float offset = fn(x, y);
|
const float offset = fn(x, y);
|
||||||
if (!isnan(offset)) {
|
if (!isnan(offset)) {
|
||||||
if (offset >= 0) SERIAL_PROTOCOLCHAR('+');
|
if (offset >= 0) SERIAL_CHAR('+');
|
||||||
SERIAL_PROTOCOL_F(offset, int(precision));
|
SERIAL_ECHO_F(offset, int(precision));
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
#ifdef SCAD_MESH_OUTPUT
|
#ifdef SCAD_MESH_OUTPUT
|
||||||
for (uint8_t i = 3; i < precision + 3; i++)
|
for (uint8_t i = 3; i < precision + 3; i++)
|
||||||
SERIAL_PROTOCOLCHAR(' ');
|
SERIAL_CHAR(' ');
|
||||||
SERIAL_PROTOCOLPGM("NAN");
|
SERIAL_ECHOPGM("NAN");
|
||||||
#else
|
#else
|
||||||
for (uint8_t i = 0; i < precision + 3; i++)
|
for (uint8_t i = 0; i < precision + 3; i++)
|
||||||
SERIAL_PROTOCOLCHAR(i ? '=' : ' ');
|
SERIAL_CHAR(i ? '=' : ' ');
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
#ifdef SCAD_MESH_OUTPUT
|
#ifdef SCAD_MESH_OUTPUT
|
||||||
if (x < sx - 1) SERIAL_PROTOCOLCHAR(',');
|
if (x < sx - 1) SERIAL_CHAR(',');
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
#ifdef SCAD_MESH_OUTPUT
|
#ifdef SCAD_MESH_OUTPUT
|
||||||
SERIAL_PROTOCOLCHAR(' ');
|
SERIAL_CHAR(' ');
|
||||||
SERIAL_PROTOCOLCHAR(']'); // close sub-array
|
SERIAL_CHAR(']'); // close sub-array
|
||||||
if (y < sy - 1) SERIAL_PROTOCOLCHAR(',');
|
if (y < sy - 1) SERIAL_CHAR(',');
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
#ifdef SCAD_MESH_OUTPUT
|
#ifdef SCAD_MESH_OUTPUT
|
||||||
SERIAL_PROTOCOLPGM("];"); // close 2D array
|
SERIAL_ECHOPGM("];"); // close 2D array
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
|
|
@ -119,9 +119,8 @@
|
||||||
#endif // IS_CARTESIAN && !SEGMENT_LEVELED_MOVES
|
#endif // IS_CARTESIAN && !SEGMENT_LEVELED_MOVES
|
||||||
|
|
||||||
void mesh_bed_leveling::report_mesh() {
|
void mesh_bed_leveling::report_mesh() {
|
||||||
SERIAL_PROTOCOLPGM(STRINGIFY(GRID_MAX_POINTS_X) "x" STRINGIFY(GRID_MAX_POINTS_Y) " mesh. Z offset: ");
|
SERIAL_ECHOPAIR_F(STRINGIFY(GRID_MAX_POINTS_X) "x" STRINGIFY(GRID_MAX_POINTS_Y) " mesh. Z offset: ", z_offset, 5);
|
||||||
SERIAL_PROTOCOL_F(z_offset, 5);
|
SERIAL_ECHOLNPGM("\nMeasured points:");
|
||||||
SERIAL_PROTOCOLLNPGM("\nMeasured points:");
|
|
||||||
print_2d_array(GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y, 5,
|
print_2d_array(GRID_MAX_POINTS_X, GRID_MAX_POINTS_Y, 5,
|
||||||
[](const uint8_t ix, const uint8_t iy) { return z_values[ix][iy]; }
|
[](const uint8_t ix, const uint8_t iy) { return z_values[ix][iy]; }
|
||||||
);
|
);
|
||||||
|
|
|
@ -39,7 +39,7 @@
|
||||||
const int8_t port/*= -1*/
|
const int8_t port/*= -1*/
|
||||||
#endif
|
#endif
|
||||||
) {
|
) {
|
||||||
SERIAL_PROTOCOLPGM_P(port, "Unified Bed Leveling");
|
SERIAL_ECHOPGM_P(port, "Unified Bed Leveling");
|
||||||
}
|
}
|
||||||
|
|
||||||
void unified_bed_leveling::report_current_mesh(
|
void unified_bed_leveling::report_current_mesh(
|
||||||
|
@ -48,16 +48,14 @@
|
||||||
#endif
|
#endif
|
||||||
) {
|
) {
|
||||||
if (!leveling_is_valid()) return;
|
if (!leveling_is_valid()) return;
|
||||||
SERIAL_ECHO_START_P(port);
|
SERIAL_ECHO_MSG_P(port, " G29 I99");
|
||||||
SERIAL_ECHOLNPGM_P(port, " G29 I99");
|
|
||||||
for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++)
|
for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++)
|
||||||
for (uint8_t y = 0; y < GRID_MAX_POINTS_Y; y++)
|
for (uint8_t y = 0; y < GRID_MAX_POINTS_Y; y++)
|
||||||
if (!isnan(z_values[x][y])) {
|
if (!isnan(z_values[x][y])) {
|
||||||
SERIAL_ECHO_START_P(port);
|
SERIAL_ECHO_START_P(port);
|
||||||
SERIAL_ECHOPAIR_P(port, " M421 I", x);
|
SERIAL_ECHOPAIR_P(port, " M421 I", x);
|
||||||
SERIAL_ECHOPAIR_P(port, " J", y);
|
SERIAL_ECHOPAIR_P(port, " J", y);
|
||||||
SERIAL_ECHOPGM_P(port, " Z");
|
SERIAL_ECHOPAIR_F_P(port, " Z", z_values[x][y], 2);
|
||||||
SERIAL_ECHO_F_P(port, z_values[x][y], 2);
|
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
serial_delay(75); // Prevent Printrun from exploding
|
serial_delay(75); // Prevent Printrun from exploding
|
||||||
}
|
}
|
||||||
|
@ -73,9 +71,9 @@
|
||||||
port
|
port
|
||||||
#endif
|
#endif
|
||||||
);
|
);
|
||||||
SERIAL_PROTOCOLPGM_P(port, " System v" UBL_VERSION " ");
|
SERIAL_ECHOPGM_P(port, " System v" UBL_VERSION " ");
|
||||||
if (!planner.leveling_active) SERIAL_PROTOCOLPGM_P(port, "in");
|
if (!planner.leveling_active) SERIAL_ECHOPGM_P(port, "in");
|
||||||
SERIAL_PROTOCOLLNPGM_P(port, "active.");
|
SERIAL_ECHOLNPGM_P(port, "active.");
|
||||||
serial_delay(50);
|
serial_delay(50);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -105,16 +103,16 @@
|
||||||
if (xy_dist == 0.0) return;
|
if (xy_dist == 0.0) return;
|
||||||
|
|
||||||
const float fpmm = de / xy_dist;
|
const float fpmm = de / xy_dist;
|
||||||
SERIAL_ECHOPGM(" fpmm="); SERIAL_ECHO_F(fpmm, 6);
|
SERIAL_ECHOPAIR_F(" fpmm=", fpmm, 6);
|
||||||
SERIAL_ECHOPGM(" current=( ");
|
SERIAL_ECHOPAIR_F(" current=( ", current_position[X_AXIS], 6);
|
||||||
SERIAL_ECHO_F(current_position[X_AXIS], 6); SERIAL_ECHOPGM(", ");
|
SERIAL_ECHOPAIR_F(", ", current_position[Y_AXIS], 6);
|
||||||
SERIAL_ECHO_F(current_position[Y_AXIS], 6); SERIAL_ECHOPGM(", ");
|
SERIAL_ECHOPAIR_F(", ", current_position[Z_AXIS], 6);
|
||||||
SERIAL_ECHO_F(current_position[Z_AXIS], 6); SERIAL_ECHOPGM(", ");
|
SERIAL_ECHOPAIR_F(", ", current_position[E_AXIS], 6);
|
||||||
SERIAL_ECHO_F(current_position[E_AXIS], 6); SERIAL_ECHOPGM(" ) destination=( ");
|
SERIAL_ECHOPGM(" ) destination=( "); debug_echo_axis(X_AXIS);
|
||||||
debug_echo_axis(X_AXIS); SERIAL_ECHOPGM(", ");
|
SERIAL_ECHOPGM(", "); debug_echo_axis(Y_AXIS);
|
||||||
debug_echo_axis(Y_AXIS); SERIAL_ECHOPGM(", ");
|
SERIAL_ECHOPGM(", "); debug_echo_axis(Z_AXIS);
|
||||||
debug_echo_axis(Z_AXIS); SERIAL_ECHOPGM(", ");
|
SERIAL_ECHOPGM(", "); debug_echo_axis(E_AXIS);
|
||||||
debug_echo_axis(E_AXIS); SERIAL_ECHOPGM(" ) ");
|
SERIAL_ECHOPGM(" ) ");
|
||||||
serialprintPGM(title);
|
serialprintPGM(title);
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
@ -279,7 +277,7 @@
|
||||||
uint8_t error_flag = 0;
|
uint8_t error_flag = 0;
|
||||||
|
|
||||||
if (settings.calc_num_meshes() < 1) {
|
if (settings.calc_num_meshes() < 1) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Mesh too big for EEPROM.");
|
SERIAL_ECHOLNPGM("?Mesh too big for EEPROM.");
|
||||||
error_flag++;
|
error_flag++;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -308,19 +308,13 @@ class unified_bed_leveling {
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
if (DEBUGGING(MESH_ADJUST)) {
|
if (DEBUGGING(MESH_ADJUST)) {
|
||||||
SERIAL_ECHOPAIR(" raw get_z_correction(", rx0);
|
SERIAL_ECHOPAIR(" raw get_z_correction(", rx0);
|
||||||
SERIAL_CHAR(',');
|
SERIAL_CHAR(','); SERIAL_ECHO(ry0);
|
||||||
SERIAL_ECHO(ry0);
|
SERIAL_ECHOPAIR_F(") = ", z0, 6);
|
||||||
SERIAL_ECHOPGM(") = ");
|
|
||||||
SERIAL_ECHO_F(z0, 6);
|
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
if (DEBUGGING(MESH_ADJUST)) {
|
if (DEBUGGING(MESH_ADJUST)) SERIAL_ECHOLNPAIR_F(" >>>---> ", z0, 6);
|
||||||
SERIAL_ECHOPGM(" >>>---> ");
|
|
||||||
SERIAL_ECHO_F(z0, 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
}
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN
|
if (isnan(z0)) { // if part of the Mesh is undefined, it will show up as NAN
|
||||||
|
|
|
@ -331,23 +331,23 @@
|
||||||
// meant to invalidate the ENTIRE mesh, which cannot be done with
|
// meant to invalidate the ENTIRE mesh, which cannot be done with
|
||||||
// find_closest_mesh_point loop which only returns REACHABLE points.
|
// find_closest_mesh_point loop which only returns REACHABLE points.
|
||||||
set_all_mesh_points_to_value(NAN);
|
set_all_mesh_points_to_value(NAN);
|
||||||
SERIAL_PROTOCOLLNPGM("Entire Mesh invalidated.\n");
|
SERIAL_ECHOLNPGM("Entire Mesh invalidated.\n");
|
||||||
break; // No more invalid Mesh Points to populate
|
break; // No more invalid Mesh Points to populate
|
||||||
}
|
}
|
||||||
z_values[location.x_index][location.y_index] = NAN;
|
z_values[location.x_index][location.y_index] = NAN;
|
||||||
cnt++;
|
cnt++;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
SERIAL_PROTOCOLLNPGM("Locations invalidated.\n");
|
SERIAL_ECHOLNPGM("Locations invalidated.\n");
|
||||||
}
|
}
|
||||||
|
|
||||||
if (parser.seen('Q')) {
|
if (parser.seen('Q')) {
|
||||||
const int test_pattern = parser.has_value() ? parser.value_int() : -99;
|
const int test_pattern = parser.has_value() ? parser.value_int() : -99;
|
||||||
if (!WITHIN(test_pattern, -1, 2)) {
|
if (!WITHIN(test_pattern, -1, 2)) {
|
||||||
SERIAL_PROTOCOLLNPGM("Invalid test_pattern value. (-1 to 2)\n");
|
SERIAL_ECHOLNPGM("Invalid test_pattern value. (-1 to 2)\n");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
SERIAL_PROTOCOLLNPGM("Loading test_pattern values.\n");
|
SERIAL_ECHOLNPGM("Loading test_pattern values.\n");
|
||||||
switch (test_pattern) {
|
switch (test_pattern) {
|
||||||
|
|
||||||
#if ENABLED(UBL_DEVEL_DEBUGGING)
|
#if ENABLED(UBL_DEVEL_DEBUGGING)
|
||||||
|
@ -405,7 +405,7 @@
|
||||||
if (parser.seen('P')) {
|
if (parser.seen('P')) {
|
||||||
if (WITHIN(g29_phase_value, 0, 1) && storage_slot == -1) {
|
if (WITHIN(g29_phase_value, 0, 1) && storage_slot == -1) {
|
||||||
storage_slot = 0;
|
storage_slot = 0;
|
||||||
SERIAL_PROTOCOLLNPGM("Default storage slot 0 selected.");
|
SERIAL_ECHOLNPGM("Default storage slot 0 selected.");
|
||||||
}
|
}
|
||||||
|
|
||||||
switch (g29_phase_value) {
|
switch (g29_phase_value) {
|
||||||
|
@ -414,7 +414,7 @@
|
||||||
// Zero Mesh Data
|
// Zero Mesh Data
|
||||||
//
|
//
|
||||||
reset();
|
reset();
|
||||||
SERIAL_PROTOCOLLNPGM("Mesh zeroed.");
|
SERIAL_ECHOLNPGM("Mesh zeroed.");
|
||||||
break;
|
break;
|
||||||
|
|
||||||
#if HAS_BED_PROBE
|
#if HAS_BED_PROBE
|
||||||
|
@ -425,13 +425,13 @@
|
||||||
//
|
//
|
||||||
if (!parser.seen('C')) {
|
if (!parser.seen('C')) {
|
||||||
invalidate();
|
invalidate();
|
||||||
SERIAL_PROTOCOLLNPGM("Mesh invalidated. Probing mesh.");
|
SERIAL_ECHOLNPGM("Mesh invalidated. Probing mesh.");
|
||||||
}
|
}
|
||||||
if (g29_verbose_level > 1) {
|
if (g29_verbose_level > 1) {
|
||||||
SERIAL_PROTOCOLPAIR("Probing Mesh Points Closest to (", g29_x_pos);
|
SERIAL_ECHOPAIR("Probing Mesh Points Closest to (", g29_x_pos);
|
||||||
SERIAL_PROTOCOLCHAR(',');
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOL(g29_y_pos);
|
SERIAL_ECHO(g29_y_pos);
|
||||||
SERIAL_PROTOCOLLNPGM(").\n");
|
SERIAL_ECHOLNPGM(").\n");
|
||||||
}
|
}
|
||||||
probe_entire_mesh(g29_x_pos + X_PROBE_OFFSET_FROM_EXTRUDER, g29_y_pos + Y_PROBE_OFFSET_FROM_EXTRUDER,
|
probe_entire_mesh(g29_x_pos + X_PROBE_OFFSET_FROM_EXTRUDER, g29_y_pos + Y_PROBE_OFFSET_FROM_EXTRUDER,
|
||||||
parser.seen('T'), parser.seen('E'), parser.seen('U'));
|
parser.seen('T'), parser.seen('E'), parser.seen('U'));
|
||||||
|
@ -446,7 +446,7 @@
|
||||||
//
|
//
|
||||||
// Manually Probe Mesh in areas that can't be reached by the probe
|
// Manually Probe Mesh in areas that can't be reached by the probe
|
||||||
//
|
//
|
||||||
SERIAL_PROTOCOLLNPGM("Manually probing unreachable mesh locations.");
|
SERIAL_ECHOLNPGM("Manually probing unreachable mesh locations.");
|
||||||
do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES);
|
do_blocking_move_to_z(Z_CLEARANCE_BETWEEN_PROBES);
|
||||||
|
|
||||||
if (parser.seen('C') && !g29_x_flag && !g29_y_flag) {
|
if (parser.seen('C') && !g29_x_flag && !g29_y_flag) {
|
||||||
|
@ -469,26 +469,26 @@
|
||||||
if (parser.seen('B')) {
|
if (parser.seen('B')) {
|
||||||
g29_card_thickness = parser.has_value() ? parser.value_float() : measure_business_card_thickness((float) Z_CLEARANCE_BETWEEN_PROBES);
|
g29_card_thickness = parser.has_value() ? parser.value_float() : measure_business_card_thickness((float) Z_CLEARANCE_BETWEEN_PROBES);
|
||||||
if (ABS(g29_card_thickness) > 1.5f) {
|
if (ABS(g29_card_thickness) > 1.5f) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Error in Business Card measurement.");
|
SERIAL_ECHOLNPGM("?Error in Business Card measurement.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!position_is_reachable(g29_x_pos, g29_y_pos)) {
|
if (!position_is_reachable(g29_x_pos, g29_y_pos)) {
|
||||||
SERIAL_PROTOCOLLNPGM("XY outside printable radius.");
|
SERIAL_ECHOLNPGM("XY outside printable radius.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
const float height = parser.floatval('H', Z_CLEARANCE_BETWEEN_PROBES);
|
const float height = parser.floatval('H', Z_CLEARANCE_BETWEEN_PROBES);
|
||||||
manually_probe_remaining_mesh(g29_x_pos, g29_y_pos, height, g29_card_thickness, parser.seen('T'));
|
manually_probe_remaining_mesh(g29_x_pos, g29_y_pos, height, g29_card_thickness, parser.seen('T'));
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("G29 P2 finished.");
|
SERIAL_ECHOLNPGM("G29 P2 finished.");
|
||||||
|
|
||||||
report_current_position();
|
report_current_position();
|
||||||
|
|
||||||
#else
|
#else
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("?P2 is only available when an LCD is present.");
|
SERIAL_ECHOLNPGM("?P2 is only available when an LCD is present.");
|
||||||
return;
|
return;
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
@ -553,7 +553,7 @@
|
||||||
#if HAS_LCD_MENU
|
#if HAS_LCD_MENU
|
||||||
fine_tune_mesh(g29_x_pos, g29_y_pos, parser.seen('T'));
|
fine_tune_mesh(g29_x_pos, g29_y_pos, parser.seen('T'));
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOLLNPGM("?P4 is only available when an LCD is present.");
|
SERIAL_ECHOLNPGM("?P4 is only available when an LCD is present.");
|
||||||
return;
|
return;
|
||||||
#endif
|
#endif
|
||||||
break;
|
break;
|
||||||
|
@ -593,20 +593,20 @@
|
||||||
int16_t a = settings.calc_num_meshes();
|
int16_t a = settings.calc_num_meshes();
|
||||||
|
|
||||||
if (!a) {
|
if (!a) {
|
||||||
SERIAL_PROTOCOLLNPGM("?EEPROM storage not available.");
|
SERIAL_ECHOLNPGM("?EEPROM storage not available.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!WITHIN(g29_storage_slot, 0, a - 1)) {
|
if (!WITHIN(g29_storage_slot, 0, a - 1)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Invalid storage slot.");
|
SERIAL_ECHOLNPGM("?Invalid storage slot.");
|
||||||
SERIAL_PROTOCOLLNPAIR("?Use 0 to ", a - 1);
|
SERIAL_ECHOLNPAIR("?Use 0 to ", a - 1);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
settings.load_mesh(g29_storage_slot);
|
settings.load_mesh(g29_storage_slot);
|
||||||
storage_slot = g29_storage_slot;
|
storage_slot = g29_storage_slot;
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("Done.");
|
SERIAL_ECHOLNPGM("Done.");
|
||||||
}
|
}
|
||||||
|
|
||||||
//
|
//
|
||||||
|
@ -622,20 +622,20 @@
|
||||||
int16_t a = settings.calc_num_meshes();
|
int16_t a = settings.calc_num_meshes();
|
||||||
|
|
||||||
if (!a) {
|
if (!a) {
|
||||||
SERIAL_PROTOCOLLNPGM("?EEPROM storage not available.");
|
SERIAL_ECHOLNPGM("?EEPROM storage not available.");
|
||||||
goto LEAVE;
|
goto LEAVE;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!WITHIN(g29_storage_slot, 0, a - 1)) {
|
if (!WITHIN(g29_storage_slot, 0, a - 1)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Invalid storage slot.");
|
SERIAL_ECHOLNPGM("?Invalid storage slot.");
|
||||||
SERIAL_PROTOCOLLNPAIR("?Use 0 to ", a - 1);
|
SERIAL_ECHOLNPAIR("?Use 0 to ", a - 1);
|
||||||
goto LEAVE;
|
goto LEAVE;
|
||||||
}
|
}
|
||||||
|
|
||||||
settings.store_mesh(g29_storage_slot);
|
settings.store_mesh(g29_storage_slot);
|
||||||
storage_slot = g29_storage_slot;
|
storage_slot = g29_storage_slot;
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("Done.");
|
SERIAL_ECHOLNPGM("Done.");
|
||||||
}
|
}
|
||||||
|
|
||||||
if (parser.seen('T'))
|
if (parser.seen('T'))
|
||||||
|
@ -675,14 +675,10 @@
|
||||||
sum_of_diff_squared += sq(z_values[x][y] - mean);
|
sum_of_diff_squared += sq(z_values[x][y] - mean);
|
||||||
|
|
||||||
SERIAL_ECHOLNPAIR("# of samples: ", n);
|
SERIAL_ECHOLNPAIR("# of samples: ", n);
|
||||||
SERIAL_ECHOPGM("Mean Mesh Height: ");
|
SERIAL_ECHOLNPAIR_F("Mean Mesh Height: ", mean, 6);
|
||||||
SERIAL_ECHO_F(mean, 6);
|
|
||||||
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_ECHOLNPAIR_F("Standard Deviation: ", sigma, 6);
|
||||||
SERIAL_ECHO_F(sigma, 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
|
|
||||||
if (cflag)
|
if (cflag)
|
||||||
for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++)
|
for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++)
|
||||||
|
@ -721,7 +717,7 @@
|
||||||
#if HAS_LCD_MENU
|
#if HAS_LCD_MENU
|
||||||
if (ui.button_pressed()) {
|
if (ui.button_pressed()) {
|
||||||
ui.quick_feedback(false); // Preserve button state for click-and-hold
|
ui.quick_feedback(false); // Preserve button state for click-and-hold
|
||||||
SERIAL_PROTOCOLLNPGM("\nMesh only partially populated.\n");
|
SERIAL_ECHOLNPGM("\nMesh only partially populated.\n");
|
||||||
STOW_PROBE();
|
STOW_PROBE();
|
||||||
ui.wait_for_release();
|
ui.wait_for_release();
|
||||||
ui.quick_feedback();
|
ui.quick_feedback();
|
||||||
|
@ -803,7 +799,7 @@
|
||||||
return current_position[Z_AXIS];
|
return current_position[Z_AXIS];
|
||||||
}
|
}
|
||||||
|
|
||||||
static void echo_and_take_a_measurement() { SERIAL_PROTOCOLLNPGM(" and take a measurement."); }
|
static void echo_and_take_a_measurement() { SERIAL_ECHOLNPGM(" and take a measurement."); }
|
||||||
|
|
||||||
float unified_bed_leveling::measure_business_card_thickness(float in_height) {
|
float unified_bed_leveling::measure_business_card_thickness(float in_height) {
|
||||||
ui.capture();
|
ui.capture();
|
||||||
|
@ -813,7 +809,7 @@
|
||||||
//, MIN(planner.settings.max_feedrate_mm_s[X_AXIS], planner.settings.max_feedrate_mm_s[Y_AXIS]) * 0.5f);
|
//, MIN(planner.settings.max_feedrate_mm_s[X_AXIS], planner.settings.max_feedrate_mm_s[Y_AXIS]) * 0.5f);
|
||||||
planner.synchronize();
|
planner.synchronize();
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM("Place shim under nozzle");
|
SERIAL_ECHOPGM("Place shim under nozzle");
|
||||||
LCD_MESSAGEPGM(MSG_UBL_BC_INSERT);
|
LCD_MESSAGEPGM(MSG_UBL_BC_INSERT);
|
||||||
ui.return_to_status();
|
ui.return_to_status();
|
||||||
echo_and_take_a_measurement();
|
echo_and_take_a_measurement();
|
||||||
|
@ -822,7 +818,7 @@
|
||||||
do_blocking_move_to_z(current_position[Z_AXIS] + SIZE_OF_LITTLE_RAISE);
|
do_blocking_move_to_z(current_position[Z_AXIS] + SIZE_OF_LITTLE_RAISE);
|
||||||
planner.synchronize();
|
planner.synchronize();
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM("Remove shim");
|
SERIAL_ECHOPGM("Remove shim");
|
||||||
LCD_MESSAGEPGM(MSG_UBL_BC_REMOVE);
|
LCD_MESSAGEPGM(MSG_UBL_BC_REMOVE);
|
||||||
echo_and_take_a_measurement();
|
echo_and_take_a_measurement();
|
||||||
|
|
||||||
|
@ -833,9 +829,8 @@
|
||||||
const float thickness = ABS(z1 - z2);
|
const float thickness = ABS(z1 - z2);
|
||||||
|
|
||||||
if (g29_verbose_level > 1) {
|
if (g29_verbose_level > 1) {
|
||||||
SERIAL_PROTOCOLPGM("Business Card is ");
|
SERIAL_ECHOPAIR_F("Business Card is ", thickness, 4);
|
||||||
SERIAL_PROTOCOL_F(thickness, 4);
|
SERIAL_ECHOLNPGM("mm thick.");
|
||||||
SERIAL_PROTOCOLLNPGM("mm thick.");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
ui.release();
|
ui.release();
|
||||||
|
@ -846,7 +841,7 @@
|
||||||
}
|
}
|
||||||
|
|
||||||
void abort_manual_probe_remaining_mesh() {
|
void abort_manual_probe_remaining_mesh() {
|
||||||
SERIAL_PROTOCOLLNPGM("\nMesh only partially populated.");
|
SERIAL_ECHOLNPGM("\nMesh only partially populated.");
|
||||||
do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE);
|
do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE);
|
||||||
ui.release();
|
ui.release();
|
||||||
KEEPALIVE_STATE(IN_HANDLER);
|
KEEPALIVE_STATE(IN_HANDLER);
|
||||||
|
@ -892,7 +887,7 @@
|
||||||
move_z_with_encoder(z_step);
|
move_z_with_encoder(z_step);
|
||||||
|
|
||||||
if (click_and_hold()) {
|
if (click_and_hold()) {
|
||||||
SERIAL_PROTOCOLLNPGM("\nMesh only partially populated.");
|
SERIAL_ECHOLNPGM("\nMesh only partially populated.");
|
||||||
do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE);
|
do_blocking_move_to_z(Z_CLEARANCE_DEPLOY_PROBE);
|
||||||
ui.release();
|
ui.release();
|
||||||
KEEPALIVE_STATE(IN_HANDLER);
|
KEEPALIVE_STATE(IN_HANDLER);
|
||||||
|
@ -901,11 +896,8 @@
|
||||||
}
|
}
|
||||||
|
|
||||||
z_values[location.x_index][location.y_index] = current_position[Z_AXIS] - thick;
|
z_values[location.x_index][location.y_index] = current_position[Z_AXIS] - thick;
|
||||||
if (g29_verbose_level > 2) {
|
if (g29_verbose_level > 2)
|
||||||
SERIAL_PROTOCOLPGM("Mesh Point Measured at: ");
|
SERIAL_ECHOLNPAIR_F("Mesh Point Measured at: ", z_values[location.x_index][location.y_index], 6);
|
||||||
SERIAL_PROTOCOL_F(z_values[location.x_index][location.y_index], 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
}
|
|
||||||
SERIAL_FLUSH(); // Prevent host M105 buffer overrun.
|
SERIAL_FLUSH(); // Prevent host M105 buffer overrun.
|
||||||
} while (location.x_index >= 0 && location.y_index >= 0);
|
} while (location.x_index >= 0 && location.y_index >= 0);
|
||||||
|
|
||||||
|
@ -934,7 +926,7 @@
|
||||||
#if ENABLED(UBL_MESH_EDIT_MOVES_Z)
|
#if ENABLED(UBL_MESH_EDIT_MOVES_Z)
|
||||||
const float h_offset = parser.seenval('H') ? parser.value_linear_units() : 0;
|
const float h_offset = parser.seenval('H') ? parser.value_linear_units() : 0;
|
||||||
if (!WITHIN(h_offset, 0, 10)) {
|
if (!WITHIN(h_offset, 0, 10)) {
|
||||||
SERIAL_PROTOCOLLNPGM("Offset out of bounds. (0 to 10mm)\n");
|
SERIAL_ECHOLNPGM("Offset out of bounds. (0 to 10mm)\n");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -942,7 +934,7 @@
|
||||||
mesh_index_pair location;
|
mesh_index_pair location;
|
||||||
|
|
||||||
if (!position_is_reachable(rx, ry)) {
|
if (!position_is_reachable(rx, ry)) {
|
||||||
SERIAL_PROTOCOLLNPGM("(X,Y) outside printable radius.");
|
SERIAL_ECHOLNPGM("(X,Y) outside printable radius.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1050,14 +1042,14 @@
|
||||||
g29_repetition_cnt = parser.has_value() ? parser.value_int() : GRID_MAX_POINTS;
|
g29_repetition_cnt = parser.has_value() ? parser.value_int() : GRID_MAX_POINTS;
|
||||||
NOMORE(g29_repetition_cnt, GRID_MAX_POINTS);
|
NOMORE(g29_repetition_cnt, GRID_MAX_POINTS);
|
||||||
if (g29_repetition_cnt < 1) {
|
if (g29_repetition_cnt < 1) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(R)epetition count invalid (1+).\n");
|
SERIAL_ECHOLNPGM("?(R)epetition count invalid (1+).\n");
|
||||||
return UBL_ERR;
|
return UBL_ERR;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
g29_verbose_level = parser.seen('V') ? parser.value_int() : 0;
|
g29_verbose_level = parser.seen('V') ? parser.value_int() : 0;
|
||||||
if (!WITHIN(g29_verbose_level, 0, 4)) {
|
if (!WITHIN(g29_verbose_level, 0, 4)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(V)erbose level is implausible (0-4).\n");
|
SERIAL_ECHOLNPGM("?(V)erbose level is implausible (0-4).\n");
|
||||||
err_flag = true;
|
err_flag = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1065,7 +1057,7 @@
|
||||||
const int pv = parser.value_int();
|
const int pv = parser.value_int();
|
||||||
#if !HAS_BED_PROBE
|
#if !HAS_BED_PROBE
|
||||||
if (pv == 1) {
|
if (pv == 1) {
|
||||||
SERIAL_PROTOCOLLNPGM("G29 P1 requires a probe.\n");
|
SERIAL_ECHOLNPGM("G29 P1 requires a probe.\n");
|
||||||
err_flag = true;
|
err_flag = true;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
|
@ -1073,7 +1065,7 @@
|
||||||
{
|
{
|
||||||
g29_phase_value = pv;
|
g29_phase_value = pv;
|
||||||
if (!WITHIN(g29_phase_value, 0, 6)) {
|
if (!WITHIN(g29_phase_value, 0, 6)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(P)hase value invalid (0-6).\n");
|
SERIAL_ECHOLNPGM("?(P)hase value invalid (0-6).\n");
|
||||||
err_flag = true;
|
err_flag = true;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -1083,17 +1075,17 @@
|
||||||
#if HAS_BED_PROBE
|
#if HAS_BED_PROBE
|
||||||
g29_grid_size = parser.has_value() ? parser.value_int() : 0;
|
g29_grid_size = parser.has_value() ? parser.value_int() : 0;
|
||||||
if (g29_grid_size && !WITHIN(g29_grid_size, 2, 9)) {
|
if (g29_grid_size && !WITHIN(g29_grid_size, 2, 9)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Invalid grid size (J) specified (2-9).\n");
|
SERIAL_ECHOLNPGM("?Invalid grid size (J) specified (2-9).\n");
|
||||||
err_flag = true;
|
err_flag = true;
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOLLNPGM("G29 J action requires a probe.\n");
|
SERIAL_ECHOLNPGM("G29 J action requires a probe.\n");
|
||||||
err_flag = true;
|
err_flag = true;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
||||||
if (g29_x_flag != g29_y_flag) {
|
if (g29_x_flag != g29_y_flag) {
|
||||||
SERIAL_PROTOCOLLNPGM("Both X & Y locations must be specified.\n");
|
SERIAL_ECHOLNPGM("Both X & Y locations must be specified.\n");
|
||||||
err_flag = true;
|
err_flag = true;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1111,7 +1103,7 @@
|
||||||
*/
|
*/
|
||||||
if (parser.seen('A')) {
|
if (parser.seen('A')) {
|
||||||
if (parser.seen('D')) {
|
if (parser.seen('D')) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Can't activate and deactivate at the same time.\n");
|
SERIAL_ECHOLNPGM("?Can't activate and deactivate at the same time.\n");
|
||||||
return UBL_ERR;
|
return UBL_ERR;
|
||||||
}
|
}
|
||||||
set_bed_leveling_enabled(true);
|
set_bed_leveling_enabled(true);
|
||||||
|
@ -1130,7 +1122,7 @@
|
||||||
if (parser.seenval('F')) {
|
if (parser.seenval('F')) {
|
||||||
const float fh = parser.value_float();
|
const float fh = parser.value_float();
|
||||||
if (!WITHIN(fh, 0, 100)) {
|
if (!WITHIN(fh, 0, 100)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(F)ade height for Bed Level Correction not plausible.\n");
|
SERIAL_ECHOLNPGM("?(F)ade height for Bed Level Correction not plausible.\n");
|
||||||
return UBL_ERR;
|
return UBL_ERR;
|
||||||
}
|
}
|
||||||
set_z_fade_height(fh);
|
set_z_fade_height(fh);
|
||||||
|
@ -1139,7 +1131,7 @@
|
||||||
|
|
||||||
g29_map_type = parser.intval('T');
|
g29_map_type = parser.intval('T');
|
||||||
if (!WITHIN(g29_map_type, 0, 2)) {
|
if (!WITHIN(g29_map_type, 0, 2)) {
|
||||||
SERIAL_PROTOCOLLNPGM("Invalid map type.\n");
|
SERIAL_ECHOLNPGM("Invalid map type.\n");
|
||||||
return UBL_ERR;
|
return UBL_ERR;
|
||||||
}
|
}
|
||||||
return UBL_OK;
|
return UBL_OK;
|
||||||
|
@ -1435,29 +1427,23 @@
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
if (DEBUGGING(LEVELING)) {
|
if (DEBUGGING(LEVELING)) {
|
||||||
SERIAL_CHAR('(');
|
SERIAL_CHAR('(');
|
||||||
SERIAL_PROTOCOL_F(rx, 7);
|
SERIAL_ECHO_F(rx, 7);
|
||||||
SERIAL_CHAR(',');
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOL_F(ry, 7);
|
SERIAL_ECHO_F(ry, 7);
|
||||||
SERIAL_ECHOPGM(") logical: ");
|
SERIAL_ECHOPGM(") logical: ");
|
||||||
SERIAL_CHAR('(');
|
SERIAL_CHAR('(');
|
||||||
SERIAL_PROTOCOL_F(LOGICAL_X_POSITION(rx), 7);
|
SERIAL_ECHO_F(LOGICAL_X_POSITION(rx), 7);
|
||||||
SERIAL_CHAR(',');
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOL_F(LOGICAL_Y_POSITION(ry), 7);
|
SERIAL_ECHO_F(LOGICAL_Y_POSITION(ry), 7);
|
||||||
SERIAL_ECHOPGM(") measured: ");
|
SERIAL_ECHOPAIR_F(") measured: ", measured_z, 7);
|
||||||
SERIAL_PROTOCOL_F(measured_z, 7);
|
SERIAL_ECHOPAIR_F(" correction: ", get_z_correction(rx, ry), 7);
|
||||||
SERIAL_ECHOPGM(" correction: ");
|
|
||||||
SERIAL_PROTOCOL_F(get_z_correction(rx, ry), 7);
|
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
measured_z -= get_z_correction(rx, ry) /* + zprobe_zoffset */ ;
|
measured_z -= get_z_correction(rx, ry) /* + zprobe_zoffset */ ;
|
||||||
|
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
if (DEBUGGING(LEVELING)) {
|
if (DEBUGGING(LEVELING)) SERIAL_ECHOLNPAIR_F(" final >>>---> ", measured_z, 7);
|
||||||
SERIAL_ECHOPGM(" final >>>---> ");
|
|
||||||
SERIAL_PROTOCOL_F(measured_z, 7);
|
|
||||||
SERIAL_EOL();
|
|
||||||
}
|
|
||||||
#endif
|
#endif
|
||||||
if (g29_verbose_level > 3) {
|
if (g29_verbose_level > 3) {
|
||||||
serial_spaces(16);
|
serial_spaces(16);
|
||||||
|
@ -1483,12 +1469,11 @@
|
||||||
vector_3 normal = vector_3(lsf_results.A, lsf_results.B, 1).get_normal();
|
vector_3 normal = vector_3(lsf_results.A, lsf_results.B, 1).get_normal();
|
||||||
|
|
||||||
if (g29_verbose_level > 2) {
|
if (g29_verbose_level > 2) {
|
||||||
SERIAL_ECHOPGM("bed plane normal = [");
|
SERIAL_ECHOPAIR_F("bed plane normal = [", normal.x, 7);
|
||||||
SERIAL_PROTOCOL_F(normal.x, 7);
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOLCHAR(',');
|
SERIAL_ECHO_F(normal.y, 7);
|
||||||
SERIAL_PROTOCOL_F(normal.y, 7);
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOLCHAR(',');
|
SERIAL_ECHO_F(normal.z, 7);
|
||||||
SERIAL_PROTOCOL_F(normal.z, 7);
|
|
||||||
SERIAL_ECHOLNPGM("]");
|
SERIAL_ECHOLNPGM("]");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1502,12 +1487,11 @@
|
||||||
|
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
if (DEBUGGING(LEVELING)) {
|
if (DEBUGGING(LEVELING)) {
|
||||||
SERIAL_ECHOPGM("before rotation = [");
|
SERIAL_ECHOPAIR_F("before rotation = [", x_tmp, 7);
|
||||||
SERIAL_PROTOCOL_F(x_tmp, 7);
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOLCHAR(',');
|
SERIAL_ECHO_F(y_tmp, 7);
|
||||||
SERIAL_PROTOCOL_F(y_tmp, 7);
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOLCHAR(',');
|
SERIAL_ECHO_F(z_tmp, 7);
|
||||||
SERIAL_PROTOCOL_F(z_tmp, 7);
|
|
||||||
SERIAL_ECHOPGM("] ---> ");
|
SERIAL_ECHOPGM("] ---> ");
|
||||||
serial_delay(20);
|
serial_delay(20);
|
||||||
}
|
}
|
||||||
|
@ -1517,12 +1501,11 @@
|
||||||
|
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
if (DEBUGGING(LEVELING)) {
|
if (DEBUGGING(LEVELING)) {
|
||||||
SERIAL_ECHOPGM("after rotation = [");
|
SERIAL_ECHOPAIR_F("after rotation = [", x_tmp, 7);
|
||||||
SERIAL_PROTOCOL_F(x_tmp, 7);
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOLCHAR(',');
|
SERIAL_ECHO_F(y_tmp, 7);
|
||||||
SERIAL_PROTOCOL_F(y_tmp, 7);
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOLCHAR(',');
|
SERIAL_ECHO_F(z_tmp, 7);
|
||||||
SERIAL_PROTOCOL_F(z_tmp, 7);
|
|
||||||
SERIAL_ECHOLNPGM("]");
|
SERIAL_ECHOLNPGM("]");
|
||||||
serial_delay(55);
|
serial_delay(55);
|
||||||
}
|
}
|
||||||
|
@ -1535,22 +1518,17 @@
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
if (DEBUGGING(LEVELING)) {
|
if (DEBUGGING(LEVELING)) {
|
||||||
rotation.debug(PSTR("rotation matrix:\n"));
|
rotation.debug(PSTR("rotation matrix:\n"));
|
||||||
SERIAL_ECHOPGM("LSF Results A=");
|
SERIAL_ECHOPAIR_F("LSF Results A=", lsf_results.A, 7);
|
||||||
SERIAL_PROTOCOL_F(lsf_results.A, 7);
|
SERIAL_ECHOPAIR_F(" B=", lsf_results.B, 7);
|
||||||
SERIAL_ECHOPGM(" B=");
|
SERIAL_ECHOLNPAIR_F(" D=", lsf_results.D, 7);
|
||||||
SERIAL_PROTOCOL_F(lsf_results.B, 7);
|
|
||||||
SERIAL_ECHOPGM(" D=");
|
|
||||||
SERIAL_PROTOCOL_F(lsf_results.D, 7);
|
|
||||||
SERIAL_EOL();
|
|
||||||
serial_delay(55);
|
serial_delay(55);
|
||||||
|
|
||||||
SERIAL_ECHOPGM("bed plane normal = [");
|
SERIAL_ECHOPAIR_F("bed plane normal = [", normal.x, 7);
|
||||||
SERIAL_PROTOCOL_F(normal.x, 7);
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOLCHAR(',');
|
SERIAL_ECHO_F(normal.y, 7);
|
||||||
SERIAL_PROTOCOL_F(normal.y, 7);
|
SERIAL_CHAR(',');
|
||||||
SERIAL_PROTOCOLCHAR(',');
|
SERIAL_ECHO_F(normal.z, 7);
|
||||||
SERIAL_PROTOCOL_F(normal.z, 7);
|
SERIAL_ECHOLNPGM("]");
|
||||||
SERIAL_ECHOPGM("]\n");
|
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -1565,45 +1543,31 @@
|
||||||
float t, t1, d;
|
float t, t1, d;
|
||||||
t = normal.x * (PROBE_PT_1_X) + normal.y * (PROBE_PT_1_Y);
|
t = normal.x * (PROBE_PT_1_X) + normal.y * (PROBE_PT_1_Y);
|
||||||
d = t + normal.z * z1;
|
d = t + normal.z * z1;
|
||||||
SERIAL_ECHOPGM("D from 1st point: ");
|
SERIAL_ECHOPAIR_F("D from 1st point: ", d, 6);
|
||||||
SERIAL_ECHO_F(d, 6);
|
SERIAL_ECHOLNPAIR_F(" Z error: ", normal.z*z1-get_z_correction(PROBE_PT_1_X, PROBE_PT_1_Y), 6);
|
||||||
SERIAL_ECHOPGM(" Z error: ");
|
|
||||||
SERIAL_ECHO_F(normal.z*z1-get_z_correction(PROBE_PT_1_X, PROBE_PT_1_Y), 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
|
|
||||||
t = normal.x * (PROBE_PT_2_X) + normal.y * (PROBE_PT_2_Y);
|
t = normal.x * (PROBE_PT_2_X) + normal.y * (PROBE_PT_2_Y);
|
||||||
d = t + normal.z * z2;
|
d = t + normal.z * z2;
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
SERIAL_ECHOPGM("D from 2nd point: ");
|
SERIAL_ECHOPAIR_F("D from 2nd point: ", d, 6);
|
||||||
SERIAL_ECHO_F(d, 6);
|
SERIAL_ECHOLNPAIR_F(" Z error: ", normal.z*z2-get_z_correction(PROBE_PT_2_X, PROBE_PT_2_Y), 6);
|
||||||
SERIAL_ECHOPGM(" Z error: ");
|
|
||||||
SERIAL_ECHO_F(normal.z*z2-get_z_correction(PROBE_PT_2_X, PROBE_PT_2_Y), 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
|
|
||||||
t = normal.x * (PROBE_PT_3_X) + normal.y * (PROBE_PT_3_Y);
|
t = normal.x * (PROBE_PT_3_X) + normal.y * (PROBE_PT_3_Y);
|
||||||
d = t + normal.z * z3;
|
d = t + normal.z * z3;
|
||||||
SERIAL_ECHOPGM("D from 3rd point: ");
|
SERIAL_ECHOPAIR_F("D from 3rd point: ", d, 6);
|
||||||
SERIAL_ECHO_F(d, 6);
|
SERIAL_ECHOLNPAIR_F(" Z error: ", normal.z*z3-get_z_correction(PROBE_PT_3_X, PROBE_PT_3_Y), 6);
|
||||||
SERIAL_ECHOPGM(" Z error: ");
|
|
||||||
SERIAL_ECHO_F(normal.z*z3-get_z_correction(PROBE_PT_3_X, PROBE_PT_3_Y), 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
|
|
||||||
t = normal.x * (Z_SAFE_HOMING_X_POINT) + normal.y * (Z_SAFE_HOMING_Y_POINT);
|
t = normal.x * (Z_SAFE_HOMING_X_POINT) + normal.y * (Z_SAFE_HOMING_Y_POINT);
|
||||||
d = t + normal.z * 0;
|
d = t + normal.z * 0;
|
||||||
SERIAL_ECHOPGM("D from home location with Z=0 : ");
|
SERIAL_ECHOLNPAIR_F("D from home location with Z=0 : ", d, 6);
|
||||||
SERIAL_ECHO_F(d, 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
|
|
||||||
t = normal.x * (Z_SAFE_HOMING_X_POINT) + normal.y * (Z_SAFE_HOMING_Y_POINT);
|
t = normal.x * (Z_SAFE_HOMING_X_POINT) + normal.y * (Z_SAFE_HOMING_Y_POINT);
|
||||||
d = t + get_z_correction(Z_SAFE_HOMING_X_POINT, Z_SAFE_HOMING_Y_POINT); // normal.z * 0;
|
d = t + get_z_correction(Z_SAFE_HOMING_X_POINT, Z_SAFE_HOMING_Y_POINT); // normal.z * 0;
|
||||||
SERIAL_ECHOPGM("D from home location using mesh value for Z: ");
|
SERIAL_ECHOPAIR_F("D from home location using mesh value for Z: ", d, 6);
|
||||||
SERIAL_ECHO_F(d, 6);
|
|
||||||
|
|
||||||
SERIAL_ECHOPAIR(" Z error: (", Z_SAFE_HOMING_X_POINT);
|
SERIAL_ECHOPAIR(" Z error: (", Z_SAFE_HOMING_X_POINT);
|
||||||
SERIAL_ECHOPAIR(",", Z_SAFE_HOMING_Y_POINT );
|
SERIAL_ECHOPAIR(",", Z_SAFE_HOMING_Y_POINT);
|
||||||
SERIAL_ECHOPGM(") = ");
|
SERIAL_ECHOLNPAIR_F(") = ", get_z_correction(Z_SAFE_HOMING_X_POINT, Z_SAFE_HOMING_Y_POINT), 6);
|
||||||
SERIAL_ECHO_F(get_z_correction(Z_SAFE_HOMING_X_POINT, Z_SAFE_HOMING_Y_POINT), 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
#endif
|
#endif
|
||||||
} // DEBUGGING(LEVELING)
|
} // DEBUGGING(LEVELING)
|
||||||
#endif
|
#endif
|
||||||
|
@ -1675,26 +1639,22 @@
|
||||||
report_state();
|
report_state();
|
||||||
|
|
||||||
if (storage_slot == -1)
|
if (storage_slot == -1)
|
||||||
SERIAL_PROTOCOLPGM("No Mesh Loaded.");
|
SERIAL_ECHOPGM("No Mesh Loaded.");
|
||||||
else {
|
else {
|
||||||
SERIAL_PROTOCOLPAIR("Mesh ", storage_slot);
|
SERIAL_ECHOPAIR("Mesh ", storage_slot);
|
||||||
SERIAL_PROTOCOLPGM(" Loaded.");
|
SERIAL_ECHOPGM(" Loaded.");
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
serial_delay(50);
|
serial_delay(50);
|
||||||
|
|
||||||
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
||||||
SERIAL_PROTOCOLPGM("planner.z_fade_height : ");
|
SERIAL_ECHOLNPAIR_F("planner.z_fade_height : ", planner.z_fade_height, 4);
|
||||||
SERIAL_PROTOCOL_F(planner.z_fade_height, 4);
|
|
||||||
SERIAL_EOL();
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
adjust_mesh_to_mean(g29_c_flag, g29_constant);
|
adjust_mesh_to_mean(g29_c_flag, g29_constant);
|
||||||
|
|
||||||
#if HAS_BED_PROBE
|
#if HAS_BED_PROBE
|
||||||
SERIAL_PROTOCOLPGM("zprobe_zoffset: ");
|
SERIAL_ECHOLNPAIR_F("zprobe_zoffset: ", zprobe_zoffset, 7);
|
||||||
SERIAL_PROTOCOL_F(zprobe_zoffset, 7);
|
|
||||||
SERIAL_EOL();
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SERIAL_ECHOLNPAIR("MESH_MIN_X " STRINGIFY(MESH_MIN_X) "=", MESH_MIN_X); serial_delay(50);
|
SERIAL_ECHOLNPAIR("MESH_MIN_X " STRINGIFY(MESH_MIN_X) "=", MESH_MIN_X); serial_delay(50);
|
||||||
|
@ -1706,53 +1666,53 @@
|
||||||
SERIAL_ECHOLNPAIR("MESH_X_DIST ", MESH_X_DIST);
|
SERIAL_ECHOLNPAIR("MESH_X_DIST ", MESH_X_DIST);
|
||||||
SERIAL_ECHOLNPAIR("MESH_Y_DIST ", MESH_Y_DIST); serial_delay(50);
|
SERIAL_ECHOLNPAIR("MESH_Y_DIST ", MESH_Y_DIST); serial_delay(50);
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM("X-Axis Mesh Points at: ");
|
SERIAL_ECHOPGM("X-Axis Mesh Points at: ");
|
||||||
for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
|
for (uint8_t i = 0; i < GRID_MAX_POINTS_X; i++) {
|
||||||
SERIAL_PROTOCOL_F(LOGICAL_X_POSITION(mesh_index_to_xpos(i)), 3);
|
SERIAL_ECHO_F(LOGICAL_X_POSITION(mesh_index_to_xpos(i)), 3);
|
||||||
SERIAL_PROTOCOLPGM(" ");
|
SERIAL_ECHOPGM(" ");
|
||||||
serial_delay(25);
|
serial_delay(25);
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM("Y-Axis Mesh Points at: ");
|
SERIAL_ECHOPGM("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++) {
|
||||||
SERIAL_PROTOCOL_F(LOGICAL_Y_POSITION(mesh_index_to_ypos(i)), 3);
|
SERIAL_ECHO_F(LOGICAL_Y_POSITION(mesh_index_to_ypos(i)), 3);
|
||||||
SERIAL_PROTOCOLPGM(" ");
|
SERIAL_ECHOPGM(" ");
|
||||||
serial_delay(25);
|
serial_delay(25);
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
|
|
||||||
#if HAS_KILL
|
#if HAS_KILL
|
||||||
SERIAL_PROTOCOLPAIR("Kill pin on :", KILL_PIN);
|
SERIAL_ECHOPAIR("Kill pin on :", KILL_PIN);
|
||||||
SERIAL_PROTOCOLLNPAIR(" state:", READ(KILL_PIN));
|
SERIAL_ECHOLNPAIR(" state:", READ(KILL_PIN));
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
serial_delay(50);
|
serial_delay(50);
|
||||||
|
|
||||||
#if ENABLED(UBL_DEVEL_DEBUGGING)
|
#if ENABLED(UBL_DEVEL_DEBUGGING)
|
||||||
SERIAL_PROTOCOLLNPAIR("ubl_state_at_invocation :", ubl_state_at_invocation); SERIAL_EOL();
|
SERIAL_ECHOLNPAIR("ubl_state_at_invocation :", ubl_state_at_invocation); SERIAL_EOL();
|
||||||
SERIAL_PROTOCOLLNPAIR("ubl_state_recursion_chk :", ubl_state_recursion_chk); SERIAL_EOL();
|
SERIAL_ECHOLNPAIR("ubl_state_recursion_chk :", ubl_state_recursion_chk); SERIAL_EOL();
|
||||||
serial_delay(50);
|
serial_delay(50);
|
||||||
|
|
||||||
SERIAL_PROTOCOLPAIR("Meshes go from ", hex_address((void*)settings.meshes_start_index()));
|
SERIAL_ECHOPAIR("Meshes go from ", hex_address((void*)settings.meshes_start_index()));
|
||||||
SERIAL_PROTOCOLLNPAIR(" to ", hex_address((void*)settings.meshes_end_index()));
|
SERIAL_ECHOLNPAIR(" to ", hex_address((void*)settings.meshes_end_index()));
|
||||||
serial_delay(50);
|
serial_delay(50);
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPAIR("sizeof(ubl) : ", (int)sizeof(ubl)); SERIAL_EOL();
|
SERIAL_ECHOLNPAIR("sizeof(ubl) : ", (int)sizeof(ubl)); SERIAL_EOL();
|
||||||
SERIAL_PROTOCOLLNPAIR("z_value[][] size: ", (int)sizeof(z_values)); SERIAL_EOL();
|
SERIAL_ECHOLNPAIR("z_value[][] size: ", (int)sizeof(z_values)); SERIAL_EOL();
|
||||||
serial_delay(25);
|
serial_delay(25);
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPAIR("EEPROM free for UBL: ", hex_address((void*)(settings.meshes_end_index() - settings.meshes_start_index())));
|
SERIAL_ECHOLNPAIR("EEPROM free for UBL: ", hex_address((void*)(settings.meshes_end_index() - settings.meshes_start_index())));
|
||||||
serial_delay(50);
|
serial_delay(50);
|
||||||
|
|
||||||
SERIAL_PROTOCOLPAIR("EEPROM can hold ", settings.calc_num_meshes());
|
SERIAL_ECHOPAIR("EEPROM can hold ", settings.calc_num_meshes());
|
||||||
SERIAL_PROTOCOLLNPGM(" meshes.\n");
|
SERIAL_ECHOLNPGM(" meshes.\n");
|
||||||
serial_delay(25);
|
serial_delay(25);
|
||||||
#endif // UBL_DEVEL_DEBUGGING
|
#endif // UBL_DEVEL_DEBUGGING
|
||||||
|
|
||||||
if (!sanity_check()) {
|
if (!sanity_check()) {
|
||||||
echo_name();
|
echo_name();
|
||||||
SERIAL_PROTOCOLLNPGM(" sanity checks passed.");
|
SERIAL_ECHOLNPGM(" sanity checks passed.");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1763,8 +1723,7 @@
|
||||||
void unified_bed_leveling::g29_eeprom_dump() {
|
void unified_bed_leveling::g29_eeprom_dump() {
|
||||||
uint8_t cccc;
|
uint8_t cccc;
|
||||||
|
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG("EEPROM Dump:");
|
||||||
SERIAL_ECHOLNPGM("EEPROM Dump:");
|
|
||||||
persistentStore.access_start();
|
persistentStore.access_start();
|
||||||
for (uint16_t i = 0; i < persistentStore.capacity(); i += 16) {
|
for (uint16_t i = 0; i < persistentStore.capacity(); i += 16) {
|
||||||
if (!(i & 0x3)) idle();
|
if (!(i & 0x3)) idle();
|
||||||
|
@ -1773,7 +1732,7 @@
|
||||||
for (uint16_t j = 0; j < 16; j++) {
|
for (uint16_t j = 0; j < 16; j++) {
|
||||||
persistentStore.read_data(i + j, &cccc, sizeof(uint8_t));
|
persistentStore.read_data(i + j, &cccc, sizeof(uint8_t));
|
||||||
print_hex_byte(cccc);
|
print_hex_byte(cccc);
|
||||||
SERIAL_ECHO(' ');
|
SERIAL_CHAR(' ');
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
@ -1789,29 +1748,29 @@
|
||||||
int16_t a = settings.calc_num_meshes();
|
int16_t a = settings.calc_num_meshes();
|
||||||
|
|
||||||
if (!a) {
|
if (!a) {
|
||||||
SERIAL_PROTOCOLLNPGM("?EEPROM storage not available.");
|
SERIAL_ECHOLNPGM("?EEPROM storage not available.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!parser.has_value()) {
|
if (!parser.has_value()) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Storage slot # required.");
|
SERIAL_ECHOLNPGM("?Storage slot # required.");
|
||||||
SERIAL_PROTOCOLLNPAIR("?Use 0 to ", a - 1);
|
SERIAL_ECHOLNPAIR("?Use 0 to ", a - 1);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
g29_storage_slot = parser.value_int();
|
g29_storage_slot = parser.value_int();
|
||||||
|
|
||||||
if (!WITHIN(g29_storage_slot, 0, a - 1)) {
|
if (!WITHIN(g29_storage_slot, 0, a - 1)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Invalid storage slot.");
|
SERIAL_ECHOLNPGM("?Invalid storage slot.");
|
||||||
SERIAL_PROTOCOLLNPAIR("?Use 0 to ", a - 1);
|
SERIAL_ECHOLNPAIR("?Use 0 to ", a - 1);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
float tmp_z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
|
float tmp_z_values[GRID_MAX_POINTS_X][GRID_MAX_POINTS_Y];
|
||||||
settings.load_mesh(g29_storage_slot, &tmp_z_values);
|
settings.load_mesh(g29_storage_slot, &tmp_z_values);
|
||||||
|
|
||||||
SERIAL_PROTOCOLPAIR("Subtracting mesh in slot ", g29_storage_slot);
|
SERIAL_ECHOPAIR("Subtracting mesh in slot ", g29_storage_slot);
|
||||||
SERIAL_PROTOCOLLNPGM(" from current mesh.");
|
SERIAL_ECHOLNPGM(" from current mesh.");
|
||||||
|
|
||||||
for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++)
|
for (uint8_t x = 0; x < GRID_MAX_POINTS_X; x++)
|
||||||
for (uint8_t y = 0; y < GRID_MAX_POINTS_Y; y++)
|
for (uint8_t y = 0; y < GRID_MAX_POINTS_Y; y++)
|
||||||
|
|
|
@ -103,8 +103,7 @@ void dac_current_set_percents(const uint8_t pct[XYZE]) {
|
||||||
void dac_print_values() {
|
void dac_print_values() {
|
||||||
if (!dac_present) return;
|
if (!dac_present) return;
|
||||||
|
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG("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));
|
||||||
|
|
|
@ -93,8 +93,7 @@ static bool ensure_safe_temperature(const AdvancedPauseMode mode=ADVANCED_PAUSE_
|
||||||
|
|
||||||
#if ENABLED(PREVENT_COLD_EXTRUSION)
|
#if ENABLED(PREVENT_COLD_EXTRUSION)
|
||||||
if (!DEBUGGING(DRYRUN) && thermalManager.targetTooColdToExtrude(active_extruder)) {
|
if (!DEBUGGING(DRYRUN) && thermalManager.targetTooColdToExtrude(active_extruder)) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_HOTEND_TOO_COLD);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_HOTEND_TOO_COLD);
|
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -142,8 +141,7 @@ bool load_filament(const float &slow_load_length/*=0*/, const float &fast_load_l
|
||||||
#if HAS_LCD_MENU
|
#if HAS_LCD_MENU
|
||||||
if (show_lcd) lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_INSERT, mode);
|
if (show_lcd) lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_INSERT, mode);
|
||||||
#endif
|
#endif
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(MSG_FILAMENT_CHANGE_INSERT);
|
||||||
SERIAL_ECHOLNPGM(MSG_FILAMENT_CHANGE_INSERT);
|
|
||||||
|
|
||||||
#if HAS_BUZZER
|
#if HAS_BUZZER
|
||||||
filament_change_beep(max_beep_count, true);
|
filament_change_beep(max_beep_count, true);
|
||||||
|
@ -336,8 +334,7 @@ bool pause_print(const float &retract, const point_t &park_point, const float &u
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
if (!DEBUGGING(DRYRUN) && unload_length && thermalManager.targetTooColdToExtrude(active_extruder)) {
|
if (!DEBUGGING(DRYRUN) && unload_length && thermalManager.targetTooColdToExtrude(active_extruder)) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_HOTEND_TOO_COLD);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_HOTEND_TOO_COLD);
|
|
||||||
|
|
||||||
#if HAS_LCD_MENU
|
#if HAS_LCD_MENU
|
||||||
if (show_lcd) { // Show status screen
|
if (show_lcd) { // Show status screen
|
||||||
|
@ -464,8 +461,7 @@ void wait_for_confirmation(const bool is_reload/*=false*/, const int8_t max_beep
|
||||||
#if HAS_LCD_MENU
|
#if HAS_LCD_MENU
|
||||||
lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_HEAT);
|
lcd_advanced_pause_show_message(ADVANCED_PAUSE_MESSAGE_HEAT);
|
||||||
#endif
|
#endif
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(_PMSG(MSG_FILAMENT_CHANGE_HEAT));
|
||||||
SERIAL_ECHOLNPGM(_PMSG(MSG_FILAMENT_CHANGE_HEAT));
|
|
||||||
|
|
||||||
// Wait for LCD click or M108
|
// Wait for LCD click or M108
|
||||||
while (wait_for_user) idle(true);
|
while (wait_for_user) idle(true);
|
||||||
|
|
|
@ -192,7 +192,7 @@ class FilamentSensorBase {
|
||||||
|
|
||||||
#ifdef FILAMENT_RUNOUT_SENSOR_DEBUG
|
#ifdef FILAMENT_RUNOUT_SENSOR_DEBUG
|
||||||
if (change) {
|
if (change) {
|
||||||
SERIAL_PROTOCOLPGM("Motion detected:");
|
SERIAL_ECHOPGM("Motion detected:");
|
||||||
for (uint8_t e = 0; e < NUM_RUNOUT_SENSORS; e++)
|
for (uint8_t e = 0; e < NUM_RUNOUT_SENSORS; e++)
|
||||||
if (TEST(change, e)) { SERIAL_CHAR(' '); SERIAL_CHAR('0' + e); }
|
if (TEST(change, e)) { SERIAL_CHAR(' '); SERIAL_CHAR('0' + e); }
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
|
@ -253,7 +253,7 @@ class FilamentSensorBase {
|
||||||
static bool was_out = false;
|
static bool was_out = false;
|
||||||
if (out != was_out) {
|
if (out != was_out) {
|
||||||
was_out = out;
|
was_out = out;
|
||||||
SERIAL_PROTOCOL("Filament ");
|
SERIAL_ECHOPGM("Filament ");
|
||||||
serialprintPGM(out ? PSTR("OUT\n") : PSTR("IN\n"));
|
serialprintPGM(out ? PSTR("OUT\n") : PSTR("IN\n"));
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -289,7 +289,7 @@ class FilamentSensorBase {
|
||||||
t = millis() + 1000UL;
|
t = millis() + 1000UL;
|
||||||
LOOP_L_N(i, EXTRUDERS) {
|
LOOP_L_N(i, EXTRUDERS) {
|
||||||
serialprintPGM(i ? PSTR(", ") : PSTR("Remaining mm: "));
|
serialprintPGM(i ? PSTR(", ") : PSTR("Remaining mm: "));
|
||||||
SERIAL_PROTOCOL(runout_mm_countdown[i]);
|
SERIAL_ECHO(runout_mm_countdown[i]);
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
|
|
@ -59,8 +59,7 @@ void enable_solenoid(const uint8_t num) {
|
||||||
break;
|
break;
|
||||||
#endif
|
#endif
|
||||||
default:
|
default:
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(MSG_INVALID_SOLENOID);
|
||||||
SERIAL_ECHOLNPGM(MSG_INVALID_SOLENOID);
|
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -358,12 +358,12 @@
|
||||||
|
|
||||||
template <typename TMC>
|
template <typename TMC>
|
||||||
static void tmc_status(TMC &st, const TMC_debug_enum i, const float spmm) {
|
static void tmc_status(TMC &st, const TMC_debug_enum i, const float spmm) {
|
||||||
SERIAL_ECHO('\t');
|
SERIAL_CHAR('\t');
|
||||||
switch (i) {
|
switch (i) {
|
||||||
case TMC_CODES: st.printLabel(); break;
|
case TMC_CODES: st.printLabel(); break;
|
||||||
case TMC_ENABLED: serialprintPGM(st.isEnabled() ? PSTR("true") : PSTR("false")); break;
|
case TMC_ENABLED: serialprintPGM(st.isEnabled() ? PSTR("true") : PSTR("false")); break;
|
||||||
case TMC_CURRENT: SERIAL_ECHO(st.getMilliamps()); break;
|
case TMC_CURRENT: SERIAL_ECHO(st.getMilliamps()); break;
|
||||||
case TMC_RMS_CURRENT: SERIAL_PROTOCOL(st.rms_current()); break;
|
case TMC_RMS_CURRENT: SERIAL_ECHO(st.rms_current()); break;
|
||||||
case TMC_MAX_CURRENT: SERIAL_PRINT((float)st.rms_current() * 1.41, 0); break;
|
case TMC_MAX_CURRENT: SERIAL_PRINT((float)st.rms_current() * 1.41, 0); break;
|
||||||
case TMC_IRUN:
|
case TMC_IRUN:
|
||||||
SERIAL_PRINT(st.irun(), DEC);
|
SERIAL_PRINT(st.irun(), DEC);
|
||||||
|
@ -408,12 +408,12 @@
|
||||||
#if HAS_DRIVER(TMC2660)
|
#if HAS_DRIVER(TMC2660)
|
||||||
template<char AXIS_LETTER, char DRIVER_ID>
|
template<char AXIS_LETTER, char DRIVER_ID>
|
||||||
void tmc_status(TMCMarlin<TMC2660Stepper, AXIS_LETTER, DRIVER_ID> &st, const TMC_debug_enum i, const float) {
|
void tmc_status(TMCMarlin<TMC2660Stepper, AXIS_LETTER, DRIVER_ID> &st, const TMC_debug_enum i, const float) {
|
||||||
SERIAL_ECHO('\t');
|
SERIAL_CHAR('\t');
|
||||||
switch (i) {
|
switch (i) {
|
||||||
case TMC_CODES: st.printLabel(); break;
|
case TMC_CODES: st.printLabel(); break;
|
||||||
case TMC_ENABLED: serialprintPGM(st.isEnabled() ? PSTR("true") : PSTR("false")); break;
|
case TMC_ENABLED: serialprintPGM(st.isEnabled() ? PSTR("true") : PSTR("false")); break;
|
||||||
case TMC_CURRENT: SERIAL_ECHO(st.getMilliamps()); break;
|
case TMC_CURRENT: SERIAL_ECHO(st.getMilliamps()); break;
|
||||||
case TMC_RMS_CURRENT: SERIAL_PROTOCOL(st.rms_current()); break;
|
case TMC_RMS_CURRENT: SERIAL_ECHO(st.rms_current()); break;
|
||||||
case TMC_MAX_CURRENT: SERIAL_PRINT((float)st.rms_current() * 1.41, 0); break;
|
case TMC_MAX_CURRENT: SERIAL_PRINT((float)st.rms_current() * 1.41, 0); break;
|
||||||
case TMC_IRUN:
|
case TMC_IRUN:
|
||||||
SERIAL_PRINT(st.cs(), DEC);
|
SERIAL_PRINT(st.cs(), DEC);
|
||||||
|
|
|
@ -44,8 +44,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_MSG("Bad I2C address (8-127)");
|
||||||
SERIAL_ECHOLNPGM("Bad I2C address (8-127)");
|
|
||||||
}
|
}
|
||||||
|
|
||||||
this->addr = adr;
|
this->addr = adr;
|
||||||
|
|
|
@ -573,7 +573,7 @@ void GcodeSuite::G26() {
|
||||||
if (parser.seenval('B')) {
|
if (parser.seenval('B')) {
|
||||||
g26_bed_temp = parser.value_celsius();
|
g26_bed_temp = parser.value_celsius();
|
||||||
if (g26_bed_temp && !WITHIN(g26_bed_temp, 40, 140)) {
|
if (g26_bed_temp && !WITHIN(g26_bed_temp, 40, 140)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Specified bed temperature not plausible (40-140C).");
|
SERIAL_ECHOLNPGM("?Specified bed temperature not plausible (40-140C).");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -581,7 +581,7 @@ void GcodeSuite::G26() {
|
||||||
if (parser.seenval('L')) {
|
if (parser.seenval('L')) {
|
||||||
g26_layer_height = parser.value_linear_units();
|
g26_layer_height = parser.value_linear_units();
|
||||||
if (!WITHIN(g26_layer_height, 0.0, 2.0)) {
|
if (!WITHIN(g26_layer_height, 0.0, 2.0)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Specified layer height not plausible.");
|
SERIAL_ECHOLNPGM("?Specified layer height not plausible.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -590,12 +590,12 @@ void GcodeSuite::G26() {
|
||||||
if (parser.has_value()) {
|
if (parser.has_value()) {
|
||||||
g26_retraction_multiplier = parser.value_float();
|
g26_retraction_multiplier = parser.value_float();
|
||||||
if (!WITHIN(g26_retraction_multiplier, 0.05, 15.0)) {
|
if (!WITHIN(g26_retraction_multiplier, 0.05, 15.0)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Specified Retraction Multiplier not plausible.");
|
SERIAL_ECHOLNPGM("?Specified Retraction Multiplier not plausible.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
SERIAL_PROTOCOLLNPGM("?Retraction Multiplier must be specified.");
|
SERIAL_ECHOLNPGM("?Retraction Multiplier must be specified.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -603,7 +603,7 @@ void GcodeSuite::G26() {
|
||||||
if (parser.seenval('S')) {
|
if (parser.seenval('S')) {
|
||||||
g26_nozzle = parser.value_float();
|
g26_nozzle = parser.value_float();
|
||||||
if (!WITHIN(g26_nozzle, 0.1, 1.0)) {
|
if (!WITHIN(g26_nozzle, 0.1, 1.0)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Specified nozzle size not plausible.");
|
SERIAL_ECHOLNPGM("?Specified nozzle size not plausible.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -613,7 +613,7 @@ void GcodeSuite::G26() {
|
||||||
#if HAS_LCD_MENU
|
#if HAS_LCD_MENU
|
||||||
g26_prime_flag = -1;
|
g26_prime_flag = -1;
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOLLNPGM("?Prime length must be specified when not using an LCD.");
|
SERIAL_ECHOLNPGM("?Prime length must be specified when not using an LCD.");
|
||||||
return;
|
return;
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
@ -621,7 +621,7 @@ void GcodeSuite::G26() {
|
||||||
g26_prime_flag++;
|
g26_prime_flag++;
|
||||||
g26_prime_length = parser.value_linear_units();
|
g26_prime_length = parser.value_linear_units();
|
||||||
if (!WITHIN(g26_prime_length, 0.0, 25.0)) {
|
if (!WITHIN(g26_prime_length, 0.0, 25.0)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Specified prime length not plausible.");
|
SERIAL_ECHOLNPGM("?Specified prime length not plausible.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -630,7 +630,7 @@ void GcodeSuite::G26() {
|
||||||
if (parser.seenval('F')) {
|
if (parser.seenval('F')) {
|
||||||
g26_filament_diameter = parser.value_linear_units();
|
g26_filament_diameter = parser.value_linear_units();
|
||||||
if (!WITHIN(g26_filament_diameter, 1.0, 4.0)) {
|
if (!WITHIN(g26_filament_diameter, 1.0, 4.0)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Specified filament size not plausible.");
|
SERIAL_ECHOLNPGM("?Specified filament size not plausible.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -643,7 +643,7 @@ void GcodeSuite::G26() {
|
||||||
if (parser.seenval('H')) {
|
if (parser.seenval('H')) {
|
||||||
g26_hotend_temp = parser.value_celsius();
|
g26_hotend_temp = parser.value_celsius();
|
||||||
if (!WITHIN(g26_hotend_temp, 165, 280)) {
|
if (!WITHIN(g26_hotend_temp, 165, 280)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Specified nozzle temperature not plausible.");
|
SERIAL_ECHOLNPGM("?Specified nozzle temperature not plausible.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -659,21 +659,21 @@ void GcodeSuite::G26() {
|
||||||
g26_repeats = parser.intval('R', GRID_MAX_POINTS + 1);
|
g26_repeats = parser.intval('R', GRID_MAX_POINTS + 1);
|
||||||
#else
|
#else
|
||||||
if (!parser.seen('R')) {
|
if (!parser.seen('R')) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(R)epeat must be specified when not using an LCD.");
|
SERIAL_ECHOLNPGM("?(R)epeat must be specified when not using an LCD.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
g26_repeats = parser.has_value() ? parser.value_int() : GRID_MAX_POINTS + 1;
|
g26_repeats = parser.has_value() ? parser.value_int() : GRID_MAX_POINTS + 1;
|
||||||
#endif
|
#endif
|
||||||
if (g26_repeats < 1) {
|
if (g26_repeats < 1) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(R)epeat value not plausible; must be at least 1.");
|
SERIAL_ECHOLNPGM("?(R)epeat value not plausible; must be at least 1.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
g26_x_pos = parser.seenval('X') ? RAW_X_POSITION(parser.value_linear_units()) : current_position[X_AXIS];
|
g26_x_pos = parser.seenval('X') ? RAW_X_POSITION(parser.value_linear_units()) : current_position[X_AXIS];
|
||||||
g26_y_pos = parser.seenval('Y') ? RAW_Y_POSITION(parser.value_linear_units()) : current_position[Y_AXIS];
|
g26_y_pos = parser.seenval('Y') ? RAW_Y_POSITION(parser.value_linear_units()) : current_position[Y_AXIS];
|
||||||
if (!position_is_reachable(g26_x_pos, g26_y_pos)) {
|
if (!position_is_reachable(g26_x_pos, g26_y_pos)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Specified X,Y coordinate out of bounds.");
|
SERIAL_ECHOLNPGM("?Specified X,Y coordinate out of bounds.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -95,13 +95,13 @@ void GcodeSuite::M420() {
|
||||||
const int16_t a = settings.calc_num_meshes();
|
const int16_t a = settings.calc_num_meshes();
|
||||||
|
|
||||||
if (!a) {
|
if (!a) {
|
||||||
SERIAL_PROTOCOLLNPGM("?EEPROM storage not available.");
|
SERIAL_ECHOLNPGM("?EEPROM storage not available.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!WITHIN(storage_slot, 0, a - 1)) {
|
if (!WITHIN(storage_slot, 0, a - 1)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Invalid storage slot.");
|
SERIAL_ECHOLNPGM("?Invalid storage slot.");
|
||||||
SERIAL_PROTOCOLLNPAIR("?Use 0 to ", a - 1);
|
SERIAL_ECHOLNPAIR("?Use 0 to ", a - 1);
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -110,7 +110,7 @@ void GcodeSuite::M420() {
|
||||||
|
|
||||||
#else
|
#else
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("?EEPROM storage not available.");
|
SERIAL_ECHOLNPGM("?EEPROM storage not available.");
|
||||||
return;
|
return;
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
@ -206,10 +206,8 @@ void GcodeSuite::M420() {
|
||||||
set_bed_leveling_enabled(to_enable);
|
set_bed_leveling_enabled(to_enable);
|
||||||
|
|
||||||
// Error if leveling failed to enable or reenable
|
// Error if leveling failed to enable or reenable
|
||||||
if (to_enable && !planner.leveling_active) {
|
if (to_enable && !planner.leveling_active)
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_M420_FAILED);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_M420_FAILED);
|
|
||||||
}
|
|
||||||
|
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_START();
|
||||||
SERIAL_ECHOPGM("Bed Leveling ");
|
SERIAL_ECHOPGM("Bed Leveling ");
|
||||||
|
|
|
@ -293,15 +293,13 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
const bool seen_w = parser.seen('W');
|
const bool seen_w = parser.seen('W');
|
||||||
if (seen_w) {
|
if (seen_w) {
|
||||||
if (!leveling_is_valid()) {
|
if (!leveling_is_valid()) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG("No bilinear grid");
|
||||||
SERIAL_ERRORLNPGM("No bilinear grid");
|
|
||||||
G29_RETURN(false);
|
G29_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
const float rz = parser.seenval('Z') ? RAW_Z_POSITION(parser.value_linear_units()) : current_position[Z_AXIS];
|
const float rz = parser.seenval('Z') ? RAW_Z_POSITION(parser.value_linear_units()) : current_position[Z_AXIS];
|
||||||
if (!WITHIN(rz, -10, 10)) {
|
if (!WITHIN(rz, -10, 10)) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG("Bad Z value");
|
||||||
SERIAL_ERRORLNPGM("Bad Z value");
|
|
||||||
G29_RETURN(false);
|
G29_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -343,7 +341,7 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
|
|
||||||
verbose_level = parser.intval('V');
|
verbose_level = parser.intval('V');
|
||||||
if (!WITHIN(verbose_level, 0, 4)) {
|
if (!WITHIN(verbose_level, 0, 4)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(V)erbose level is implausible (0-4).");
|
SERIAL_ECHOLNPGM("?(V)erbose level is implausible (0-4).");
|
||||||
G29_RETURN(false);
|
G29_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -364,11 +362,11 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
if (parser.seenval('P')) abl_grid_points_x = abl_grid_points_y = parser.value_int();
|
if (parser.seenval('P')) abl_grid_points_x = abl_grid_points_y = parser.value_int();
|
||||||
|
|
||||||
if (!WITHIN(abl_grid_points_x, 2, GRID_MAX_POINTS_X)) {
|
if (!WITHIN(abl_grid_points_x, 2, GRID_MAX_POINTS_X)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Probe points (X) is implausible (2-" STRINGIFY(GRID_MAX_POINTS_X) ").");
|
SERIAL_ECHOLNPGM("?Probe points (X) is implausible (2-" STRINGIFY(GRID_MAX_POINTS_X) ").");
|
||||||
G29_RETURN(false);
|
G29_RETURN(false);
|
||||||
}
|
}
|
||||||
if (!WITHIN(abl_grid_points_y, 2, GRID_MAX_POINTS_Y)) {
|
if (!WITHIN(abl_grid_points_y, 2, GRID_MAX_POINTS_Y)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Probe points (Y) is implausible (2-" STRINGIFY(GRID_MAX_POINTS_Y) ").");
|
SERIAL_ECHOLNPGM("?Probe points (Y) is implausible (2-" STRINGIFY(GRID_MAX_POINTS_Y) ").");
|
||||||
G29_RETURN(false);
|
G29_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -410,7 +408,7 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
|| !position_is_reachable_by_probe(right_probe_bed_position, back_probe_bed_position)
|
|| !position_is_reachable_by_probe(right_probe_bed_position, back_probe_bed_position)
|
||||||
#endif
|
#endif
|
||||||
) {
|
) {
|
||||||
SERIAL_PROTOCOLLNPGM("? (L,R,F,B) out of bounds.");
|
SERIAL_ECHOLNPGM("? (L,R,F,B) out of bounds.");
|
||||||
G29_RETURN(false);
|
G29_RETURN(false);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -421,8 +419,8 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
#endif // ABL_GRID
|
#endif // ABL_GRID
|
||||||
|
|
||||||
if (verbose_level > 0) {
|
if (verbose_level > 0) {
|
||||||
SERIAL_PROTOCOLPGM("G29 Auto Bed Leveling");
|
SERIAL_ECHOPGM("G29 Auto Bed Leveling");
|
||||||
if (dryrun) SERIAL_PROTOCOLPGM(" (DRYRUN)");
|
if (dryrun) SERIAL_ECHOPGM(" (DRYRUN)");
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -491,7 +489,7 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
|
|
||||||
// Abort current G29 procedure, go back to idle state
|
// Abort current G29 procedure, go back to idle state
|
||||||
if (seenA && g29_in_progress) {
|
if (seenA && g29_in_progress) {
|
||||||
SERIAL_PROTOCOLLNPGM("Manual G29 aborted");
|
SERIAL_ECHOLNPGM("Manual G29 aborted");
|
||||||
#if HAS_SOFTWARE_ENDSTOPS
|
#if HAS_SOFTWARE_ENDSTOPS
|
||||||
soft_endstops_enabled = enable_soft_endstops;
|
soft_endstops_enabled = enable_soft_endstops;
|
||||||
#endif
|
#endif
|
||||||
|
@ -504,13 +502,13 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
|
|
||||||
// Query G29 status
|
// Query G29 status
|
||||||
if (verbose_level || seenQ) {
|
if (verbose_level || seenQ) {
|
||||||
SERIAL_PROTOCOLPGM("Manual G29 ");
|
SERIAL_ECHOPGM("Manual G29 ");
|
||||||
if (g29_in_progress) {
|
if (g29_in_progress) {
|
||||||
SERIAL_PROTOCOLPAIR("point ", MIN(abl_probe_index + 1, abl_points));
|
SERIAL_ECHOPAIR("point ", MIN(abl_probe_index + 1, abl_points));
|
||||||
SERIAL_PROTOCOLLNPAIR(" of ", abl_points);
|
SERIAL_ECHOLNPAIR(" of ", abl_points);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
SERIAL_PROTOCOLLNPGM("idle");
|
SERIAL_ECHOLNPGM("idle");
|
||||||
}
|
}
|
||||||
|
|
||||||
if (no_action) G29_RETURN(false);
|
if (no_action) G29_RETURN(false);
|
||||||
|
@ -553,9 +551,9 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
|
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
if (DEBUGGING(LEVELING)) {
|
if (DEBUGGING(LEVELING)) {
|
||||||
SERIAL_PROTOCOLPAIR("Save X", xCount);
|
SERIAL_ECHOPAIR("Save X", xCount);
|
||||||
SERIAL_PROTOCOLPAIR(" Y", yCount);
|
SERIAL_ECHOPAIR(" Y", yCount);
|
||||||
SERIAL_PROTOCOLLNPAIR(" Z", measured_z + zoffset);
|
SERIAL_ECHOLNPAIR(" Z", measured_z + zoffset);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
@ -609,7 +607,7 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
|
|
||||||
// Leveling done! Fall through to G29 finishing code below
|
// Leveling done! Fall through to G29 finishing code below
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("Grid probing done.");
|
SERIAL_ECHOLNPGM("Grid probing done.");
|
||||||
|
|
||||||
// Re-enable software endstops, if needed
|
// Re-enable software endstops, if needed
|
||||||
#if HAS_SOFTWARE_ENDSTOPS
|
#if HAS_SOFTWARE_ENDSTOPS
|
||||||
|
@ -633,7 +631,7 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("3-point probing done.");
|
SERIAL_ECHOLNPGM("3-point probing done.");
|
||||||
|
|
||||||
// Re-enable software endstops, if needed
|
// Re-enable software endstops, if needed
|
||||||
#if HAS_SOFTWARE_ENDSTOPS
|
#if HAS_SOFTWARE_ENDSTOPS
|
||||||
|
@ -829,18 +827,12 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
mean /= abl_points;
|
mean /= abl_points;
|
||||||
|
|
||||||
if (verbose_level) {
|
if (verbose_level) {
|
||||||
SERIAL_PROTOCOLPGM("Eqn coefficients: a: ");
|
SERIAL_ECHOPAIR_F("Eqn coefficients: a: ", plane_equation_coefficients[0], 8);
|
||||||
SERIAL_PROTOCOL_F(plane_equation_coefficients[0], 8);
|
SERIAL_ECHOPAIR_F(" b: ", plane_equation_coefficients[1], 8);
|
||||||
SERIAL_PROTOCOLPGM(" b: ");
|
SERIAL_ECHOPAIR_F(" d: ", plane_equation_coefficients[2], 8);
|
||||||
SERIAL_PROTOCOL_F(plane_equation_coefficients[1], 8);
|
if (verbose_level > 2)
|
||||||
SERIAL_PROTOCOLPGM(" d: ");
|
SERIAL_ECHOPAIR_F("\nMean of sampled points: ", mean, 8);
|
||||||
SERIAL_PROTOCOL_F(plane_equation_coefficients[2], 8);
|
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
if (verbose_level > 2) {
|
|
||||||
SERIAL_PROTOCOLPGM("Mean of sampled points: ");
|
|
||||||
SERIAL_PROTOCOL_F(mean, 8);
|
|
||||||
SERIAL_EOL();
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Create the matrix but don't correct the position yet
|
// Create the matrix but don't correct the position yet
|
||||||
|
@ -852,7 +844,7 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
// Show the Topography map if enabled
|
// Show the Topography map if enabled
|
||||||
if (do_topography_map) {
|
if (do_topography_map) {
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("\nBed Height Topography:\n"
|
SERIAL_ECHOLNPGM("\nBed Height Topography:\n"
|
||||||
" +--- BACK --+\n"
|
" +--- BACK --+\n"
|
||||||
" | |\n"
|
" | |\n"
|
||||||
" L | (+) | R\n"
|
" L | (+) | R\n"
|
||||||
|
@ -879,17 +871,17 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
NOMORE(min_diff, eqnBVector[ind] - z_tmp);
|
NOMORE(min_diff, eqnBVector[ind] - z_tmp);
|
||||||
|
|
||||||
if (diff >= 0.0)
|
if (diff >= 0.0)
|
||||||
SERIAL_PROTOCOLPGM(" +"); // Include + for column alignment
|
SERIAL_ECHOPGM(" +"); // Include + for column alignment
|
||||||
else
|
else
|
||||||
SERIAL_PROTOCOLCHAR(' ');
|
SERIAL_CHAR(' ');
|
||||||
SERIAL_PROTOCOL_F(diff, 5);
|
SERIAL_ECHO_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_ECHOLNPGM("\nCorrected Bed Height vs. Bed Topology:");
|
||||||
|
|
||||||
for (int8_t yy = abl_grid_points_y - 1; yy >= 0; yy--) {
|
for (int8_t yy = abl_grid_points_y - 1; yy >= 0; yy--) {
|
||||||
for (uint8_t xx = 0; xx < abl_grid_points_x; xx++) {
|
for (uint8_t xx = 0; xx < abl_grid_points_x; xx++) {
|
||||||
|
@ -902,11 +894,11 @@ G29_TYPE GcodeSuite::G29() {
|
||||||
|
|
||||||
float diff = eqnBVector[ind] - z_tmp - min_diff;
|
float diff = eqnBVector[ind] - z_tmp - min_diff;
|
||||||
if (diff >= 0.0)
|
if (diff >= 0.0)
|
||||||
SERIAL_PROTOCOLPGM(" +");
|
SERIAL_ECHOPGM(" +");
|
||||||
// Include + for column alignment
|
// Include + for column alignment
|
||||||
else
|
else
|
||||||
SERIAL_PROTOCOLCHAR(' ');
|
SERIAL_CHAR(' ');
|
||||||
SERIAL_PROTOCOL_F(diff, 5);
|
SERIAL_ECHO_F(diff, 5);
|
||||||
} // xx
|
} // xx
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
} // yy
|
} // yy
|
||||||
|
|
|
@ -45,14 +45,10 @@ void GcodeSuite::M421() {
|
||||||
hasZ = parser.seen('Z'),
|
hasZ = parser.seen('Z'),
|
||||||
hasQ = !hasZ && parser.seen('Q');
|
hasQ = !hasZ && parser.seen('Q');
|
||||||
|
|
||||||
if (!hasI || !hasJ || !(hasZ || hasQ)) {
|
if (!hasI || !hasJ || !(hasZ || hasQ))
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(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))
|
||||||
}
|
SERIAL_ERROR_MSG(MSG_ERR_MESH_XY);
|
||||||
else if (!WITHIN(ix, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(iy, 0, GRID_MAX_POINTS_Y - 1)) {
|
|
||||||
SERIAL_ERROR_START();
|
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
|
|
||||||
}
|
|
||||||
else {
|
else {
|
||||||
z_values[ix][iy] = parser.value_linear_units() + (hasQ ? z_values[ix][iy] : 0);
|
z_values[ix][iy] = parser.value_linear_units() + (hasQ ? z_values[ix][iy] : 0);
|
||||||
#if ENABLED(ABL_BILINEAR_SUBDIVISION)
|
#if ENABLED(ABL_BILINEAR_SUBDIVISION)
|
||||||
|
|
|
@ -39,7 +39,7 @@
|
||||||
#include "../../../module/stepper.h"
|
#include "../../../module/stepper.h"
|
||||||
|
|
||||||
// Save 130 bytes with non-duplication of PSTR
|
// Save 130 bytes with non-duplication of PSTR
|
||||||
inline void echo_not_entered(const char c) { SERIAL_CHAR(c); SERIAL_PROTOCOLLNPGM(" not entered."); }
|
inline void echo_not_entered(const char c) { SERIAL_CHAR(c); SERIAL_ECHOLNPGM(" not entered."); }
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* G29: Mesh-based Z probe, probes a grid and produces a
|
* G29: Mesh-based Z probe, probes a grid and produces a
|
||||||
|
@ -64,7 +64,7 @@ void GcodeSuite::G29() {
|
||||||
|
|
||||||
MeshLevelingState state = (MeshLevelingState)parser.byteval('S', (int8_t)MeshReport);
|
MeshLevelingState state = (MeshLevelingState)parser.byteval('S', (int8_t)MeshReport);
|
||||||
if (!WITHIN(state, 0, 5)) {
|
if (!WITHIN(state, 0, 5)) {
|
||||||
SERIAL_PROTOCOLLNPGM("S out of range (0-5).");
|
SERIAL_ECHOLNPGM("S out of range (0-5).");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -72,13 +72,13 @@ void GcodeSuite::G29() {
|
||||||
|
|
||||||
switch (state) {
|
switch (state) {
|
||||||
case MeshReport:
|
case MeshReport:
|
||||||
SERIAL_PROTOCOLPGM("Mesh Bed Leveling ");
|
SERIAL_ECHOPGM("Mesh Bed Leveling ");
|
||||||
if (leveling_is_valid()) {
|
if (leveling_is_valid()) {
|
||||||
serialprintln_onoff(planner.leveling_active);
|
serialprintln_onoff(planner.leveling_active);
|
||||||
mbl.report_mesh();
|
mbl.report_mesh();
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
SERIAL_PROTOCOLLNPGM("has no data.");
|
SERIAL_ECHOLNPGM("has no data.");
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case MeshStart:
|
case MeshStart:
|
||||||
|
@ -92,7 +92,7 @@ void GcodeSuite::G29() {
|
||||||
|
|
||||||
case MeshNext:
|
case MeshNext:
|
||||||
if (mbl_probe_index < 0) {
|
if (mbl_probe_index < 0) {
|
||||||
SERIAL_PROTOCOLLNPGM("Start mesh probing with \"G29 S1\" first.");
|
SERIAL_ECHOLNPGM("Start mesh probing with \"G29 S1\" first.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
// For each G29 S2...
|
// For each G29 S2...
|
||||||
|
@ -130,7 +130,7 @@ void GcodeSuite::G29() {
|
||||||
|
|
||||||
// After recording the last point, activate home and activate
|
// After recording the last point, activate home and activate
|
||||||
mbl_probe_index = -1;
|
mbl_probe_index = -1;
|
||||||
SERIAL_PROTOCOLLNPGM("Mesh probing done.");
|
SERIAL_ECHOLNPGM("Mesh probing done.");
|
||||||
BUZZ(100, 659);
|
BUZZ(100, 659);
|
||||||
BUZZ(100, 698);
|
BUZZ(100, 698);
|
||||||
|
|
||||||
|
@ -154,8 +154,8 @@ void GcodeSuite::G29() {
|
||||||
if (parser.seenval('I')) {
|
if (parser.seenval('I')) {
|
||||||
ix = parser.value_int();
|
ix = parser.value_int();
|
||||||
if (!WITHIN(ix, 0, GRID_MAX_POINTS_X - 1)) {
|
if (!WITHIN(ix, 0, GRID_MAX_POINTS_X - 1)) {
|
||||||
SERIAL_PROTOCOLPAIR("I out of range (0-", int(GRID_MAX_POINTS_X - 1));
|
SERIAL_ECHOPAIR("I out of range (0-", int(GRID_MAX_POINTS_X - 1));
|
||||||
SERIAL_PROTOCOLLNPGM(")");
|
SERIAL_ECHOLNPGM(")");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -165,8 +165,8 @@ void GcodeSuite::G29() {
|
||||||
if (parser.seenval('J')) {
|
if (parser.seenval('J')) {
|
||||||
iy = parser.value_int();
|
iy = parser.value_int();
|
||||||
if (!WITHIN(iy, 0, GRID_MAX_POINTS_Y - 1)) {
|
if (!WITHIN(iy, 0, GRID_MAX_POINTS_Y - 1)) {
|
||||||
SERIAL_PROTOCOLPAIR("J out of range (0-", int(GRID_MAX_POINTS_Y - 1));
|
SERIAL_ECHOPAIR("J out of range (0-", int(GRID_MAX_POINTS_Y - 1));
|
||||||
SERIAL_PROTOCOLLNPGM(")");
|
SERIAL_ECHOLNPGM(")");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -193,8 +193,8 @@ void GcodeSuite::G29() {
|
||||||
} // switch(state)
|
} // switch(state)
|
||||||
|
|
||||||
if (state == MeshNext) {
|
if (state == MeshNext) {
|
||||||
SERIAL_PROTOCOLPAIR("MBL G29 point ", MIN(mbl_probe_index, GRID_MAX_POINTS));
|
SERIAL_ECHOPAIR("MBL G29 point ", MIN(mbl_probe_index, GRID_MAX_POINTS));
|
||||||
SERIAL_PROTOCOLLNPAIR(" of ", int(GRID_MAX_POINTS));
|
SERIAL_ECHOLNPAIR(" of ", int(GRID_MAX_POINTS));
|
||||||
}
|
}
|
||||||
|
|
||||||
report_current_position();
|
report_current_position();
|
||||||
|
|
|
@ -48,14 +48,10 @@ void GcodeSuite::M421() {
|
||||||
const int8_t iy = hasJ ? parser.value_int() : hasY ? mbl.probe_index_y(RAW_Y_POSITION(parser.value_linear_units())) : -1;
|
const int8_t iy = hasJ ? parser.value_int() : hasY ? mbl.probe_index_y(RAW_Y_POSITION(parser.value_linear_units())) : -1;
|
||||||
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_MSG(MSG_ERR_M421_PARAMETERS);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_M421_PARAMETERS);
|
else if (ix < 0 || iy < 0)
|
||||||
}
|
SERIAL_ERROR_MSG(MSG_ERR_MESH_XY);
|
||||||
else if (ix < 0 || iy < 0) {
|
|
||||||
SERIAL_ERROR_START();
|
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
|
|
||||||
}
|
|
||||||
else
|
else
|
||||||
mbl.set_z(ix, iy, parser.value_linear_units() + (hasQ ? mbl.z_values[ix][iy] : 0));
|
mbl.set_z(ix, iy, parser.value_linear_units() + (hasQ ? mbl.z_values[ix][iy] : 0));
|
||||||
}
|
}
|
||||||
|
|
|
@ -56,14 +56,10 @@ void GcodeSuite::M421() {
|
||||||
iy = location.y_index;
|
iy = location.y_index;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (int(hasC) + int(hasI && hasJ) != 1 || !(hasZ || hasQ || hasN)) {
|
if (int(hasC) + int(hasI && hasJ) != 1 || !(hasZ || hasQ || hasN))
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(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))
|
||||||
}
|
SERIAL_ERROR_MSG(MSG_ERR_MESH_XY);
|
||||||
else if (!WITHIN(ix, 0, GRID_MAX_POINTS_X - 1) || !WITHIN(iy, 0, GRID_MAX_POINTS_Y - 1)) {
|
|
||||||
SERIAL_ERROR_START();
|
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_MESH_XY);
|
|
||||||
}
|
|
||||||
else
|
else
|
||||||
ubl.z_values[ix][iy] = hasN ? NAN : parser.value_linear_units() + (hasQ ? ubl.z_values[ix][iy] : 0);
|
ubl.z_values[ix][iy] = hasN ? NAN : parser.value_linear_units() + (hasQ ? ubl.z_values[ix][iy] : 0);
|
||||||
}
|
}
|
||||||
|
|
|
@ -33,7 +33,7 @@
|
||||||
|
|
||||||
void GcodeSuite::M49() {
|
void GcodeSuite::M49() {
|
||||||
g26_debug_flag ^= true;
|
g26_debug_flag ^= true;
|
||||||
SERIAL_PROTOCOLPGM("G26 Debug: ");
|
SERIAL_ECHOPGM("G26 Debug: ");
|
||||||
serialprintPGM(g26_debug_flag ? PSTR("On\n") : PSTR("Off\n"));
|
serialprintPGM(g26_debug_flag ? PSTR("On\n") : PSTR("Off\n"));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -92,8 +92,7 @@
|
||||||
// Disallow Z homing if X or Y are unknown
|
// Disallow Z homing if X or Y are unknown
|
||||||
if (!TEST(axis_known_position, X_AXIS) || !TEST(axis_known_position, Y_AXIS)) {
|
if (!TEST(axis_known_position, X_AXIS) || !TEST(axis_known_position, Y_AXIS)) {
|
||||||
LCD_MESSAGEPGM(MSG_ERR_Z_HOMING);
|
LCD_MESSAGEPGM(MSG_ERR_Z_HOMING);
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(MSG_ERR_Z_HOMING);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_Z_HOMING);
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -135,8 +134,7 @@
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
LCD_MESSAGEPGM(MSG_ZPROBE_OUT);
|
LCD_MESSAGEPGM(MSG_ZPROBE_OUT);
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(MSG_ZPROBE_OUT);
|
||||||
SERIAL_ECHOLNPGM(MSG_ZPROBE_OUT);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
|
|
|
@ -109,28 +109,28 @@ void ac_cleanup(
|
||||||
}
|
}
|
||||||
|
|
||||||
void print_signed_float(PGM_P const prefix, const float &f) {
|
void print_signed_float(PGM_P const prefix, const float &f) {
|
||||||
SERIAL_PROTOCOLPGM(" ");
|
SERIAL_ECHOPGM(" ");
|
||||||
serialprintPGM(prefix);
|
serialprintPGM(prefix);
|
||||||
SERIAL_PROTOCOLCHAR(':');
|
SERIAL_CHAR(':');
|
||||||
if (f >= 0) SERIAL_CHAR('+');
|
if (f >= 0) SERIAL_CHAR('+');
|
||||||
SERIAL_PROTOCOL_F(f, 2);
|
SERIAL_ECHO_F(f, 2);
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* - Print the delta settings
|
* - Print the delta settings
|
||||||
*/
|
*/
|
||||||
static void print_calibration_settings(const bool end_stops, const bool tower_angles) {
|
static void print_calibration_settings(const bool end_stops, const bool tower_angles) {
|
||||||
SERIAL_PROTOCOLPAIR(".Height:", delta_height);
|
SERIAL_ECHOPAIR(".Height:", delta_height);
|
||||||
if (end_stops) {
|
if (end_stops) {
|
||||||
print_signed_float(PSTR("Ex"), delta_endstop_adj[A_AXIS]);
|
print_signed_float(PSTR("Ex"), delta_endstop_adj[A_AXIS]);
|
||||||
print_signed_float(PSTR("Ey"), delta_endstop_adj[B_AXIS]);
|
print_signed_float(PSTR("Ey"), delta_endstop_adj[B_AXIS]);
|
||||||
print_signed_float(PSTR("Ez"), delta_endstop_adj[C_AXIS]);
|
print_signed_float(PSTR("Ez"), delta_endstop_adj[C_AXIS]);
|
||||||
}
|
}
|
||||||
if (end_stops && tower_angles) {
|
if (end_stops && tower_angles) {
|
||||||
SERIAL_PROTOCOLPAIR(" Radius:", delta_radius);
|
SERIAL_ECHOPAIR(" Radius:", delta_radius);
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
SERIAL_CHAR('.');
|
SERIAL_CHAR('.');
|
||||||
SERIAL_PROTOCOL_SP(13);
|
SERIAL_ECHO_SP(13);
|
||||||
}
|
}
|
||||||
if (tower_angles) {
|
if (tower_angles) {
|
||||||
print_signed_float(PSTR("Tx"), delta_tower_angle_trim[A_AXIS]);
|
print_signed_float(PSTR("Tx"), delta_tower_angle_trim[A_AXIS]);
|
||||||
|
@ -138,11 +138,11 @@ static void print_calibration_settings(const bool end_stops, const bool tower_an
|
||||||
print_signed_float(PSTR("Tz"), delta_tower_angle_trim[C_AXIS]);
|
print_signed_float(PSTR("Tz"), delta_tower_angle_trim[C_AXIS]);
|
||||||
}
|
}
|
||||||
if ((!end_stops && tower_angles) || (end_stops && !tower_angles)) { // XOR
|
if ((!end_stops && tower_angles) || (end_stops && !tower_angles)) { // XOR
|
||||||
SERIAL_PROTOCOLPAIR(" Radius:", delta_radius);
|
SERIAL_ECHOPAIR(" Radius:", delta_radius);
|
||||||
}
|
}
|
||||||
#if HAS_BED_PROBE
|
#if HAS_BED_PROBE
|
||||||
if (!end_stops && !tower_angles) {
|
if (!end_stops && !tower_angles) {
|
||||||
SERIAL_PROTOCOL_SP(30);
|
SERIAL_ECHO_SP(30);
|
||||||
print_signed_float(PSTR("Offset"), zprobe_zoffset);
|
print_signed_float(PSTR("Offset"), zprobe_zoffset);
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -153,7 +153,7 @@ static void print_calibration_settings(const bool end_stops, const bool tower_an
|
||||||
* - Print the probe results
|
* - Print the probe results
|
||||||
*/
|
*/
|
||||||
static void print_calibration_results(const float z_pt[NPP + 1], const bool tower_points, const bool opposite_points) {
|
static void print_calibration_results(const float z_pt[NPP + 1], const bool tower_points, const bool opposite_points) {
|
||||||
SERIAL_PROTOCOLPGM(". ");
|
SERIAL_ECHOPGM(". ");
|
||||||
print_signed_float(PSTR("c"), z_pt[CEN]);
|
print_signed_float(PSTR("c"), z_pt[CEN]);
|
||||||
if (tower_points) {
|
if (tower_points) {
|
||||||
print_signed_float(PSTR(" x"), z_pt[__A]);
|
print_signed_float(PSTR(" x"), z_pt[__A]);
|
||||||
|
@ -163,7 +163,7 @@ static void print_calibration_results(const float z_pt[NPP + 1], const bool towe
|
||||||
if (tower_points && opposite_points) {
|
if (tower_points && opposite_points) {
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
SERIAL_CHAR('.');
|
SERIAL_CHAR('.');
|
||||||
SERIAL_PROTOCOL_SP(13);
|
SERIAL_ECHO_SP(13);
|
||||||
}
|
}
|
||||||
if (opposite_points) {
|
if (opposite_points) {
|
||||||
print_signed_float(PSTR("yz"), z_pt[_BC]);
|
print_signed_float(PSTR("yz"), z_pt[_BC]);
|
||||||
|
@ -438,7 +438,7 @@ void GcodeSuite::G33() {
|
||||||
|
|
||||||
const int8_t probe_points = set_up ? 2 : parser.intval('P', DELTA_CALIBRATION_DEFAULT_POINTS);
|
const int8_t probe_points = set_up ? 2 : parser.intval('P', DELTA_CALIBRATION_DEFAULT_POINTS);
|
||||||
if (!WITHIN(probe_points, -1, 10)) {
|
if (!WITHIN(probe_points, -1, 10)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(P)oints is implausible (-1 - 10).");
|
SERIAL_ECHOLNPGM("?(P)oints is implausible (-1 - 10).");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -446,19 +446,19 @@ void GcodeSuite::G33() {
|
||||||
|
|
||||||
const float calibration_precision = set_up ? Z_CLEARANCE_BETWEEN_PROBES / 5.0 : parser.floatval('C', 0.0);
|
const float calibration_precision = set_up ? Z_CLEARANCE_BETWEEN_PROBES / 5.0 : parser.floatval('C', 0.0);
|
||||||
if (calibration_precision < 0) {
|
if (calibration_precision < 0) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(C)alibration precision is implausible (>=0).");
|
SERIAL_ECHOLNPGM("?(C)alibration precision is implausible (>=0).");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
const int8_t force_iterations = parser.intval('F', 0);
|
const int8_t force_iterations = parser.intval('F', 0);
|
||||||
if (!WITHIN(force_iterations, 0, 30)) {
|
if (!WITHIN(force_iterations, 0, 30)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(F)orce iteration is implausible (0 - 30).");
|
SERIAL_ECHOLNPGM("?(F)orce iteration is implausible (0 - 30).");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
const int8_t verbose_level = parser.byteval('V', 1);
|
const int8_t verbose_level = parser.byteval('V', 1);
|
||||||
if (!WITHIN(verbose_level, 0, 3)) {
|
if (!WITHIN(verbose_level, 0, 3)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(V)erbose level is implausible (0 - 3).");
|
SERIAL_ECHOLNPGM("?(V)erbose level is implausible (0 - 3).");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -503,14 +503,14 @@ void GcodeSuite::G33() {
|
||||||
delta_tower_angle_trim[C_AXIS]
|
delta_tower_angle_trim[C_AXIS]
|
||||||
};
|
};
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("G33 Auto Calibrate");
|
SERIAL_ECHOLNPGM("G33 Auto Calibrate");
|
||||||
|
|
||||||
if (!_1p_calibration && !_0p_calibration) { // test if the outer radius is reachable
|
if (!_1p_calibration && !_0p_calibration) { // test if the outer radius is reachable
|
||||||
LOOP_CAL_RAD(axis) {
|
LOOP_CAL_RAD(axis) {
|
||||||
const float a = RADIANS(210 + (360 / NPP) * (axis - 1)),
|
const float a = RADIANS(210 + (360 / NPP) * (axis - 1)),
|
||||||
r = delta_calibration_radius;
|
r = delta_calibration_radius;
|
||||||
if (!position_is_reachable(cos(a) * r, sin(a) * r)) {
|
if (!position_is_reachable(cos(a) * r, sin(a) * r)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(M665 B)ed radius is implausible.");
|
SERIAL_ECHOLNPGM("?(M665 B)ed radius is implausible.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -519,8 +519,8 @@ void GcodeSuite::G33() {
|
||||||
// Report settings
|
// Report settings
|
||||||
PGM_P checkingac = PSTR("Checking... AC");
|
PGM_P checkingac = PSTR("Checking... AC");
|
||||||
serialprintPGM(checkingac);
|
serialprintPGM(checkingac);
|
||||||
if (verbose_level == 0) SERIAL_PROTOCOLPGM(" (DRY-RUN)");
|
if (verbose_level == 0) SERIAL_ECHOPGM(" (DRY-RUN)");
|
||||||
if (set_up) SERIAL_PROTOCOLPGM(" (SET-UP)");
|
if (set_up) SERIAL_ECHOPGM(" (SET-UP)");
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
ui.set_status_P(checkingac);
|
ui.set_status_P(checkingac);
|
||||||
|
|
||||||
|
@ -540,7 +540,7 @@ void GcodeSuite::G33() {
|
||||||
// Probe the points
|
// Probe the points
|
||||||
zero_std_dev_old = zero_std_dev;
|
zero_std_dev_old = zero_std_dev;
|
||||||
if (!probe_calibration_points(z_at_pt, probe_points, towers_set, stow_after_each, set_up)) {
|
if (!probe_calibration_points(z_at_pt, probe_points, towers_set, stow_after_each, set_up)) {
|
||||||
SERIAL_PROTOCOLLNPGM("Correct delta settings with M665 and M666");
|
SERIAL_ECHOLNPGM("Correct delta settings with M665 and M666");
|
||||||
return AC_CLEANUP();
|
return AC_CLEANUP();
|
||||||
}
|
}
|
||||||
zero_std_dev = std_dev_points(z_at_pt, _0p_calibration, _1p_calibration, _4p_calibration, _4p_opposite_points);
|
zero_std_dev = std_dev_points(z_at_pt, _0p_calibration, _1p_calibration, _4p_calibration, _4p_opposite_points);
|
||||||
|
@ -665,16 +665,15 @@ void GcodeSuite::G33() {
|
||||||
|
|
||||||
if (verbose_level != 0) { // !dry run
|
if (verbose_level != 0) { // !dry run
|
||||||
if ((zero_std_dev >= test_precision && iterations > force_iterations) || zero_std_dev <= calibration_precision) { // end iterations
|
if ((zero_std_dev >= test_precision && iterations > force_iterations) || zero_std_dev <= calibration_precision) { // end iterations
|
||||||
SERIAL_PROTOCOLPGM("Calibration OK");
|
SERIAL_ECHOPGM("Calibration OK");
|
||||||
SERIAL_PROTOCOL_SP(32);
|
SERIAL_ECHO_SP(32);
|
||||||
#if HAS_BED_PROBE
|
#if HAS_BED_PROBE
|
||||||
if (zero_std_dev >= test_precision && !_1p_calibration && !_0p_calibration)
|
if (zero_std_dev >= test_precision && !_1p_calibration && !_0p_calibration)
|
||||||
SERIAL_PROTOCOLPGM("rolling back.");
|
SERIAL_ECHOPGM("rolling back.");
|
||||||
else
|
else
|
||||||
#endif
|
#endif
|
||||||
{
|
{
|
||||||
SERIAL_PROTOCOLPGM("std dev:");
|
SERIAL_ECHOPAIR_F("std dev:", zero_std_dev_min, 3);
|
||||||
SERIAL_PROTOCOL_F(zero_std_dev_min, 3);
|
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
char mess[21];
|
char mess[21];
|
||||||
|
@ -694,11 +693,9 @@ void GcodeSuite::G33() {
|
||||||
sprintf_P(mess, PSTR("Iteration : %02i"), (int)iterations);
|
sprintf_P(mess, PSTR("Iteration : %02i"), (int)iterations);
|
||||||
else
|
else
|
||||||
strcpy_P(mess, PSTR("No convergence"));
|
strcpy_P(mess, PSTR("No convergence"));
|
||||||
SERIAL_PROTOCOL(mess);
|
SERIAL_ECHO(mess);
|
||||||
SERIAL_PROTOCOL_SP(32);
|
SERIAL_ECHO_SP(32);
|
||||||
SERIAL_PROTOCOLPGM("std dev:");
|
SERIAL_ECHOLNPAIR_F("std dev:", zero_std_dev, 3);
|
||||||
SERIAL_PROTOCOL_F(zero_std_dev, 3);
|
|
||||||
SERIAL_EOL();
|
|
||||||
ui.set_status(mess);
|
ui.set_status(mess);
|
||||||
if (verbose_level > 1)
|
if (verbose_level > 1)
|
||||||
print_calibration_settings(_endstop_results, _angle_results);
|
print_calibration_settings(_endstop_results, _angle_results);
|
||||||
|
@ -707,10 +704,8 @@ void GcodeSuite::G33() {
|
||||||
else { // dry run
|
else { // dry run
|
||||||
PGM_P enddryrun = PSTR("End DRY-RUN");
|
PGM_P enddryrun = PSTR("End DRY-RUN");
|
||||||
serialprintPGM(enddryrun);
|
serialprintPGM(enddryrun);
|
||||||
SERIAL_PROTOCOL_SP(35);
|
SERIAL_ECHO_SP(35);
|
||||||
SERIAL_PROTOCOLPGM("std dev:");
|
SERIAL_ECHOLNPAIR_F("std dev:", zero_std_dev, 3);
|
||||||
SERIAL_PROTOCOL_F(zero_std_dev, 3);
|
|
||||||
SERIAL_EOL();
|
|
||||||
|
|
||||||
char mess[21];
|
char mess[21];
|
||||||
strcpy_P(mess, enddryrun);
|
strcpy_P(mess, enddryrun);
|
||||||
|
|
|
@ -263,19 +263,19 @@ void GcodeSuite::G34() {
|
||||||
void GcodeSuite::M422() {
|
void GcodeSuite::M422() {
|
||||||
const int8_t zstepper = parser.intval('S') - 1;
|
const int8_t zstepper = parser.intval('S') - 1;
|
||||||
if (!WITHIN(zstepper, 0, Z_STEPPER_COUNT - 1)) {
|
if (!WITHIN(zstepper, 0, Z_STEPPER_COUNT - 1)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(S) Z-Stepper index invalid.");
|
SERIAL_ECHOLNPGM("?(S) Z-Stepper index invalid.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
const float x_pos = parser.floatval('X', z_auto_align_xpos[zstepper]);
|
const float x_pos = parser.floatval('X', z_auto_align_xpos[zstepper]);
|
||||||
if (!WITHIN(x_pos, X_MIN_POS, X_MAX_POS)) {
|
if (!WITHIN(x_pos, X_MIN_POS, X_MAX_POS)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(X) out of bounds.");
|
SERIAL_ECHOLNPGM("?(X) out of bounds.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
const float y_pos = parser.floatval('Y', z_auto_align_ypos[zstepper]);
|
const float y_pos = parser.floatval('Y', z_auto_align_ypos[zstepper]);
|
||||||
if (!WITHIN(y_pos, Y_MIN_POS, Y_MAX_POS)) {
|
if (!WITHIN(y_pos, Y_MIN_POS, Y_MAX_POS)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(Y) out of bounds.");
|
SERIAL_ECHOLNPGM("?(Y) out of bounds.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -55,16 +55,16 @@ void GcodeSuite::M48() {
|
||||||
|
|
||||||
const int8_t verbose_level = parser.byteval('V', 1);
|
const int8_t verbose_level = parser.byteval('V', 1);
|
||||||
if (!WITHIN(verbose_level, 0, 4)) {
|
if (!WITHIN(verbose_level, 0, 4)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?(V)erbose level is implausible (0-4).");
|
SERIAL_ECHOLNPGM("?(V)erbose level is implausible (0-4).");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (verbose_level > 0)
|
if (verbose_level > 0)
|
||||||
SERIAL_PROTOCOLLNPGM("M48 Z-Probe Repeatability Test");
|
SERIAL_ECHOLNPGM("M48 Z-Probe Repeatability Test");
|
||||||
|
|
||||||
const int8_t n_samples = parser.byteval('P', 10);
|
const int8_t n_samples = parser.byteval('P', 10);
|
||||||
if (!WITHIN(n_samples, 4, 50)) {
|
if (!WITHIN(n_samples, 4, 50)) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Sample size not plausible (4-50).");
|
SERIAL_ECHOLNPGM("?Sample size not plausible (4-50).");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -77,14 +77,14 @@ void GcodeSuite::M48() {
|
||||||
Y_probe_location = parser.linearval('Y', Y_current + Y_PROBE_OFFSET_FROM_EXTRUDER);
|
Y_probe_location = parser.linearval('Y', Y_current + Y_PROBE_OFFSET_FROM_EXTRUDER);
|
||||||
|
|
||||||
if (!position_is_reachable_by_probe(X_probe_location, Y_probe_location)) {
|
if (!position_is_reachable_by_probe(X_probe_location, Y_probe_location)) {
|
||||||
SERIAL_PROTOCOLLNPGM("? (X,Y) out of bounds.");
|
SERIAL_ECHOLNPGM("? (X,Y) out of bounds.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
bool seen_L = parser.seen('L');
|
bool seen_L = parser.seen('L');
|
||||||
uint8_t n_legs = seen_L ? parser.value_byte() : 0;
|
uint8_t n_legs = seen_L ? parser.value_byte() : 0;
|
||||||
if (n_legs > 15) {
|
if (n_legs > 15) {
|
||||||
SERIAL_PROTOCOLLNPGM("?Number of legs in movement not plausible (0-15).");
|
SERIAL_ECHOLNPGM("?Number of legs in movement not plausible (0-15).");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
if (n_legs == 1) n_legs = 2;
|
if (n_legs == 1) n_legs = 2;
|
||||||
|
@ -98,7 +98,7 @@ void GcodeSuite::M48() {
|
||||||
* we don't want to use that as a starting point for each probe.
|
* we don't want to use that as a starting point for each probe.
|
||||||
*/
|
*/
|
||||||
if (verbose_level > 2)
|
if (verbose_level > 2)
|
||||||
SERIAL_PROTOCOLLNPGM("Positioning the probe...");
|
SERIAL_ECHOLNPGM("Positioning the probe...");
|
||||||
|
|
||||||
// Disable bed level correction in M48 because we want the raw data when we probe
|
// Disable bed level correction in M48 because we want the raw data when we probe
|
||||||
|
|
||||||
|
@ -178,7 +178,7 @@ void GcodeSuite::M48() {
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
if (verbose_level > 3) {
|
if (verbose_level > 3) {
|
||||||
SERIAL_PROTOCOLPGM("Going to:");
|
SERIAL_ECHOPGM("Going to:");
|
||||||
SERIAL_ECHOPAIR(" X", X_current);
|
SERIAL_ECHOPAIR(" X", X_current);
|
||||||
SERIAL_ECHOPAIR(" Y", Y_current);
|
SERIAL_ECHOPAIR(" Y", Y_current);
|
||||||
SERIAL_ECHOLNPAIR(" Z", current_position[Z_AXIS]);
|
SERIAL_ECHOLNPAIR(" Z", current_position[Z_AXIS]);
|
||||||
|
@ -215,22 +215,15 @@ void GcodeSuite::M48() {
|
||||||
sigma = SQRT(sum / (n + 1));
|
sigma = SQRT(sum / (n + 1));
|
||||||
if (verbose_level > 0) {
|
if (verbose_level > 0) {
|
||||||
if (verbose_level > 1) {
|
if (verbose_level > 1) {
|
||||||
SERIAL_PROTOCOL(n + 1);
|
SERIAL_ECHO(n + 1);
|
||||||
SERIAL_PROTOCOLPGM(" of ");
|
SERIAL_ECHOPAIR(" of ", (int)n_samples);
|
||||||
SERIAL_PROTOCOL((int)n_samples);
|
SERIAL_ECHOPAIR_F(": z: ", sample_set[n], 3);
|
||||||
SERIAL_PROTOCOLPGM(": z: ");
|
|
||||||
SERIAL_PROTOCOL_F(sample_set[n], 3);
|
|
||||||
if (verbose_level > 2) {
|
if (verbose_level > 2) {
|
||||||
SERIAL_PROTOCOLPGM(" mean: ");
|
SERIAL_ECHOPAIR_F(" mean: ", mean, 4);
|
||||||
SERIAL_PROTOCOL_F(mean, 4);
|
SERIAL_ECHOPAIR_F(" sigma: ", sigma, 6);
|
||||||
SERIAL_PROTOCOLPGM(" sigma: ");
|
SERIAL_ECHOPAIR_F(" min: ", min, 3);
|
||||||
SERIAL_PROTOCOL_F(sigma, 6);
|
SERIAL_ECHOPAIR_F(" max: ", max, 3);
|
||||||
SERIAL_PROTOCOLPGM(" min: ");
|
SERIAL_ECHOPAIR_F(" range: ", max-min, 3);
|
||||||
SERIAL_PROTOCOL_F(min, 3);
|
|
||||||
SERIAL_PROTOCOLPGM(" max: ");
|
|
||||||
SERIAL_PROTOCOL_F(max, 3);
|
|
||||||
SERIAL_PROTOCOLPGM(" range: ");
|
|
||||||
SERIAL_PROTOCOL_F(max-min, 3);
|
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
@ -242,23 +235,16 @@ void GcodeSuite::M48() {
|
||||||
STOW_PROBE();
|
STOW_PROBE();
|
||||||
|
|
||||||
if (probing_good) {
|
if (probing_good) {
|
||||||
SERIAL_PROTOCOLLNPGM("Finished!");
|
SERIAL_ECHOLNPGM("Finished!");
|
||||||
|
|
||||||
if (verbose_level > 0) {
|
if (verbose_level > 0) {
|
||||||
SERIAL_PROTOCOLPGM("Mean: ");
|
SERIAL_ECHOPAIR_F("Mean: ", mean, 6);
|
||||||
SERIAL_PROTOCOL_F(mean, 6);
|
SERIAL_ECHOPAIR_F(" Min: ", min, 3);
|
||||||
SERIAL_PROTOCOLPGM(" Min: ");
|
SERIAL_ECHOPAIR_F(" Max: ", max, 3);
|
||||||
SERIAL_PROTOCOL_F(min, 3);
|
SERIAL_ECHOLNPAIR_F(" Range: ", max-min, 3);
|
||||||
SERIAL_PROTOCOLPGM(" Max: ");
|
|
||||||
SERIAL_PROTOCOL_F(max, 3);
|
|
||||||
SERIAL_PROTOCOLPGM(" Range: ");
|
|
||||||
SERIAL_PROTOCOL_F(max-min, 3);
|
|
||||||
SERIAL_EOL();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM("Standard Deviation: ");
|
SERIAL_ECHOLNPAIR_F("Standard Deviation: ", sigma, 6);
|
||||||
SERIAL_PROTOCOL_F(sigma, 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -84,8 +84,7 @@
|
||||||
if (sumAPX == 1)
|
if (sumAPX == 1)
|
||||||
scara_home_offset[A_AXIS] = parser.value_float();
|
scara_home_offset[A_AXIS] = parser.value_float();
|
||||||
else {
|
else {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG("Only one of A, P, or X is allowed.");
|
||||||
SERIAL_ERRORLNPGM("Only one of A, P, or X is allowed.");
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -96,8 +95,7 @@
|
||||||
if (sumBTY == 1)
|
if (sumBTY == 1)
|
||||||
scara_home_offset[B_AXIS] = parser.value_float();
|
scara_home_offset[B_AXIS] = parser.value_float();
|
||||||
else {
|
else {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG("Only one of B, T, or Y is allowed.");
|
||||||
SERIAL_ERRORLNPGM("Only one of B, T, or Y is allowed.");
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -93,9 +93,7 @@ void GcodeSuite::M852() {
|
||||||
|
|
||||||
if (!ijk) {
|
if (!ijk) {
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_START();
|
||||||
SERIAL_ECHOPGM(MSG_SKEW_FACTOR " XY: ");
|
SERIAL_ECHOLNPAIR_F(MSG_SKEW_FACTOR " XY: ", planner.skew_factor.xy, 6);
|
||||||
SERIAL_ECHO_F(planner.skew_factor.xy, 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
#if ENABLED(SKEW_CORRECTION_FOR_Z)
|
#if ENABLED(SKEW_CORRECTION_FOR_Z)
|
||||||
SERIAL_ECHOPAIR(" XZ: ", planner.skew_factor.xz);
|
SERIAL_ECHOPAIR(" XZ: ", planner.skew_factor.xz);
|
||||||
SERIAL_ECHOLNPAIR(" YZ: ", planner.skew_factor.yz);
|
SERIAL_ECHOLNPAIR(" YZ: ", planner.skew_factor.yz);
|
||||||
|
|
|
@ -147,10 +147,8 @@ void GcodeSuite::M205() {
|
||||||
planner.recalculate_max_e_jerk();
|
planner.recalculate_max_e_jerk();
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
else {
|
else
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG("?J out of range (0.01 to 0.3)");
|
||||||
SERIAL_ERRORLNPGM("?J out of range (0.01 to 0.3)");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
#if HAS_CLASSIC_JERK
|
#if HAS_CLASSIC_JERK
|
||||||
|
|
|
@ -70,10 +70,8 @@ void GcodeSuite::M301() {
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
else {
|
else
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_INVALID_EXTRUDER);
|
||||||
SERIAL_ERRORLNPGM(MSG_INVALID_EXTRUDER);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif // PIDTEMP
|
#endif // PIDTEMP
|
||||||
|
|
|
@ -89,22 +89,20 @@ inline void toggle_pins() {
|
||||||
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_MSG("SERVO not setup");
|
||||||
SERIAL_ERRORLNPGM("SERVO not setup");
|
|
||||||
|
|
||||||
#elif !HAS_Z_SERVO_PROBE
|
#elif !HAS_Z_SERVO_PROBE
|
||||||
|
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG("Z_PROBE_SERVO_NR not setup");
|
||||||
SERIAL_ERRORLNPGM("Z_PROBE_SERVO_NR not setup");
|
|
||||||
|
|
||||||
#else // HAS_Z_SERVO_PROBE
|
#else // HAS_Z_SERVO_PROBE
|
||||||
|
|
||||||
const uint8_t probe_index = parser.byteval('P', Z_PROBE_SERVO_NR);
|
const uint8_t probe_index = parser.byteval('P', Z_PROBE_SERVO_NR);
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM("Servo probe test");
|
SERIAL_ECHOLNPGM("Servo probe test");
|
||||||
SERIAL_PROTOCOLLNPAIR(". using index: ", probe_index);
|
SERIAL_ECHOLNPAIR(". using index: ", probe_index);
|
||||||
SERIAL_PROTOCOLLNPAIR(". deploy angle: ", servo_angles[probe_index][0]);
|
SERIAL_ECHOLNPAIR(". deploy angle: ", servo_angles[probe_index][0]);
|
||||||
SERIAL_PROTOCOLLNPAIR(". stow angle: ", servo_angles[probe_index][1]);
|
SERIAL_ECHOLNPAIR(". stow angle: ", servo_angles[probe_index][1]);
|
||||||
|
|
||||||
bool probe_inverting;
|
bool probe_inverting;
|
||||||
|
|
||||||
|
@ -112,14 +110,14 @@ inline void servo_probe_test() {
|
||||||
|
|
||||||
#define PROBE_TEST_PIN Z_MIN_PIN
|
#define PROBE_TEST_PIN Z_MIN_PIN
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPAIR(". probe uses Z_MIN pin: ", PROBE_TEST_PIN);
|
SERIAL_ECHOLNPAIR(". probe uses Z_MIN pin: ", PROBE_TEST_PIN);
|
||||||
SERIAL_PROTOCOLLNPGM(". uses Z_MIN_ENDSTOP_INVERTING (ignores Z_MIN_PROBE_ENDSTOP_INVERTING)");
|
SERIAL_ECHOLNPGM(". uses Z_MIN_ENDSTOP_INVERTING (ignores Z_MIN_PROBE_ENDSTOP_INVERTING)");
|
||||||
SERIAL_PROTOCOLPGM(". Z_MIN_ENDSTOP_INVERTING: ");
|
SERIAL_ECHOPGM(". Z_MIN_ENDSTOP_INVERTING: ");
|
||||||
|
|
||||||
#if Z_MIN_ENDSTOP_INVERTING
|
#if Z_MIN_ENDSTOP_INVERTING
|
||||||
SERIAL_PROTOCOLLNPGM("true");
|
SERIAL_ECHOLNPGM("true");
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOLLNPGM("false");
|
SERIAL_ECHOLNPGM("false");
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
probe_inverting = Z_MIN_ENDSTOP_INVERTING;
|
probe_inverting = Z_MIN_ENDSTOP_INVERTING;
|
||||||
|
@ -127,21 +125,21 @@ inline void servo_probe_test() {
|
||||||
#elif ENABLED(Z_MIN_PROBE_ENDSTOP)
|
#elif ENABLED(Z_MIN_PROBE_ENDSTOP)
|
||||||
|
|
||||||
#define PROBE_TEST_PIN Z_MIN_PROBE_PIN
|
#define PROBE_TEST_PIN Z_MIN_PROBE_PIN
|
||||||
SERIAL_PROTOCOLLNPAIR(". probe uses Z_MIN_PROBE_PIN: ", PROBE_TEST_PIN);
|
SERIAL_ECHOLNPAIR(". probe uses Z_MIN_PROBE_PIN: ", PROBE_TEST_PIN);
|
||||||
SERIAL_PROTOCOLLNPGM(". uses Z_MIN_PROBE_ENDSTOP_INVERTING (ignores Z_MIN_ENDSTOP_INVERTING)");
|
SERIAL_ECHOLNPGM(". uses Z_MIN_PROBE_ENDSTOP_INVERTING (ignores Z_MIN_ENDSTOP_INVERTING)");
|
||||||
SERIAL_PROTOCOLPGM(". Z_MIN_PROBE_ENDSTOP_INVERTING: ");
|
SERIAL_ECHOPGM(". Z_MIN_PROBE_ENDSTOP_INVERTING: ");
|
||||||
|
|
||||||
#if Z_MIN_PROBE_ENDSTOP_INVERTING
|
#if Z_MIN_PROBE_ENDSTOP_INVERTING
|
||||||
SERIAL_PROTOCOLLNPGM("true");
|
SERIAL_ECHOLNPGM("true");
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOLLNPGM("false");
|
SERIAL_ECHOLNPGM("false");
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
probe_inverting = Z_MIN_PROBE_ENDSTOP_INVERTING;
|
probe_inverting = Z_MIN_PROBE_ENDSTOP_INVERTING;
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM(". deploy & stow 4 times");
|
SERIAL_ECHOLNPGM(". deploy & stow 4 times");
|
||||||
SET_INPUT_PULLUP(PROBE_TEST_PIN);
|
SET_INPUT_PULLUP(PROBE_TEST_PIN);
|
||||||
uint8_t i = 0;
|
uint8_t i = 0;
|
||||||
bool deploy_state, stow_state;
|
bool deploy_state, stow_state;
|
||||||
|
@ -153,26 +151,26 @@ inline void servo_probe_test() {
|
||||||
safe_delay(500);
|
safe_delay(500);
|
||||||
stow_state = READ(PROBE_TEST_PIN);
|
stow_state = READ(PROBE_TEST_PIN);
|
||||||
} while (++i < 4);
|
} while (++i < 4);
|
||||||
if (probe_inverting != deploy_state) SERIAL_PROTOCOLLNPGM("WARNING - INVERTING setting probably backwards");
|
if (probe_inverting != deploy_state) SERIAL_ECHOLNPGM("WARNING - INVERTING setting probably backwards");
|
||||||
|
|
||||||
if (deploy_state != stow_state) {
|
if (deploy_state != stow_state) {
|
||||||
SERIAL_PROTOCOLLNPGM("BLTouch clone detected");
|
SERIAL_ECHOLNPGM("BLTouch clone detected");
|
||||||
if (deploy_state) {
|
if (deploy_state) {
|
||||||
SERIAL_PROTOCOLLNPGM(". DEPLOYED state: HIGH (logic 1)");
|
SERIAL_ECHOLNPGM(". DEPLOYED state: HIGH (logic 1)");
|
||||||
SERIAL_PROTOCOLLNPGM(". STOWED (triggered) state: LOW (logic 0)");
|
SERIAL_ECHOLNPGM(". STOWED (triggered) state: LOW (logic 0)");
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
SERIAL_PROTOCOLLNPGM(". DEPLOYED state: LOW (logic 0)");
|
SERIAL_ECHOLNPGM(". DEPLOYED state: LOW (logic 0)");
|
||||||
SERIAL_PROTOCOLLNPGM(". STOWED (triggered) state: HIGH (logic 1)");
|
SERIAL_ECHOLNPGM(". STOWED (triggered) state: HIGH (logic 1)");
|
||||||
}
|
}
|
||||||
#if ENABLED(BLTOUCH)
|
#if ENABLED(BLTOUCH)
|
||||||
SERIAL_PROTOCOLLNPGM("ERROR: BLTOUCH enabled - set this device up as a Z Servo Probe with inverting as true.");
|
SERIAL_ECHOLNPGM("ERROR: BLTOUCH enabled - set this device up as a Z Servo Probe with inverting as true.");
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
else { // measure active signal length
|
else { // measure active signal length
|
||||||
MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
|
MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][0]); // Deploy
|
||||||
safe_delay(500);
|
safe_delay(500);
|
||||||
SERIAL_PROTOCOLLNPGM("please trigger probe");
|
SERIAL_ECHOLNPGM("please trigger probe");
|
||||||
uint16_t probe_counter = 0;
|
uint16_t probe_counter = 0;
|
||||||
|
|
||||||
// Allow 30 seconds max for operator to trigger probe
|
// Allow 30 seconds max for operator to trigger probe
|
||||||
|
@ -188,11 +186,11 @@ inline void servo_probe_test() {
|
||||||
safe_delay(2);
|
safe_delay(2);
|
||||||
|
|
||||||
if (probe_counter == 50)
|
if (probe_counter == 50)
|
||||||
SERIAL_PROTOCOLLNPGM("Z Servo Probe detected"); // >= 100mS active time
|
SERIAL_ECHOLNPGM("Z Servo Probe detected"); // >= 100mS active time
|
||||||
else if (probe_counter >= 2)
|
else if (probe_counter >= 2)
|
||||||
SERIAL_PROTOCOLLNPAIR("BLTouch compatible probe detected - pulse width (+/- 4mS): ", probe_counter * 2); // allow 4 - 100mS pulse
|
SERIAL_ECHOLNPAIR("BLTouch compatible probe detected - pulse width (+/- 4mS): ", probe_counter * 2); // allow 4 - 100mS pulse
|
||||||
else
|
else
|
||||||
SERIAL_PROTOCOLLNPGM("noise detected - please re-run test"); // less than 2mS pulse
|
SERIAL_ECHOLNPGM("noise detected - please re-run test"); // less than 2mS pulse
|
||||||
|
|
||||||
MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
|
MOVE_SERVO(probe_index, servo_angles[Z_PROBE_SERVO_NR][1]); // Stow
|
||||||
|
|
||||||
|
@ -200,7 +198,7 @@ inline void servo_probe_test() {
|
||||||
|
|
||||||
} // for loop waiting for trigger
|
} // for loop waiting for trigger
|
||||||
|
|
||||||
if (probe_counter == 0) SERIAL_PROTOCOLLNPGM("trigger not detected");
|
if (probe_counter == 0) SERIAL_ECHOLNPGM("trigger not detected");
|
||||||
|
|
||||||
} // measure active signal length
|
} // measure active signal length
|
||||||
|
|
||||||
|
@ -245,9 +243,9 @@ void GcodeSuite::M43() {
|
||||||
// Enable or disable endstop monitoring
|
// Enable or disable endstop monitoring
|
||||||
if (parser.seen('E')) {
|
if (parser.seen('E')) {
|
||||||
endstops.monitor_flag = parser.value_bool();
|
endstops.monitor_flag = parser.value_bool();
|
||||||
SERIAL_PROTOCOLPGM("endstop monitor ");
|
SERIAL_ECHOPGM("endstop monitor ");
|
||||||
serialprintPGM(endstops.monitor_flag ? PSTR("en") : PSTR("dis"));
|
serialprintPGM(endstops.monitor_flag ? PSTR("en") : PSTR("dis"));
|
||||||
SERIAL_PROTOCOLLNPGM("abled");
|
SERIAL_ECHOLNPGM("abled");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -266,7 +264,7 @@ void GcodeSuite::M43() {
|
||||||
|
|
||||||
// Watch until click, M108, or reset
|
// Watch until click, M108, or reset
|
||||||
if (parser.boolval('W')) {
|
if (parser.boolval('W')) {
|
||||||
SERIAL_PROTOCOLLNPGM("Watching pins");
|
SERIAL_ECHOLNPGM("Watching pins");
|
||||||
|
|
||||||
#ifdef ARDUINO_ARCH_SAM
|
#ifdef ARDUINO_ARCH_SAM
|
||||||
NOLESS(first_pin, 2); // don't hijack the UART pins
|
NOLESS(first_pin, 2); // don't hijack the UART pins
|
||||||
|
|
|
@ -94,9 +94,7 @@ void GcodeSuite::M502() {
|
||||||
* M504: Validate EEPROM Contents
|
* M504: Validate EEPROM Contents
|
||||||
*/
|
*/
|
||||||
void GcodeSuite::M504() {
|
void GcodeSuite::M504() {
|
||||||
if (settings.validate(CHAT_PORT)) {
|
if (settings.validate(CHAT_PORT))
|
||||||
SERIAL_ECHO_START_P(command_queue_port[cmd_queue_index_r]);
|
SERIAL_ECHO_MSG_P(command_queue_port[cmd_queue_index_r], "EEPROM OK");
|
||||||
SERIAL_ECHOLNPGM_P(command_queue_port[cmd_queue_index_r], "EEPROM OK");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -40,7 +40,7 @@ void GcodeSuite::M900() {
|
||||||
#else
|
#else
|
||||||
const uint8_t tmp_extruder = parser.seenval('T') ? parser.value_int() : active_extruder;
|
const uint8_t tmp_extruder = parser.seenval('T') ? parser.value_int() : active_extruder;
|
||||||
if (tmp_extruder >= EXTRUDERS) {
|
if (tmp_extruder >= EXTRUDERS) {
|
||||||
SERIAL_PROTOCOLLNPGM("?T value out of range.");
|
SERIAL_ECHOLNPGM("?T value out of range.");
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -52,7 +52,7 @@ void GcodeSuite::M900() {
|
||||||
planner.extruder_advance_K[tmp_extruder] = newK;
|
planner.extruder_advance_K[tmp_extruder] = newK;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
SERIAL_PROTOCOLLNPGM("?K value out of range (0-10).");
|
SERIAL_ECHOLNPGM("?K value out of range (0-10).");
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_START();
|
||||||
|
|
|
@ -63,7 +63,6 @@ void GcodeSuite::M355() {
|
||||||
else SERIAL_ECHOLNPAIR("Case light: ", case_light_brightness);
|
else SERIAL_ECHOLNPAIR("Case light: ", case_light_brightness);
|
||||||
}
|
}
|
||||||
#else
|
#else
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_M355_NONE);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_M355_NONE);
|
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
|
@ -38,10 +38,8 @@ void GcodeSuite::M404() {
|
||||||
filament_width_nominal = parser.value_linear_units();
|
filament_width_nominal = parser.value_linear_units();
|
||||||
planner.volumetric_area_nominal = CIRCLE_AREA(filament_width_nominal * 0.5);
|
planner.volumetric_area_nominal = CIRCLE_AREA(filament_width_nominal * 0.5);
|
||||||
}
|
}
|
||||||
else {
|
else
|
||||||
SERIAL_PROTOCOLPGM("Filament dia (nominal mm):");
|
SERIAL_ECHOLNPAIR("Filament dia (nominal mm):", filament_width_nominal);
|
||||||
SERIAL_PROTOCOLLN(filament_width_nominal);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -79,8 +77,7 @@ void GcodeSuite::M406() {
|
||||||
* M407: Get measured filament diameter on serial output
|
* M407: Get measured filament diameter on serial output
|
||||||
*/
|
*/
|
||||||
void GcodeSuite::M407() {
|
void GcodeSuite::M407() {
|
||||||
SERIAL_PROTOCOLPGM("Filament dia (measured mm):");
|
SERIAL_ECHOLNPAIR("Filament dia (measured mm):", filament_width_meas);
|
||||||
SERIAL_PROTOCOLLN(filament_width_meas);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif // FILAMENT_WIDTH_SENSOR
|
#endif // FILAMENT_WIDTH_SENSOR
|
||||||
|
|
|
@ -68,13 +68,10 @@ void GcodeSuite::M261() {
|
||||||
|
|
||||||
uint8_t bytes = parser.byteval('B', 1);
|
uint8_t bytes = parser.byteval('B', 1);
|
||||||
|
|
||||||
if (i2c.addr && bytes && bytes <= TWIBUS_BUFFER_SIZE) {
|
if (i2c.addr && bytes && bytes <= TWIBUS_BUFFER_SIZE)
|
||||||
i2c.relay(bytes);
|
i2c.relay(bytes);
|
||||||
}
|
else
|
||||||
else {
|
SERIAL_ERROR_MSG("Bad i2c request");
|
||||||
SERIAL_ERROR_START();
|
|
||||||
SERIAL_ERRORLNPGM("Bad i2c request");
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -45,10 +45,8 @@ void GcodeSuite::M810_819() {
|
||||||
|
|
||||||
if (len) {
|
if (len) {
|
||||||
// Set a macro
|
// Set a macro
|
||||||
if (len > GCODE_MACROS_SLOT_SIZE) {
|
if (len > GCODE_MACROS_SLOT_SIZE)
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG("Macro too long.");
|
||||||
SERIAL_ERRORLNPGM("Macro too long.");
|
|
||||||
}
|
|
||||||
else {
|
else {
|
||||||
char c, *s = parser.string_arg, *d = gcode_macros[index];
|
char c, *s = parser.string_arg, *d = gcode_macros[index];
|
||||||
do {
|
do {
|
||||||
|
|
|
@ -790,16 +790,13 @@ void GcodeSuite::process_next_command() {
|
||||||
switch (busy_state) {
|
switch (busy_state) {
|
||||||
case IN_HANDLER:
|
case IN_HANDLER:
|
||||||
case IN_PROCESS:
|
case IN_PROCESS:
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(MSG_BUSY_PROCESSING);
|
||||||
SERIAL_ECHOLNPGM(MSG_BUSY_PROCESSING);
|
|
||||||
break;
|
break;
|
||||||
case PAUSED_FOR_USER:
|
case PAUSED_FOR_USER:
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(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_MSG(MSG_BUSY_PAUSED_FOR_INPUT);
|
||||||
SERIAL_ECHOLNPGM(MSG_BUSY_PAUSED_FOR_INPUT);
|
|
||||||
break;
|
break;
|
||||||
default:
|
default:
|
||||||
break;
|
break;
|
||||||
|
|
|
@ -80,7 +80,7 @@ inline void GcodeSuite::G53() {
|
||||||
void G54_59(uint8_t subcode=0) {
|
void G54_59(uint8_t subcode=0) {
|
||||||
const int8_t _space = parser.codenum - 54 + subcode;
|
const int8_t _space = parser.codenum - 54 + subcode;
|
||||||
if (gcode.select_coordinate_system(_space)) {
|
if (gcode.select_coordinate_system(_space)) {
|
||||||
SERIAL_PROTOCOLLNPAIR("Select workspace ", _space);
|
SERIAL_ECHOLNPAIR("Select workspace ", _space);
|
||||||
report_current_position();
|
report_current_position();
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -69,8 +69,7 @@ void GcodeSuite::M428() {
|
||||||
if (!WITHIN(diff[i], -20, 20) && home_dir((AxisEnum)i) > 0)
|
if (!WITHIN(diff[i], -20, 20) && home_dir((AxisEnum)i) > 0)
|
||||||
diff[i] = -current_position[i];
|
diff[i] = -current_position[i];
|
||||||
if (!WITHIN(diff[i], -20, 20)) {
|
if (!WITHIN(diff[i], -20, 20)) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(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);
|
||||||
return;
|
return;
|
||||||
|
|
|
@ -34,7 +34,7 @@
|
||||||
SERIAL_CHAR(' ');
|
SERIAL_CHAR(' ');
|
||||||
SERIAL_CHAR(axis_codes[i]);
|
SERIAL_CHAR(axis_codes[i]);
|
||||||
SERIAL_CHAR(':');
|
SERIAL_CHAR(':');
|
||||||
SERIAL_PROTOCOL(dtostrf(pos[i], 8, precision, str));
|
SERIAL_ECHO(dtostrf(pos[i], 8, precision, str));
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
@ -43,7 +43,7 @@
|
||||||
|
|
||||||
void report_current_position_detail() {
|
void report_current_position_detail() {
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM("\nLogical:");
|
SERIAL_ECHOPGM("\nLogical:");
|
||||||
const float logical[XYZ] = {
|
const float logical[XYZ] = {
|
||||||
LOGICAL_X_POSITION(current_position[X_AXIS]),
|
LOGICAL_X_POSITION(current_position[X_AXIS]),
|
||||||
LOGICAL_Y_POSITION(current_position[Y_AXIS]),
|
LOGICAL_Y_POSITION(current_position[Y_AXIS]),
|
||||||
|
@ -51,17 +51,17 @@
|
||||||
};
|
};
|
||||||
report_xyz(logical);
|
report_xyz(logical);
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM("Raw: ");
|
SERIAL_ECHOPGM("Raw: ");
|
||||||
report_xyz(current_position);
|
report_xyz(current_position);
|
||||||
|
|
||||||
float leveled[XYZ] = { current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] };
|
float leveled[XYZ] = { current_position[X_AXIS], current_position[Y_AXIS], current_position[Z_AXIS] };
|
||||||
|
|
||||||
#if HAS_LEVELING
|
#if HAS_LEVELING
|
||||||
SERIAL_PROTOCOLPGM("Leveled:");
|
SERIAL_ECHOPGM("Leveled:");
|
||||||
planner.apply_leveling(leveled);
|
planner.apply_leveling(leveled);
|
||||||
report_xyz(leveled);
|
report_xyz(leveled);
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM("UnLevel:");
|
SERIAL_ECHOPGM("UnLevel:");
|
||||||
float unleveled[XYZ] = { leveled[X_AXIS], leveled[Y_AXIS], leveled[Z_AXIS] };
|
float unleveled[XYZ] = { leveled[X_AXIS], leveled[Y_AXIS], leveled[Z_AXIS] };
|
||||||
planner.unapply_leveling(unleveled);
|
planner.unapply_leveling(unleveled);
|
||||||
report_xyz(unleveled);
|
report_xyz(unleveled);
|
||||||
|
@ -69,9 +69,9 @@
|
||||||
|
|
||||||
#if IS_KINEMATIC
|
#if IS_KINEMATIC
|
||||||
#if IS_SCARA
|
#if IS_SCARA
|
||||||
SERIAL_PROTOCOLPGM("ScaraK: ");
|
SERIAL_ECHOPGM("ScaraK: ");
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOLPGM("DeltaK: ");
|
SERIAL_ECHOPGM("DeltaK: ");
|
||||||
#endif
|
#endif
|
||||||
inverse_kinematics(leveled); // writes delta[]
|
inverse_kinematics(leveled); // writes delta[]
|
||||||
report_xyz(delta);
|
report_xyz(delta);
|
||||||
|
@ -79,12 +79,12 @@
|
||||||
|
|
||||||
planner.synchronize();
|
planner.synchronize();
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM("Stepper:");
|
SERIAL_ECHOPGM("Stepper:");
|
||||||
LOOP_XYZE(i) {
|
LOOP_XYZE(i) {
|
||||||
SERIAL_CHAR(' ');
|
SERIAL_CHAR(' ');
|
||||||
SERIAL_CHAR(axis_codes[i]);
|
SERIAL_CHAR(axis_codes[i]);
|
||||||
SERIAL_CHAR(':');
|
SERIAL_CHAR(':');
|
||||||
SERIAL_PROTOCOL(stepper.position((AxisEnum)i));
|
SERIAL_ECHO(stepper.position((AxisEnum)i));
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
|
|
||||||
|
@ -93,11 +93,11 @@
|
||||||
planner.get_axis_position_degrees(A_AXIS),
|
planner.get_axis_position_degrees(A_AXIS),
|
||||||
planner.get_axis_position_degrees(B_AXIS)
|
planner.get_axis_position_degrees(B_AXIS)
|
||||||
};
|
};
|
||||||
SERIAL_PROTOCOLPGM("Degrees:");
|
SERIAL_ECHOPGM("Degrees:");
|
||||||
report_xyze(deg, 2);
|
report_xyze(deg, 2);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM("FromStp:");
|
SERIAL_ECHOPGM("FromStp:");
|
||||||
get_cartesian_from_steppers(); // writes cartes[XYZ] (with forward kinematics)
|
get_cartesian_from_steppers(); // writes cartes[XYZ] (with forward kinematics)
|
||||||
const float from_steppers[XYZE] = { cartes[X_AXIS], cartes[Y_AXIS], cartes[Z_AXIS], planner.get_axis_position_mm(E_AXIS) };
|
const float from_steppers[XYZE] = { cartes[X_AXIS], cartes[Y_AXIS], cartes[Z_AXIS], planner.get_axis_position_mm(E_AXIS) };
|
||||||
report_xyze(from_steppers);
|
report_xyze(from_steppers);
|
||||||
|
@ -108,7 +108,7 @@
|
||||||
from_steppers[Z_AXIS] - leveled[Z_AXIS],
|
from_steppers[Z_AXIS] - leveled[Z_AXIS],
|
||||||
from_steppers[E_AXIS] - current_position[E_AXIS]
|
from_steppers[E_AXIS] - current_position[E_AXIS]
|
||||||
};
|
};
|
||||||
SERIAL_PROTOCOLPGM("Differ: ");
|
SERIAL_ECHOPGM("Differ: ");
|
||||||
report_xyze(diff);
|
report_xyze(diff);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -29,10 +29,10 @@
|
||||||
|
|
||||||
#if ENABLED(EXTENDED_CAPABILITIES_REPORT)
|
#if ENABLED(EXTENDED_CAPABILITIES_REPORT)
|
||||||
static void cap_line(PGM_P const name, bool ena=false) {
|
static void cap_line(PGM_P const name, bool ena=false) {
|
||||||
SERIAL_PROTOCOLPGM("Cap:");
|
SERIAL_ECHOPGM("Cap:");
|
||||||
serialprintPGM(name);
|
serialprintPGM(name);
|
||||||
SERIAL_CHAR(':');
|
SERIAL_CHAR(':');
|
||||||
SERIAL_PROTOCOLLN(int(ena ? 1 : 0));
|
SERIAL_ECHOLN(int(ena ? 1 : 0));
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
@ -47,7 +47,7 @@ void GcodeSuite::M115() {
|
||||||
#define CAPLINE(STR,...) cap_line(PSTR(STR), __VA_ARGS__)
|
#define CAPLINE(STR,...) cap_line(PSTR(STR), __VA_ARGS__)
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM_P(port, MSG_M115_REPORT);
|
SERIAL_ECHOLNPGM_P(port, MSG_M115_REPORT);
|
||||||
|
|
||||||
#if ENABLED(EXTENDED_CAPABILITIES_REPORT)
|
#if ENABLED(EXTENDED_CAPABILITIES_REPORT)
|
||||||
|
|
||||||
|
|
|
@ -37,10 +37,8 @@
|
||||||
*/
|
*/
|
||||||
void GcodeSuite::M145() {
|
void GcodeSuite::M145() {
|
||||||
const uint8_t material = (uint8_t)parser.intval('S');
|
const uint8_t material = (uint8_t)parser.intval('S');
|
||||||
if (material >= COUNT(ui.preheat_hotend_temp)) {
|
if (material >= COUNT(ui.preheat_hotend_temp))
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_MATERIAL_INDEX);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_MATERIAL_INDEX);
|
|
||||||
}
|
|
||||||
else {
|
else {
|
||||||
int v;
|
int v;
|
||||||
if (parser.seenval('H')) {
|
if (parser.seenval('H')) {
|
||||||
|
|
|
@ -32,7 +32,7 @@
|
||||||
*/
|
*/
|
||||||
void GcodeSuite::M250() {
|
void GcodeSuite::M250() {
|
||||||
if (parser.seen('C')) ui.set_contrast(parser.value_int());
|
if (parser.seen('C')) ui.set_contrast(parser.value_int());
|
||||||
SERIAL_PROTOCOLLNPAIR("LCD Contrast: ", ui.contrast);
|
SERIAL_ECHOLNPAIR("LCD Contrast: ", ui.contrast);
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif // HAS_LCD_CONTRAST
|
#endif // HAS_LCD_CONTRAST
|
||||||
|
|
|
@ -293,10 +293,9 @@ void GcodeSuite::G2_G3(const bool clockwise) {
|
||||||
#if ENABLED(ARC_P_CIRCLES)
|
#if ENABLED(ARC_P_CIRCLES)
|
||||||
// P indicates number of circles to do
|
// P indicates number of circles to do
|
||||||
int8_t circles_to_do = parser.byteval('P');
|
int8_t circles_to_do = parser.byteval('P');
|
||||||
if (!WITHIN(circles_to_do, 0, 100)) {
|
if (!WITHIN(circles_to_do, 0, 100))
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_ARC_ARGS);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_ARC_ARGS);
|
|
||||||
}
|
|
||||||
while (circles_to_do--)
|
while (circles_to_do--)
|
||||||
plan_arc(current_position, arc_offset, clockwise);
|
plan_arc(current_position, arc_offset, clockwise);
|
||||||
#endif
|
#endif
|
||||||
|
@ -305,11 +304,8 @@ void GcodeSuite::G2_G3(const bool clockwise) {
|
||||||
plan_arc(destination, arc_offset, clockwise);
|
plan_arc(destination, arc_offset, clockwise);
|
||||||
reset_stepper_timeout();
|
reset_stepper_timeout();
|
||||||
}
|
}
|
||||||
else {
|
else
|
||||||
// Bad arguments
|
SERIAL_ERROR_MSG(MSG_ERR_ARC_ARGS);
|
||||||
SERIAL_ERROR_START();
|
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_ARC_ARGS);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -50,8 +50,7 @@ void GcodeSuite::G5() {
|
||||||
|
|
||||||
#if ENABLED(CNC_WORKSPACE_PLANES)
|
#if ENABLED(CNC_WORKSPACE_PLANES)
|
||||||
if (workspace_plane != PLANE_XY) {
|
if (workspace_plane != PLANE_XY) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_BAD_PLANE_MODE);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_BAD_PLANE_MODE);
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -55,9 +55,9 @@ void GcodeSuite::G30() {
|
||||||
const float measured_z = probe_pt(xpos, ypos, raise_after, 1);
|
const float measured_z = probe_pt(xpos, ypos, raise_after, 1);
|
||||||
|
|
||||||
if (!isnan(measured_z)) {
|
if (!isnan(measured_z)) {
|
||||||
SERIAL_PROTOCOLPAIR_F("Bed X: ", xpos);
|
SERIAL_ECHOPAIR("Bed X: ", FIXFLOAT(xpos));
|
||||||
SERIAL_PROTOCOLPAIR_F(" Y: ", ypos);
|
SERIAL_ECHOPAIR(" Y: ", FIXFLOAT(ypos));
|
||||||
SERIAL_PROTOCOLLNPAIR_F(" Z: ", measured_z);
|
SERIAL_ECHOLNPAIR(" Z: ", FIXFLOAT(measured_z));
|
||||||
}
|
}
|
||||||
|
|
||||||
clean_up_after_endstop_or_probe_move();
|
clean_up_after_endstop_or_probe_move();
|
||||||
|
|
|
@ -108,10 +108,7 @@ void GcodeSuite::G38(const bool is_38_2) {
|
||||||
if (ABS(destination[i] - current_position[i]) >= G38_MINIMUM_MOVE) {
|
if (ABS(destination[i] - current_position[i]) >= G38_MINIMUM_MOVE) {
|
||||||
if (!parser.seenval('F')) feedrate_mm_s = homing_feedrate((AxisEnum)i);
|
if (!parser.seenval('F')) feedrate_mm_s = homing_feedrate((AxisEnum)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_MSG("Failed to reach target");
|
||||||
SERIAL_ERROR_START();
|
|
||||||
SERIAL_ERRORLNPGM("Failed to reach target");
|
|
||||||
}
|
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -32,18 +32,13 @@ void GcodeSuite::M851() {
|
||||||
if (parser.seenval('Z')) {
|
if (parser.seenval('Z')) {
|
||||||
const float value = parser.value_linear_units();
|
const float value = parser.value_linear_units();
|
||||||
if (WITHIN(value, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX))
|
if (WITHIN(value, Z_PROBE_OFFSET_RANGE_MIN, Z_PROBE_OFFSET_RANGE_MAX))
|
||||||
{
|
|
||||||
zprobe_zoffset = value;
|
zprobe_zoffset = value;
|
||||||
}
|
else
|
||||||
else {
|
SERIAL_ERROR_MSG("?Z out of range (" STRINGIFY(Z_PROBE_OFFSET_RANGE_MIN) " to " STRINGIFY(Z_PROBE_OFFSET_RANGE_MAX) ")");
|
||||||
SERIAL_ERROR_START();
|
|
||||||
SERIAL_ERRORLNPGM("?Z out of range (" STRINGIFY(Z_PROBE_OFFSET_RANGE_MIN) " to " STRINGIFY(Z_PROBE_OFFSET_RANGE_MAX) ")");
|
|
||||||
}
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_START();
|
||||||
SERIAL_ECHOPGM(MSG_PROBE_Z_OFFSET);
|
SERIAL_ECHOLNPAIR(MSG_PROBE_Z_OFFSET ": ", zprobe_zoffset);
|
||||||
SERIAL_ECHOLNPAIR(": ", zprobe_zoffset);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#endif // HAS_BED_PROBE
|
#endif // HAS_BED_PROBE
|
||||||
|
|
|
@ -221,17 +221,17 @@ void ok_to_send() {
|
||||||
if (port < 0) return;
|
if (port < 0) return;
|
||||||
#endif
|
#endif
|
||||||
if (!send_ok[cmd_queue_index_r]) return;
|
if (!send_ok[cmd_queue_index_r]) return;
|
||||||
SERIAL_PROTOCOLPGM_P(port, MSG_OK);
|
SERIAL_ECHOPGM_P(port, MSG_OK);
|
||||||
#if ENABLED(ADVANCED_OK)
|
#if ENABLED(ADVANCED_OK)
|
||||||
char* p = command_queue[cmd_queue_index_r];
|
char* p = command_queue[cmd_queue_index_r];
|
||||||
if (*p == 'N') {
|
if (*p == 'N') {
|
||||||
SERIAL_PROTOCOL_P(port, ' ');
|
SERIAL_ECHO_P(port, ' ');
|
||||||
SERIAL_ECHO_P(port, *p++);
|
SERIAL_ECHO_P(port, *p++);
|
||||||
while (NUMERIC_SIGNED(*p))
|
while (NUMERIC_SIGNED(*p))
|
||||||
SERIAL_ECHO_P(port, *p++);
|
SERIAL_ECHO_P(port, *p++);
|
||||||
}
|
}
|
||||||
SERIAL_PROTOCOLPGM_P(port, " P"); SERIAL_PROTOCOL_P(port, int(BLOCK_BUFFER_SIZE - planner.movesplanned() - 1));
|
SERIAL_ECHOPGM_P(port, " P"); SERIAL_ECHO_P(port, int(BLOCK_BUFFER_SIZE - planner.movesplanned() - 1));
|
||||||
SERIAL_PROTOCOLPGM_P(port, " B"); SERIAL_PROTOCOL_P(port, BUFSIZE - commands_in_queue);
|
SERIAL_ECHOPGM_P(port, " B"); SERIAL_ECHO_P(port, BUFSIZE - commands_in_queue);
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
}
|
}
|
||||||
|
@ -246,15 +246,15 @@ void flush_and_request_resend() {
|
||||||
if (port < 0) return;
|
if (port < 0) return;
|
||||||
#endif
|
#endif
|
||||||
SERIAL_FLUSH_P(port);
|
SERIAL_FLUSH_P(port);
|
||||||
SERIAL_PROTOCOLPGM_P(port, MSG_RESEND);
|
SERIAL_ECHOPGM_P(port, MSG_RESEND);
|
||||||
SERIAL_PROTOCOLLN_P(port, gcode_LastN + 1);
|
SERIAL_ECHOLN_P(port, gcode_LastN + 1);
|
||||||
ok_to_send();
|
ok_to_send();
|
||||||
}
|
}
|
||||||
|
|
||||||
void gcode_line_error(PGM_P err, uint8_t port) {
|
void gcode_line_error(PGM_P err, uint8_t port) {
|
||||||
SERIAL_ERROR_START_P(port);
|
SERIAL_ERROR_START_P(port);
|
||||||
serialprintPGM_P(port, err);
|
serialprintPGM_P(port, err);
|
||||||
SERIAL_ERRORLN_P(port, gcode_LastN);
|
SERIAL_ECHOLN_P(port, gcode_LastN);
|
||||||
flush_and_request_resend();
|
flush_and_request_resend();
|
||||||
serial_count[port] = 0;
|
serial_count[port] = 0;
|
||||||
}
|
}
|
||||||
|
@ -648,7 +648,7 @@ inline void get_serial_commands() {
|
||||||
#if ENABLED(BEZIER_CURVE_SUPPORT)
|
#if ENABLED(BEZIER_CURVE_SUPPORT)
|
||||||
case 5:
|
case 5:
|
||||||
#endif
|
#endif
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_STOPPED);
|
SERIAL_ECHOLNPGM(MSG_ERR_STOPPED);
|
||||||
LCD_MESSAGEPGM(MSG_STOPPED);
|
LCD_MESSAGEPGM(MSG_STOPPED);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
@ -754,7 +754,7 @@ inline void get_serial_commands() {
|
||||||
if (IS_SD_PRINTING())
|
if (IS_SD_PRINTING())
|
||||||
sd_count = 0; // If a sub-file was printing, continue from call point
|
sd_count = 0; // If a sub-file was printing, continue from call point
|
||||||
else {
|
else {
|
||||||
SERIAL_PROTOCOLLNPGM(MSG_FILE_PRINTED);
|
SERIAL_ECHOLNPGM(MSG_FILE_PRINTED);
|
||||||
#if ENABLED(PRINTER_EVENT_LEDS)
|
#if ENABLED(PRINTER_EVENT_LEDS)
|
||||||
printerEventLEDs.onPrintCompleted();
|
printerEventLEDs.onPrintCompleted();
|
||||||
#if HAS_RESUME_CONTINUE
|
#if HAS_RESUME_CONTINUE
|
||||||
|
@ -769,10 +769,9 @@ inline void get_serial_commands() {
|
||||||
#endif // PRINTER_EVENT_LEDS
|
#endif // PRINTER_EVENT_LEDS
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else if (n == -1) {
|
else if (n == -1)
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_SD_ERR_READ);
|
||||||
SERIAL_ECHOLNPGM(MSG_SD_ERR_READ);
|
|
||||||
}
|
|
||||||
if (sd_char == '#') stop_buffering = true;
|
if (sd_char == '#') stop_buffering = true;
|
||||||
|
|
||||||
sd_comment_mode = false; // for new command
|
sd_comment_mode = false; // for new command
|
||||||
|
@ -843,7 +842,7 @@ void advance_command_queue() {
|
||||||
if (strstr_P(command, PSTR("M29"))) {
|
if (strstr_P(command, PSTR("M29"))) {
|
||||||
// M29 closes the file
|
// M29 closes the file
|
||||||
card.closefile();
|
card.closefile();
|
||||||
SERIAL_PROTOCOLLNPGM(MSG_FILE_SAVED);
|
SERIAL_ECHOLNPGM(MSG_FILE_SAVED);
|
||||||
|
|
||||||
#if !defined(__AVR__) || !defined(USBCON)
|
#if !defined(__AVR__) || !defined(USBCON)
|
||||||
#if ENABLED(SERIAL_STATS_DROPPED_RX)
|
#if ENABLED(SERIAL_STATS_DROPPED_RX)
|
||||||
|
|
|
@ -50,13 +50,13 @@ void GcodeSuite::M20() {
|
||||||
const int16_t port = command_queue_port[cmd_queue_index_r];
|
const int16_t port = command_queue_port[cmd_queue_index_r];
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SERIAL_PROTOCOLLNPGM_P(port, MSG_BEGIN_FILE_LIST);
|
SERIAL_ECHOLNPGM_P(port, MSG_BEGIN_FILE_LIST);
|
||||||
card.ls(
|
card.ls(
|
||||||
#if NUM_SERIAL > 1
|
#if NUM_SERIAL > 1
|
||||||
port
|
port
|
||||||
#endif
|
#endif
|
||||||
);
|
);
|
||||||
SERIAL_PROTOCOLLNPGM_P(port, MSG_END_FILE_LIST);
|
SERIAL_ECHOLNPGM_P(port, MSG_END_FILE_LIST);
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|
|
@ -40,15 +40,14 @@ void GcodeSuite::M105() {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if HAS_TEMP_SENSOR
|
#if HAS_TEMP_SENSOR
|
||||||
SERIAL_PROTOCOLPGM_P(port, MSG_OK);
|
SERIAL_ECHOPGM_P(port, MSG_OK);
|
||||||
thermalManager.print_heater_states(target_extruder
|
thermalManager.print_heater_states(target_extruder
|
||||||
#if NUM_SERIAL > 1
|
#if NUM_SERIAL > 1
|
||||||
, port
|
, port
|
||||||
#endif
|
#endif
|
||||||
);
|
);
|
||||||
#else // !HAS_TEMP_SENSOR
|
#else // !HAS_TEMP_SENSOR
|
||||||
SERIAL_ERROR_START_P(port);
|
SERIAL_ERROR_MSG_P(port, MSG_ERR_NO_THERMISTORS);
|
||||||
SERIAL_ERRORLNPGM_P(port, MSG_ERR_NO_THERMISTORS);
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
|
|
|
@ -296,7 +296,7 @@ void _menu_ubl_fillin() {
|
||||||
|
|
||||||
void _lcd_ubl_invalidate() {
|
void _lcd_ubl_invalidate() {
|
||||||
ubl.invalidate();
|
ubl.invalidate();
|
||||||
SERIAL_PROTOCOLLNPGM("Mesh invalidated.");
|
SERIAL_ECHOLNPGM("Mesh invalidated.");
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|
|
@ -84,13 +84,9 @@ void vector_3::apply_rotation(const matrix_3x3 &matrix) {
|
||||||
|
|
||||||
void vector_3::debug(PGM_P const title) {
|
void vector_3::debug(PGM_P const title) {
|
||||||
serialprintPGM(title);
|
serialprintPGM(title);
|
||||||
SERIAL_PROTOCOLPGM(" x: ");
|
SERIAL_ECHOPAIR_F(" x: ", x, 6);
|
||||||
SERIAL_PROTOCOL_F(x, 6);
|
SERIAL_ECHOPAIR_F(" y: ", y, 6);
|
||||||
SERIAL_PROTOCOLPGM(" y: ");
|
SERIAL_ECHOLNPAIR_F(" z: ", z, 6);
|
||||||
SERIAL_PROTOCOL_F(y, 6);
|
|
||||||
SERIAL_PROTOCOLPGM(" z: ");
|
|
||||||
SERIAL_PROTOCOL_F(z, 6);
|
|
||||||
SERIAL_EOL();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void apply_rotation_xyz(const matrix_3x3 &matrix, float &x, float &y, float &z) {
|
void apply_rotation_xyz(const matrix_3x3 &matrix, float &x, float &y, float &z) {
|
||||||
|
@ -151,9 +147,9 @@ void matrix_3x3::debug(PGM_P const title) {
|
||||||
uint8_t count = 0;
|
uint8_t count = 0;
|
||||||
for (uint8_t i = 0; i < 3; i++) {
|
for (uint8_t i = 0; i < 3; i++) {
|
||||||
for (uint8_t j = 0; j < 3; j++) {
|
for (uint8_t j = 0; j < 3; j++) {
|
||||||
if (matrix[count] >= 0.0) SERIAL_PROTOCOLCHAR('+');
|
if (matrix[count] >= 0.0) SERIAL_CHAR('+');
|
||||||
SERIAL_PROTOCOL_F(matrix[count], 6);
|
SERIAL_ECHO_F(matrix[count], 6);
|
||||||
SERIAL_PROTOCOLCHAR(' ');
|
SERIAL_CHAR(' ');
|
||||||
count++;
|
count++;
|
||||||
}
|
}
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
|
|
|
@ -384,6 +384,36 @@ void MarlinSettings::postprocess() {
|
||||||
|
|
||||||
#endif // SD_FIRMWARE_UPDATE
|
#endif // SD_FIRMWARE_UPDATE
|
||||||
|
|
||||||
|
#if ENABLED(EEPROM_CHITCHAT)
|
||||||
|
#define CHITCHAT_ECHO(V) SERIAL_ECHO(V)
|
||||||
|
#define CHITCHAT_ECHOLNPGM(STR) SERIAL_ECHOLNPGM(STR)
|
||||||
|
#define CHITCHAT_ECHOPAIR(STR,V) SERIAL_ECHOPAIR(STR,V)
|
||||||
|
#define CHITCHAT_ECHOLNPAIR(STR,V) SERIAL_ECHOLNPAIR(STR,V)
|
||||||
|
#define CHITCHAT_ECHO_START_P(port) SERIAL_ECHO_START_P(port)
|
||||||
|
#define CHITCHAT_ERROR_START_P(port) SERIAL_ERROR_START_P(port)
|
||||||
|
#define CHITCHAT_ERROR_MSG_P(port, STR) SERIAL_ERROR_MSG_P(port, STR)
|
||||||
|
#define CHITCHAT_ECHO_P(port, VAL) SERIAL_ECHO_P(port, VAL)
|
||||||
|
#define CHITCHAT_ECHOPGM_P(port, STR) SERIAL_ECHOPGM_P(port, STR)
|
||||||
|
#define CHITCHAT_ECHOLNPGM_P(port, STR) SERIAL_ECHOLNPGM_P(port, STR)
|
||||||
|
#define CHITCHAT_ECHOPAIR_P(port, STR, VAL) SERIAL_ECHOPAIR_P(port, STR, VAL)
|
||||||
|
#define CHITCHAT_ECHOLNPAIR_P(port, STR, VAL) SERIAL_ECHOLNPAIR_P(port, STR, VAL)
|
||||||
|
#define CHITCHAT_EOL() SERIAL_EOL()
|
||||||
|
#else
|
||||||
|
#define CHITCHAT_ECHO(V) NOOP
|
||||||
|
#define CHITCHAT_ECHOLNPGM(STR) NOOP
|
||||||
|
#define CHITCHAT_ECHOPAIR(STR,V) NOOP
|
||||||
|
#define CHITCHAT_ECHOLNPAIR(STR,V) NOOP
|
||||||
|
#define CHITCHAT_ECHO_START_P(port) NOOP
|
||||||
|
#define CHITCHAT_ERROR_START_P(port) NOOP
|
||||||
|
#define CHITCHAT_ERROR_MSG_P(port, STR) NOOP
|
||||||
|
#define CHITCHAT_ECHO_P(port, VAL) NOOP
|
||||||
|
#define CHITCHAT_ECHOPGM_P(port, STR) NOOP
|
||||||
|
#define CHITCHAT_ECHOLNPGM_P(port, STR) NOOP
|
||||||
|
#define CHITCHAT_ECHOPAIR_P(port, STR, VAL) NOOP
|
||||||
|
#define CHITCHAT_ECHOLNPAIR_P(port, STR, VAL) NOOP
|
||||||
|
#define CHITCHAT_EOL() NOOP
|
||||||
|
#endif
|
||||||
|
|
||||||
#if ENABLED(EEPROM_SETTINGS)
|
#if ENABLED(EEPROM_SETTINGS)
|
||||||
|
|
||||||
#define EEPROM_START() int eeprom_index = EEPROM_OFFSET; persistentStore.access_start()
|
#define EEPROM_START() int eeprom_index = EEPROM_OFFSET; persistentStore.access_start()
|
||||||
|
@ -392,7 +422,7 @@ void MarlinSettings::postprocess() {
|
||||||
#define EEPROM_WRITE(VAR) persistentStore.write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
|
#define EEPROM_WRITE(VAR) persistentStore.write_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
|
||||||
#define EEPROM_READ(VAR) persistentStore.read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc, !validating)
|
#define EEPROM_READ(VAR) persistentStore.read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc, !validating)
|
||||||
#define EEPROM_READ_ALWAYS(VAR) persistentStore.read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
|
#define EEPROM_READ_ALWAYS(VAR) persistentStore.read_data(eeprom_index, (uint8_t*)&VAR, sizeof(VAR), &working_crc)
|
||||||
#define EEPROM_ASSERT(TST,ERR) do{ if (!(TST)) { SERIAL_ERROR_START_P(port); SERIAL_ERRORLNPGM_P(port, ERR); eeprom_error = true; } }while(0)
|
#define EEPROM_ASSERT(TST,ERR) do{ if (!(TST)) { SERIAL_ERROR_MSG_P(port, ERR); eeprom_error = true; } }while(0)
|
||||||
|
|
||||||
#if ENABLED(DEBUG_EEPROM_READWRITE)
|
#if ENABLED(DEBUG_EEPROM_READWRITE)
|
||||||
#define _FIELD_TEST(FIELD) \
|
#define _FIELD_TEST(FIELD) \
|
||||||
|
@ -410,10 +440,7 @@ void MarlinSettings::postprocess() {
|
||||||
|
|
||||||
bool MarlinSettings::size_error(const uint16_t size PORTARG_AFTER) {
|
bool MarlinSettings::size_error(const uint16_t size PORTARG_AFTER) {
|
||||||
if (size != datasize()) {
|
if (size != datasize()) {
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
CHITCHAT_ERROR_MSG_P(port, "EEPROM datasize error.");
|
||||||
SERIAL_ERROR_START_P(port);
|
|
||||||
SERIAL_ERRORLNPGM_P(port, "EEPROM datasize error.");
|
|
||||||
#endif
|
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
return false;
|
return false;
|
||||||
|
@ -1050,12 +1077,10 @@ void MarlinSettings::postprocess() {
|
||||||
EEPROM_WRITE(final_crc);
|
EEPROM_WRITE(final_crc);
|
||||||
|
|
||||||
// Report storage size
|
// Report storage size
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
CHITCHAT_ECHO_START_P(port);
|
||||||
SERIAL_ECHO_START_P(port);
|
CHITCHAT_ECHOPAIR_P(port, "Settings Stored (", eeprom_size);
|
||||||
SERIAL_ECHOPAIR_P(port, "Settings Stored (", eeprom_size);
|
CHITCHAT_ECHOPAIR_P(port, " bytes; crc ", (uint32_t)final_crc);
|
||||||
SERIAL_ECHOPAIR_P(port, " bytes; crc ", (uint32_t)final_crc);
|
CHITCHAT_ECHOLNPGM_P(port, ")");
|
||||||
SERIAL_ECHOLNPGM_P(port, ")");
|
|
||||||
#endif
|
|
||||||
|
|
||||||
eeprom_error |= size_error(eeprom_size);
|
eeprom_error |= size_error(eeprom_size);
|
||||||
}
|
}
|
||||||
|
@ -1092,12 +1117,10 @@ void MarlinSettings::postprocess() {
|
||||||
stored_ver[0] = '?';
|
stored_ver[0] = '?';
|
||||||
stored_ver[1] = '\0';
|
stored_ver[1] = '\0';
|
||||||
}
|
}
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
CHITCHAT_ECHO_START_P(port);
|
||||||
SERIAL_ECHO_START_P(port);
|
CHITCHAT_ECHOPGM_P(port, "EEPROM version mismatch ");
|
||||||
SERIAL_ECHOPGM_P(port, "EEPROM version mismatch ");
|
CHITCHAT_ECHOPAIR_P(port, "(EEPROM=", stored_ver);
|
||||||
SERIAL_ECHOPAIR_P(port, "(EEPROM=", stored_ver);
|
CHITCHAT_ECHOLNPGM_P(port, " Marlin=" EEPROM_VERSION ")");
|
||||||
SERIAL_ECHOLNPGM_P(port, " Marlin=" EEPROM_VERSION ")");
|
|
||||||
#endif
|
|
||||||
eeprom_error = true;
|
eeprom_error = true;
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
|
@ -1704,31 +1727,25 @@ void MarlinSettings::postprocess() {
|
||||||
|
|
||||||
eeprom_error = size_error(eeprom_index - (EEPROM_OFFSET));
|
eeprom_error = size_error(eeprom_index - (EEPROM_OFFSET));
|
||||||
if (eeprom_error) {
|
if (eeprom_error) {
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
CHITCHAT_ECHO_START_P(port);
|
||||||
SERIAL_ECHO_START_P(port);
|
CHITCHAT_ECHOPAIR_P(port, "Index: ", int(eeprom_index - (EEPROM_OFFSET)));
|
||||||
SERIAL_ECHOPAIR_P(port, "Index: ", int(eeprom_index - (EEPROM_OFFSET)));
|
CHITCHAT_ECHOLNPAIR_P(port, " Size: ", datasize());
|
||||||
SERIAL_ECHOLNPAIR_P(port, " Size: ", datasize());
|
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
else if (working_crc != stored_crc) {
|
else if (working_crc != stored_crc) {
|
||||||
eeprom_error = true;
|
eeprom_error = true;
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
CHITCHAT_ERROR_START_P(port);
|
||||||
SERIAL_ERROR_START_P(port);
|
CHITCHAT_ECHOPGM_P(port, "EEPROM CRC mismatch - (stored) ");
|
||||||
SERIAL_ERRORPGM_P(port, "EEPROM CRC mismatch - (stored) ");
|
CHITCHAT_ECHO_P(port, stored_crc);
|
||||||
SERIAL_ERROR_P(port, stored_crc);
|
CHITCHAT_ECHOPGM_P(port, " != ");
|
||||||
SERIAL_ERRORPGM_P(port, " != ");
|
CHITCHAT_ECHO_P(port, working_crc);
|
||||||
SERIAL_ERROR_P(port, working_crc);
|
CHITCHAT_ECHOLNPGM_P(port, " (calculated)!");
|
||||||
SERIAL_ERRORLNPGM_P(port, " (calculated)!");
|
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
else if (!validating) {
|
else if (!validating) {
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
CHITCHAT_ECHO_START_P(port);
|
||||||
SERIAL_ECHO_START_P(port);
|
CHITCHAT_ECHO_P(port, version);
|
||||||
SERIAL_ECHO_P(port, version);
|
CHITCHAT_ECHOPAIR_P(port, " stored settings retrieved (", eeprom_index - (EEPROM_OFFSET));
|
||||||
SERIAL_ECHOPAIR_P(port, " stored settings retrieved (", eeprom_index - (EEPROM_OFFSET));
|
CHITCHAT_ECHOPAIR_P(port, " bytes; crc ", (uint32_t)working_crc);
|
||||||
SERIAL_ECHOPAIR_P(port, " bytes; crc ", (uint32_t)working_crc);
|
CHITCHAT_ECHOLNPGM_P(port, ")");
|
||||||
SERIAL_ECHOLNPGM_P(port, ")");
|
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!validating && !eeprom_error) postprocess();
|
if (!validating && !eeprom_error) postprocess();
|
||||||
|
@ -1741,31 +1758,27 @@ void MarlinSettings::postprocess() {
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
#if ENABLED(EEPROM_CHITCHAT)
|
||||||
ubl.echo_name();
|
ubl.echo_name();
|
||||||
SERIAL_ECHOLNPGM_P(port, " initialized.\n");
|
CHITCHAT_ECHOLNPGM_P(port, " initialized.\n");
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
eeprom_error = true;
|
eeprom_error = true;
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
#if ENABLED(EEPROM_CHITCHAT)
|
||||||
SERIAL_PROTOCOLPGM_P(port, "?Can't enable ");
|
CHITCHAT_ECHOPGM_P(port, "?Can't enable ");
|
||||||
ubl.echo_name();
|
ubl.echo_name();
|
||||||
SERIAL_PROTOCOLLNPGM_P(port, ".");
|
CHITCHAT_ECHOLNPGM_P(port, ".");
|
||||||
#endif
|
#endif
|
||||||
ubl.reset();
|
ubl.reset();
|
||||||
}
|
}
|
||||||
|
|
||||||
if (ubl.storage_slot >= 0) {
|
if (ubl.storage_slot >= 0) {
|
||||||
load_mesh(ubl.storage_slot);
|
load_mesh(ubl.storage_slot);
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
CHITCHAT_ECHOPAIR_P(port, "Mesh ", ubl.storage_slot);
|
||||||
SERIAL_ECHOPAIR_P(port, "Mesh ", ubl.storage_slot);
|
CHITCHAT_ECHOLNPGM_P(port, " loaded from storage.");
|
||||||
SERIAL_ECHOLNPGM_P(port, " loaded from storage.");
|
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
ubl.reset();
|
ubl.reset();
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
CHITCHAT_ECHOLNPGM_P(port, "UBL System reset()");
|
||||||
SERIAL_ECHOLNPGM_P(port, "UBL System reset()");
|
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
@ -1794,13 +1807,15 @@ void MarlinSettings::postprocess() {
|
||||||
|
|
||||||
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
||||||
|
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
inline void ubl_invalid_slot(const int s) {
|
||||||
void ubl_invalid_slot(const int s) {
|
#if ENABLED(EEPROM_CHITCHAT)
|
||||||
SERIAL_PROTOCOLLNPGM("?Invalid slot.");
|
CHITCHAT_ECHOLNPGM("?Invalid slot.");
|
||||||
SERIAL_PROTOCOL(s);
|
CHITCHAT_ECHO(s);
|
||||||
SERIAL_PROTOCOLLNPGM(" mesh slots available.");
|
CHITCHAT_ECHOLNPGM(" mesh slots available.");
|
||||||
}
|
#else
|
||||||
#endif
|
UNUSED(s);
|
||||||
|
#endif
|
||||||
|
}
|
||||||
|
|
||||||
const uint16_t MarlinSettings::meshes_end = persistentStore.capacity() - 129; // 128 (+1 because of the change to capacity rather than last valid address)
|
const uint16_t MarlinSettings::meshes_end = persistentStore.capacity() - 129; // 128 (+1 because of the change to capacity rather than last valid address)
|
||||||
// is a placeholder for the size of the MAT; the MAT will always
|
// is a placeholder for the size of the MAT; the MAT will always
|
||||||
|
@ -1824,32 +1839,24 @@ void MarlinSettings::postprocess() {
|
||||||
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
#if ENABLED(AUTO_BED_LEVELING_UBL)
|
||||||
const int16_t a = calc_num_meshes();
|
const int16_t a = calc_num_meshes();
|
||||||
if (!WITHIN(slot, 0, a - 1)) {
|
if (!WITHIN(slot, 0, a - 1)) {
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
ubl_invalid_slot(a);
|
||||||
ubl_invalid_slot(a);
|
CHITCHAT_ECHOPAIR("E2END=", persistentStore.capacity() - 1);
|
||||||
SERIAL_PROTOCOLPAIR("E2END=", persistentStore.capacity() - 1);
|
CHITCHAT_ECHOPAIR(" meshes_end=", meshes_end);
|
||||||
SERIAL_PROTOCOLPAIR(" meshes_end=", meshes_end);
|
CHITCHAT_ECHOLNPAIR(" slot=", slot);
|
||||||
SERIAL_PROTOCOLLNPAIR(" slot=", slot);
|
CHITCHAT_EOL();
|
||||||
SERIAL_EOL();
|
|
||||||
#endif
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
int pos = mesh_slot_offset(slot);
|
int pos = mesh_slot_offset(slot);
|
||||||
uint16_t crc = 0;
|
uint16_t crc = 0;
|
||||||
|
|
||||||
|
// Write crc to MAT along with other data, or just tack on to the beginning or end
|
||||||
persistentStore.access_start();
|
persistentStore.access_start();
|
||||||
const bool status = persistentStore.write_data(pos, (uint8_t *)&ubl.z_values, sizeof(ubl.z_values), &crc);
|
const bool status = persistentStore.write_data(pos, (uint8_t *)&ubl.z_values, sizeof(ubl.z_values), &crc);
|
||||||
persistentStore.access_finish();
|
persistentStore.access_finish();
|
||||||
|
|
||||||
if (status)
|
if (status) SERIAL_ECHOPGM("?Unable to save mesh data.\n");
|
||||||
SERIAL_PROTOCOLPGM("?Unable to save mesh data.\n");
|
else CHITCHAT_ECHOLNPAIR("Mesh saved in slot ", slot);
|
||||||
|
|
||||||
// Write crc to MAT along with other data, or just tack on to the beginning or end
|
|
||||||
|
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
|
||||||
if (!status)
|
|
||||||
SERIAL_PROTOCOLLNPAIR("Mesh saved in slot ", slot);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#else
|
#else
|
||||||
|
|
||||||
|
@ -1865,9 +1872,7 @@ void MarlinSettings::postprocess() {
|
||||||
const int16_t a = settings.calc_num_meshes();
|
const int16_t a = settings.calc_num_meshes();
|
||||||
|
|
||||||
if (!WITHIN(slot, 0, a - 1)) {
|
if (!WITHIN(slot, 0, a - 1)) {
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
ubl_invalid_slot(a);
|
||||||
ubl_invalid_slot(a);
|
|
||||||
#endif
|
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1879,13 +1884,9 @@ void MarlinSettings::postprocess() {
|
||||||
const uint16_t status = persistentStore.read_data(pos, dest, sizeof(ubl.z_values), &crc);
|
const uint16_t status = persistentStore.read_data(pos, dest, sizeof(ubl.z_values), &crc);
|
||||||
persistentStore.access_finish();
|
persistentStore.access_finish();
|
||||||
|
|
||||||
if (status)
|
if (status) SERIAL_ECHOPGM("?Unable to load mesh data.\n");
|
||||||
SERIAL_PROTOCOLPGM("?Unable to load mesh data.\n");
|
else CHITCHAT_ECHOLNPAIR("Mesh loaded from slot ", slot);
|
||||||
|
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
|
||||||
else
|
|
||||||
SERIAL_PROTOCOLLNPAIR("Mesh loaded from slot ", slot);
|
|
||||||
#endif
|
|
||||||
EEPROM_FINISH();
|
EEPROM_FINISH();
|
||||||
|
|
||||||
#else
|
#else
|
||||||
|
@ -1903,10 +1904,7 @@ void MarlinSettings::postprocess() {
|
||||||
#else // !EEPROM_SETTINGS
|
#else // !EEPROM_SETTINGS
|
||||||
|
|
||||||
bool MarlinSettings::save(PORTARG_SOLO) {
|
bool MarlinSettings::save(PORTARG_SOLO) {
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
CHITCHAT_ERROR_MSG_P(port, "EEPROM disabled");
|
||||||
SERIAL_ERROR_START_P(port);
|
|
||||||
SERIAL_ERRORLNPGM_P(port, "EEPROM disabled");
|
|
||||||
#endif
|
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -2177,15 +2175,15 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
|
|
||||||
postprocess();
|
postprocess();
|
||||||
|
|
||||||
#if ENABLED(EEPROM_CHITCHAT)
|
CHITCHAT_ECHO_START_P(port);
|
||||||
SERIAL_ECHO_START_P(port);
|
CHITCHAT_ECHOLNPGM_P(port, "Hardcoded Default Settings Loaded");
|
||||||
SERIAL_ECHOLNPGM_P(port, "Hardcoded Default Settings Loaded");
|
|
||||||
#endif
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#if DISABLED(DISABLE_M503)
|
#if DISABLED(DISABLE_M503)
|
||||||
|
|
||||||
#define CONFIG_ECHO_START do{ if (!forReplay) SERIAL_ECHO_START_P(port); }while(0)
|
#define CONFIG_ECHO_START() do{ if (!forReplay) SERIAL_ECHO_START_P(port); }while(0)
|
||||||
|
#define CONFIG_ECHO_MSG(STR) do{ CONFIG_ECHO_START(); SERIAL_ECHOLNPGM_P(port, STR); }while(0)
|
||||||
|
#define CONFIG_ECHO_HEADING(STR) do{ if (!forReplay) { CONFIG_ECHO_START(); SERIAL_ECHOLNPGM_P(port, STR); } }while(0)
|
||||||
|
|
||||||
#if HAS_TRINAMIC
|
#if HAS_TRINAMIC
|
||||||
void say_M906(PORTARG_SOLO) { SERIAL_ECHOPGM_P(port, " M906"); }
|
void say_M906(PORTARG_SOLO) { SERIAL_ECHOPGM_P(port, " M906"); }
|
||||||
|
@ -2234,7 +2232,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
/**
|
/**
|
||||||
* Announce current units, in case inches are being displayed
|
* Announce current units, in case inches are being displayed
|
||||||
*/
|
*/
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
#if ENABLED(INCH_MODE_SUPPORT)
|
#if ENABLED(INCH_MODE_SUPPORT)
|
||||||
SERIAL_ECHOPGM_P(port, " G2");
|
SERIAL_ECHOPGM_P(port, " G2");
|
||||||
SERIAL_CHAR_P(port, parser.linear_unit_factor == 1.0 ? '1' : '0');
|
SERIAL_CHAR_P(port, parser.linear_unit_factor == 1.0 ? '1' : '0');
|
||||||
|
@ -2250,7 +2248,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
|
|
||||||
// Temperature units - for Ultipanel temperature options
|
// Temperature units - for Ultipanel temperature options
|
||||||
|
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
|
#if ENABLED(TEMPERATURE_UNITS_SUPPORT)
|
||||||
SERIAL_ECHOPGM_P(port, " M149 ");
|
SERIAL_ECHOPGM_P(port, " M149 ");
|
||||||
SERIAL_CHAR_P(port, parser.temp_units_code());
|
SERIAL_CHAR_P(port, parser.temp_units_code());
|
||||||
|
@ -2270,7 +2268,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
* Volumetric extrusion M200
|
* Volumetric extrusion M200
|
||||||
*/
|
*/
|
||||||
if (!forReplay) {
|
if (!forReplay) {
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPGM_P(port, "Filament settings:");
|
SERIAL_ECHOPGM_P(port, "Filament settings:");
|
||||||
if (parser.volumetric_enabled)
|
if (parser.volumetric_enabled)
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
|
@ -2278,27 +2276,27 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
SERIAL_ECHOLNPGM_P(port, " Disabled");
|
SERIAL_ECHOLNPGM_P(port, " Disabled");
|
||||||
}
|
}
|
||||||
|
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M200 D", LINEAR_UNIT(planner.filament_size[0]));
|
SERIAL_ECHOPAIR_P(port, " M200 D", LINEAR_UNIT(planner.filament_size[0]));
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
#if EXTRUDERS > 1
|
#if EXTRUDERS > 1
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M200 T1 D", LINEAR_UNIT(planner.filament_size[1]));
|
SERIAL_ECHOPAIR_P(port, " M200 T1 D", LINEAR_UNIT(planner.filament_size[1]));
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
#if EXTRUDERS > 2
|
#if EXTRUDERS > 2
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M200 T2 D", LINEAR_UNIT(planner.filament_size[2]));
|
SERIAL_ECHOPAIR_P(port, " M200 T2 D", LINEAR_UNIT(planner.filament_size[2]));
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
#if EXTRUDERS > 3
|
#if EXTRUDERS > 3
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M200 T3 D", LINEAR_UNIT(planner.filament_size[3]));
|
SERIAL_ECHOPAIR_P(port, " M200 T3 D", LINEAR_UNIT(planner.filament_size[3]));
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
#if EXTRUDERS > 4
|
#if EXTRUDERS > 4
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M200 T4 D", LINEAR_UNIT(planner.filament_size[4]));
|
SERIAL_ECHOPAIR_P(port, " M200 T4 D", LINEAR_UNIT(planner.filament_size[4]));
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
#if EXTRUDERS > 5
|
#if EXTRUDERS > 5
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M200 T5 D", LINEAR_UNIT(planner.filament_size[5]));
|
SERIAL_ECHOPAIR_P(port, " M200 T5 D", LINEAR_UNIT(planner.filament_size[5]));
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
#endif // EXTRUDERS > 5
|
#endif // EXTRUDERS > 5
|
||||||
|
@ -2307,18 +2305,13 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif // EXTRUDERS > 2
|
#endif // EXTRUDERS > 2
|
||||||
#endif // EXTRUDERS > 1
|
#endif // EXTRUDERS > 1
|
||||||
|
|
||||||
if (!parser.volumetric_enabled) {
|
if (!parser.volumetric_enabled)
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_MSG(" M200 D0");
|
||||||
SERIAL_ECHOLNPGM_P(port, " M200 D0");
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif // !NO_VOLUMETRICS
|
#endif // !NO_VOLUMETRICS
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Steps per unit:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Steps per unit:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M92 X", LINEAR_UNIT(planner.settings.axis_steps_per_mm[X_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " M92 X", LINEAR_UNIT(planner.settings.axis_steps_per_mm[X_AXIS]));
|
||||||
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(planner.settings.axis_steps_per_mm[Y_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(planner.settings.axis_steps_per_mm[Y_AXIS]));
|
||||||
SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(planner.settings.axis_steps_per_mm[Z_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(planner.settings.axis_steps_per_mm[Z_AXIS]));
|
||||||
|
@ -2327,18 +2320,15 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
#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++) {
|
||||||
SERIAL_ECHOPAIR_P(port, " M92 T", (int)i);
|
SERIAL_ECHOPAIR_P(port, " M92 T", (int)i);
|
||||||
SERIAL_ECHOLNPAIR_P(port, " E", VOLUMETRIC_UNIT(planner.settings.axis_steps_per_mm[E_AXIS + i]));
|
SERIAL_ECHOLNPAIR_P(port, " E", VOLUMETRIC_UNIT(planner.settings.axis_steps_per_mm[E_AXIS + i]));
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Maximum feedrates (units/s):");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Maximum feedrates (units/s):");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M203 X", LINEAR_UNIT(planner.settings.max_feedrate_mm_s[X_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " M203 X", LINEAR_UNIT(planner.settings.max_feedrate_mm_s[X_AXIS]));
|
||||||
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(planner.settings.max_feedrate_mm_s[Y_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(planner.settings.max_feedrate_mm_s[Y_AXIS]));
|
||||||
SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(planner.settings.max_feedrate_mm_s[Z_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(planner.settings.max_feedrate_mm_s[Z_AXIS]));
|
||||||
|
@ -2347,18 +2337,15 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
#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++) {
|
||||||
SERIAL_ECHOPAIR_P(port, " M203 T", (int)i);
|
SERIAL_ECHOPAIR_P(port, " M203 T", (int)i);
|
||||||
SERIAL_ECHOLNPAIR_P(port, " E", VOLUMETRIC_UNIT(planner.settings.max_feedrate_mm_s[E_AXIS + i]));
|
SERIAL_ECHOLNPAIR_P(port, " E", VOLUMETRIC_UNIT(planner.settings.max_feedrate_mm_s[E_AXIS + i]));
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Maximum Acceleration (units/s2):");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Maximum Acceleration (units/s2):");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M201 X", LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[X_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " M201 X", LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[X_AXIS]));
|
||||||
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[Y_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[Y_AXIS]));
|
||||||
SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[Z_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(planner.settings.max_acceleration_mm_per_s2[Z_AXIS]));
|
||||||
|
@ -2367,24 +2354,21 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
#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++) {
|
||||||
SERIAL_ECHOPAIR_P(port, " M201 T", (int)i);
|
SERIAL_ECHOPAIR_P(port, " M201 T", (int)i);
|
||||||
SERIAL_ECHOLNPAIR_P(port, " E", VOLUMETRIC_UNIT(planner.settings.max_acceleration_mm_per_s2[E_AXIS + i]));
|
SERIAL_ECHOLNPAIR_P(port, " E", VOLUMETRIC_UNIT(planner.settings.max_acceleration_mm_per_s2[E_AXIS + i]));
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Acceleration (units/s2): P<print_accel> R<retract_accel> T<travel_accel>");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Acceleration (units/s2): P<print_accel> R<retract_accel> T<travel_accel>");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M204 P", LINEAR_UNIT(planner.settings.acceleration));
|
SERIAL_ECHOPAIR_P(port, " M204 P", LINEAR_UNIT(planner.settings.acceleration));
|
||||||
SERIAL_ECHOPAIR_P(port, " R", LINEAR_UNIT(planner.settings.retract_acceleration));
|
SERIAL_ECHOPAIR_P(port, " R", LINEAR_UNIT(planner.settings.retract_acceleration));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " T", LINEAR_UNIT(planner.settings.travel_acceleration));
|
SERIAL_ECHOLNPAIR_P(port, " T", LINEAR_UNIT(planner.settings.travel_acceleration));
|
||||||
|
|
||||||
if (!forReplay) {
|
if (!forReplay) {
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPGM_P(port, "Advanced: B<min_segment_time_us> S<min_feedrate> T<min_travel_feedrate>");
|
SERIAL_ECHOPGM_P(port, "Advanced: B<min_segment_time_us> S<min_feedrate> T<min_travel_feedrate>");
|
||||||
#if ENABLED(JUNCTION_DEVIATION)
|
#if ENABLED(JUNCTION_DEVIATION)
|
||||||
SERIAL_ECHOPGM_P(port, " J<junc_dev>");
|
SERIAL_ECHOPGM_P(port, " J<junc_dev>");
|
||||||
|
@ -2397,7 +2381,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
}
|
}
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M205 B", LINEAR_UNIT(planner.settings.min_segment_time_us));
|
SERIAL_ECHOPAIR_P(port, " M205 B", LINEAR_UNIT(planner.settings.min_segment_time_us));
|
||||||
SERIAL_ECHOPAIR_P(port, " S", LINEAR_UNIT(planner.settings.min_feedrate_mm_s));
|
SERIAL_ECHOPAIR_P(port, " S", LINEAR_UNIT(planner.settings.min_feedrate_mm_s));
|
||||||
SERIAL_ECHOPAIR_P(port, " T", LINEAR_UNIT(planner.settings.min_travel_feedrate_mm_s));
|
SERIAL_ECHOPAIR_P(port, " T", LINEAR_UNIT(planner.settings.min_travel_feedrate_mm_s));
|
||||||
|
@ -2417,29 +2401,21 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
SERIAL_EOL_P(port);
|
SERIAL_EOL_P(port);
|
||||||
|
|
||||||
#if HAS_M206_COMMAND
|
#if HAS_M206_COMMAND
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Home offset:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Home offset:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M206 X", LINEAR_UNIT(home_offset[X_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " M206 X", LINEAR_UNIT(home_offset[X_AXIS]));
|
||||||
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(home_offset[Y_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(home_offset[Y_AXIS]));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " Z", LINEAR_UNIT(home_offset[Z_AXIS]));
|
SERIAL_ECHOLNPAIR_P(port, " Z", LINEAR_UNIT(home_offset[Z_AXIS]));
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if HAS_HOTEND_OFFSET
|
#if HAS_HOTEND_OFFSET
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Hotend offsets:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Hotend offsets:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
for (uint8_t e = 1; e < HOTENDS; e++) {
|
for (uint8_t e = 1; e < HOTENDS; e++) {
|
||||||
SERIAL_ECHOPAIR_P(port, " M218 T", (int)e);
|
SERIAL_ECHOPAIR_P(port, " M218 T", (int)e);
|
||||||
SERIAL_ECHOPAIR_P(port, " X", LINEAR_UNIT(hotend_offset[X_AXIS][e]));
|
SERIAL_ECHOPAIR_P(port, " X", LINEAR_UNIT(hotend_offset[X_AXIS][e]));
|
||||||
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(hotend_offset[Y_AXIS][e]));
|
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(hotend_offset[Y_AXIS][e]));
|
||||||
SERIAL_ECHO_P(port, " Z");
|
SERIAL_ECHOLNPAIR_F_P(port, " Z", LINEAR_UNIT(hotend_offset[Z_AXIS][e]), 3);
|
||||||
SERIAL_ECHO_F_P(port, LINEAR_UNIT(hotend_offset[Z_AXIS][e]), 3);
|
|
||||||
SERIAL_EOL_P(port);
|
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
@ -2450,29 +2426,23 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
|
|
||||||
#if ENABLED(MESH_BED_LEVELING)
|
#if ENABLED(MESH_BED_LEVELING)
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Mesh Bed Leveling:");
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOLNPGM_P(port, "Mesh Bed Leveling:");
|
|
||||||
}
|
|
||||||
|
|
||||||
#elif ENABLED(AUTO_BED_LEVELING_UBL)
|
#elif ENABLED(AUTO_BED_LEVELING_UBL)
|
||||||
|
|
||||||
if (!forReplay) {
|
if (!forReplay) {
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
ubl.echo_name();
|
ubl.echo_name();
|
||||||
SERIAL_ECHOLNPGM_P(port, ":");
|
SERIAL_ECHOLNPGM_P(port, ":");
|
||||||
}
|
}
|
||||||
|
|
||||||
#elif HAS_ABL
|
#elif HAS_ABL
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Auto Bed Leveling:");
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOLNPGM_P(port, "Auto Bed Leveling:");
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M420 S", planner.leveling_active ? 1 : 0);
|
SERIAL_ECHOPAIR_P(port, " M420 S", planner.leveling_active ? 1 : 0);
|
||||||
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
#if ENABLED(ENABLE_LEVELING_FADE_HEIGHT)
|
||||||
SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(planner.z_fade_height));
|
SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(planner.z_fade_height));
|
||||||
|
@ -2484,12 +2454,10 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
if (leveling_is_valid()) {
|
if (leveling_is_valid()) {
|
||||||
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();
|
||||||
SERIAL_ECHOPAIR_P(port, " G29 S3 X", (int)px + 1);
|
SERIAL_ECHOPAIR_P(port, " G29 S3 X", (int)px + 1);
|
||||||
SERIAL_ECHOPAIR_P(port, " Y", (int)py + 1);
|
SERIAL_ECHOPAIR_P(port, " Y", (int)py + 1);
|
||||||
SERIAL_ECHOPGM_P(port, " Z");
|
SERIAL_ECHOLNPAIR_F_P(port, " Z", LINEAR_UNIT(mbl.z_values[px][py]), 5);
|
||||||
SERIAL_ECHO_F_P(port, LINEAR_UNIT(mbl.z_values[px][py]), 5);
|
|
||||||
SERIAL_EOL_P(port);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -2504,19 +2472,17 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
SERIAL_ECHOLNPGM_P(port, " meshes.\n");
|
SERIAL_ECHOLNPGM_P(port, " meshes.\n");
|
||||||
}
|
}
|
||||||
|
|
||||||
// ubl.report_current_mesh(PORTVAR_SOLO); // This is too verbose for large mesh's. A better (more terse)
|
//ubl.report_current_mesh(PORTVAR_SOLO); // This is too verbose for large meshes. A better (more terse)
|
||||||
// solution needs to be found.
|
// solution needs to be found.
|
||||||
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
#elif ENABLED(AUTO_BED_LEVELING_BILINEAR)
|
||||||
|
|
||||||
if (leveling_is_valid()) {
|
if (leveling_is_valid()) {
|
||||||
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();
|
||||||
SERIAL_ECHOPAIR_P(port, " G29 W I", (int)px);
|
SERIAL_ECHOPAIR_P(port, " G29 W I", (int)px);
|
||||||
SERIAL_ECHOPAIR_P(port, " J", (int)py);
|
SERIAL_ECHOPAIR_P(port, " J", (int)py);
|
||||||
SERIAL_ECHOPGM_P(port, " Z");
|
SERIAL_ECHOLNPAIR_F_P(port, " Z", LINEAR_UNIT(z_values[px][py]), 5);
|
||||||
SERIAL_ECHO_F_P(port, LINEAR_UNIT(z_values[px][py]), 5);
|
|
||||||
SERIAL_EOL_P(port);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -2527,10 +2493,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
|
|
||||||
#if HAS_SERVOS && ENABLED(EDITABLE_SERVO_ANGLES)
|
#if HAS_SERVOS && ENABLED(EDITABLE_SERVO_ANGLES)
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Servo Angles:");
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOLNPGM_P(port, "Servo Angles:");
|
|
||||||
}
|
|
||||||
for (uint8_t i = 0; i < NUM_SERVOS; i++) {
|
for (uint8_t i = 0; i < NUM_SERVOS; i++) {
|
||||||
switch (i) {
|
switch (i) {
|
||||||
#if ENABLED(SWITCHING_EXTRUDER)
|
#if ENABLED(SWITCHING_EXTRUDER)
|
||||||
|
@ -2543,7 +2506,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#elif defined(Z_SERVO_ANGLES) && defined(Z_PROBE_SERVO_NR)
|
#elif defined(Z_SERVO_ANGLES) && defined(Z_PROBE_SERVO_NR)
|
||||||
case Z_PROBE_SERVO_NR:
|
case Z_PROBE_SERVO_NR:
|
||||||
#endif
|
#endif
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M281 P", int(i));
|
SERIAL_ECHOPAIR_P(port, " M281 P", int(i));
|
||||||
SERIAL_ECHOPAIR_P(port, " L", servo_angles[i][0]);
|
SERIAL_ECHOPAIR_P(port, " L", servo_angles[i][0]);
|
||||||
SERIAL_ECHOPAIR_P(port, " U", servo_angles[i][1]);
|
SERIAL_ECHOPAIR_P(port, " U", servo_angles[i][1]);
|
||||||
|
@ -2556,11 +2519,8 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
|
|
||||||
#if HAS_SCARA_OFFSET
|
#if HAS_SCARA_OFFSET
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("SCARA settings: S<seg-per-sec> P<theta-psi-offset> T<theta-offset>");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "SCARA settings: S<seg-per-sec> P<theta-psi-offset> T<theta-offset>");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M665 S", delta_segments_per_second);
|
SERIAL_ECHOPAIR_P(port, " M665 S", delta_segments_per_second);
|
||||||
SERIAL_ECHOPAIR_P(port, " P", scara_home_offset[A_AXIS]);
|
SERIAL_ECHOPAIR_P(port, " P", scara_home_offset[A_AXIS]);
|
||||||
SERIAL_ECHOPAIR_P(port, " T", scara_home_offset[B_AXIS]);
|
SERIAL_ECHOPAIR_P(port, " T", scara_home_offset[B_AXIS]);
|
||||||
|
@ -2569,19 +2529,14 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
|
|
||||||
#elif ENABLED(DELTA)
|
#elif ENABLED(DELTA)
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Endstop adjustment:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Endstop adjustment:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M666 X", LINEAR_UNIT(delta_endstop_adj[X_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " M666 X", LINEAR_UNIT(delta_endstop_adj[X_AXIS]));
|
||||||
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(delta_endstop_adj[Y_AXIS]));
|
SERIAL_ECHOPAIR_P(port, " Y", LINEAR_UNIT(delta_endstop_adj[Y_AXIS]));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " Z", LINEAR_UNIT(delta_endstop_adj[Z_AXIS]));
|
SERIAL_ECHOLNPAIR_P(port, " Z", LINEAR_UNIT(delta_endstop_adj[Z_AXIS]));
|
||||||
if (!forReplay) {
|
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_HEADING("Delta settings: L<diagonal_rod> R<radius> H<height> S<segments_per_s> B<calibration radius> XYZ<tower angle corrections>");
|
||||||
SERIAL_ECHOLNPGM_P(port, "Delta settings: L<diagonal_rod> R<radius> H<height> S<segments_per_s> B<calibration radius> XYZ<tower angle corrections>");
|
CONFIG_ECHO_START();
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M665 L", LINEAR_UNIT(delta_diagonal_rod));
|
SERIAL_ECHOPAIR_P(port, " M665 L", LINEAR_UNIT(delta_diagonal_rod));
|
||||||
SERIAL_ECHOPAIR_P(port, " R", LINEAR_UNIT(delta_radius));
|
SERIAL_ECHOPAIR_P(port, " R", LINEAR_UNIT(delta_radius));
|
||||||
SERIAL_ECHOPAIR_P(port, " H", LINEAR_UNIT(delta_height));
|
SERIAL_ECHOPAIR_P(port, " H", LINEAR_UNIT(delta_height));
|
||||||
|
@ -2594,11 +2549,8 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
|
|
||||||
#elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS)
|
#elif ENABLED(X_DUAL_ENDSTOPS) || ENABLED(Y_DUAL_ENDSTOPS) || ENABLED(Z_DUAL_ENDSTOPS)
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Endstop adjustment:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Endstop adjustment:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPGM_P(port, " M666");
|
SERIAL_ECHOPGM_P(port, " M666");
|
||||||
#if ENABLED(X_DUAL_ENDSTOPS)
|
#if ENABLED(X_DUAL_ENDSTOPS)
|
||||||
SERIAL_ECHOPAIR_P(port, " X", LINEAR_UNIT(endstops.x2_endstop_adj));
|
SERIAL_ECHOPAIR_P(port, " X", LINEAR_UNIT(endstops.x2_endstop_adj));
|
||||||
|
@ -2608,7 +2560,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif
|
#endif
|
||||||
#if ENABLED(Z_TRIPLE_ENDSTOPS)
|
#if ENABLED(Z_TRIPLE_ENDSTOPS)
|
||||||
SERIAL_ECHOLNPAIR_P(port, "S1 Z", LINEAR_UNIT(endstops.z2_endstop_adj));
|
SERIAL_ECHOLNPAIR_P(port, "S1 Z", LINEAR_UNIT(endstops.z2_endstop_adj));
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M666 S2 Z", LINEAR_UNIT(endstops.z3_endstop_adj));
|
SERIAL_ECHOPAIR_P(port, " M666 S2 Z", LINEAR_UNIT(endstops.z3_endstop_adj));
|
||||||
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
#elif ENABLED(Z_DUAL_ENDSTOPS)
|
||||||
SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(endstops.z2_endstop_adj));
|
SERIAL_ECHOPAIR_P(port, " Z", LINEAR_UNIT(endstops.z2_endstop_adj));
|
||||||
|
@ -2619,12 +2571,9 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
|
|
||||||
#if HAS_LCD_MENU
|
#if HAS_LCD_MENU
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Material heatup parameters:");
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOLNPGM_P(port, "Material heatup parameters:");
|
|
||||||
}
|
|
||||||
for (uint8_t i = 0; i < COUNT(ui.preheat_hotend_temp); i++) {
|
for (uint8_t i = 0; i < COUNT(ui.preheat_hotend_temp); i++) {
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M145 S", (int)i);
|
SERIAL_ECHOPAIR_P(port, " M145 S", (int)i);
|
||||||
SERIAL_ECHOPAIR_P(port, " H", TEMP_UNIT(ui.preheat_hotend_temp[i]));
|
SERIAL_ECHOPAIR_P(port, " H", TEMP_UNIT(ui.preheat_hotend_temp[i]));
|
||||||
SERIAL_ECHOPAIR_P(port, " B", TEMP_UNIT(ui.preheat_bed_temp[i]));
|
SERIAL_ECHOPAIR_P(port, " B", TEMP_UNIT(ui.preheat_bed_temp[i]));
|
||||||
|
@ -2635,15 +2584,12 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
|
|
||||||
#if HAS_PID_HEATING
|
#if HAS_PID_HEATING
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("PID settings:");
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOLNPGM_P(port, "PID settings:");
|
|
||||||
}
|
|
||||||
#if ENABLED(PIDTEMP)
|
#if ENABLED(PIDTEMP)
|
||||||
#if HOTENDS > 1
|
#if HOTENDS > 1
|
||||||
if (forReplay) {
|
if (forReplay) {
|
||||||
HOTEND_LOOP() {
|
HOTEND_LOOP() {
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M301 E", e);
|
SERIAL_ECHOPAIR_P(port, " M301 E", e);
|
||||||
SERIAL_ECHOPAIR_P(port, " P", PID_PARAM(Kp, e));
|
SERIAL_ECHOPAIR_P(port, " P", PID_PARAM(Kp, e));
|
||||||
SERIAL_ECHOPAIR_P(port, " I", unscalePID_i(PID_PARAM(Ki, e)));
|
SERIAL_ECHOPAIR_P(port, " I", unscalePID_i(PID_PARAM(Ki, e)));
|
||||||
|
@ -2659,7 +2605,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif // HOTENDS > 1
|
#endif // HOTENDS > 1
|
||||||
// !forReplay || HOTENDS == 1
|
// !forReplay || HOTENDS == 1
|
||||||
{
|
{
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M301 P", PID_PARAM(Kp, 0)); // for compatibility with hosts, only echo values for E0
|
SERIAL_ECHOPAIR_P(port, " M301 P", PID_PARAM(Kp, 0)); // for compatibility with hosts, only echo values for E0
|
||||||
SERIAL_ECHOPAIR_P(port, " I", unscalePID_i(PID_PARAM(Ki, 0)));
|
SERIAL_ECHOPAIR_P(port, " I", unscalePID_i(PID_PARAM(Ki, 0)));
|
||||||
SERIAL_ECHOPAIR_P(port, " D", unscalePID_d(PID_PARAM(Kd, 0)));
|
SERIAL_ECHOPAIR_P(port, " D", unscalePID_d(PID_PARAM(Kd, 0)));
|
||||||
|
@ -2672,7 +2618,7 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif // PIDTEMP
|
#endif // PIDTEMP
|
||||||
|
|
||||||
#if ENABLED(PIDTEMPBED)
|
#if ENABLED(PIDTEMPBED)
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPAIR_P(port, " M304 P", thermalManager.bed_pid.Kp);
|
SERIAL_ECHOPAIR_P(port, " M304 P", thermalManager.bed_pid.Kp);
|
||||||
SERIAL_ECHOPAIR_P(port, " I", unscalePID_i(thermalManager.bed_pid.Ki));
|
SERIAL_ECHOPAIR_P(port, " I", unscalePID_i(thermalManager.bed_pid.Ki));
|
||||||
SERIAL_ECHOPAIR_P(port, " D", unscalePID_d(thermalManager.bed_pid.Kd));
|
SERIAL_ECHOPAIR_P(port, " D", unscalePID_d(thermalManager.bed_pid.Kd));
|
||||||
|
@ -2682,51 +2628,36 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif // PIDTEMP || PIDTEMPBED
|
#endif // PIDTEMP || PIDTEMPBED
|
||||||
|
|
||||||
#if HAS_LCD_CONTRAST
|
#if HAS_LCD_CONTRAST
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("LCD Contrast:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "LCD Contrast:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOLNPAIR_P(port, " M250 C", ui.contrast);
|
SERIAL_ECHOLNPAIR_P(port, " M250 C", ui.contrast);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if ENABLED(POWER_LOSS_RECOVERY)
|
#if ENABLED(POWER_LOSS_RECOVERY)
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Power-Loss Recovery:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Power-Loss Recovery:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOLNPAIR_P(port, " M413 S", int(recovery.enabled));
|
SERIAL_ECHOLNPAIR_P(port, " M413 S", int(recovery.enabled));
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if ENABLED(FWRETRACT)
|
#if ENABLED(FWRETRACT)
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Retract: S<length> F<units/m> Z<lift>");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Retract: S<length> F<units/m> Z<lift>");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M207 S", LINEAR_UNIT(fwretract.settings.retract_length));
|
SERIAL_ECHOPAIR_P(port, " M207 S", LINEAR_UNIT(fwretract.settings.retract_length));
|
||||||
SERIAL_ECHOPAIR_P(port, " W", LINEAR_UNIT(fwretract.settings.swap_retract_length));
|
SERIAL_ECHOPAIR_P(port, " W", LINEAR_UNIT(fwretract.settings.swap_retract_length));
|
||||||
SERIAL_ECHOPAIR_P(port, " F", MMS_TO_MMM(LINEAR_UNIT(fwretract.settings.retract_feedrate_mm_s)));
|
SERIAL_ECHOPAIR_P(port, " F", MMS_TO_MMM(LINEAR_UNIT(fwretract.settings.retract_feedrate_mm_s)));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " Z", LINEAR_UNIT(fwretract.settings.retract_zraise));
|
SERIAL_ECHOLNPAIR_P(port, " Z", LINEAR_UNIT(fwretract.settings.retract_zraise));
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Recover: S<length> F<units/m>");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Recover: S<length> F<units/m>");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M208 S", LINEAR_UNIT(fwretract.settings.retract_recover_length));
|
SERIAL_ECHOPAIR_P(port, " M208 S", LINEAR_UNIT(fwretract.settings.retract_recover_length));
|
||||||
SERIAL_ECHOPAIR_P(port, " W", LINEAR_UNIT(fwretract.settings.swap_retract_recover_length));
|
SERIAL_ECHOPAIR_P(port, " W", LINEAR_UNIT(fwretract.settings.swap_retract_recover_length));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " F", MMS_TO_MMM(LINEAR_UNIT(fwretract.settings.retract_recover_feedrate_mm_s)));
|
SERIAL_ECHOLNPAIR_P(port, " F", MMS_TO_MMM(LINEAR_UNIT(fwretract.settings.retract_recover_feedrate_mm_s)));
|
||||||
|
|
||||||
#if ENABLED(FWRETRACT_AUTORETRACT)
|
#if ENABLED(FWRETRACT_AUTORETRACT)
|
||||||
|
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Auto-Retract: S=0 to disable, 1 to interpret E-only moves as retract/recover");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Auto-Retract: S=0 to disable, 1 to interpret E-only moves as retract/recover");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
SERIAL_ECHOLNPAIR_P(port, " M209 S", fwretract.autoretract_enabled ? 1 : 0);
|
SERIAL_ECHOLNPAIR_P(port, " M209 S", fwretract.autoretract_enabled ? 1 : 0);
|
||||||
|
|
||||||
#endif // FWRETRACT_AUTORETRACT
|
#endif // FWRETRACT_AUTORETRACT
|
||||||
|
@ -2738,11 +2669,11 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
*/
|
*/
|
||||||
#if HAS_BED_PROBE
|
#if HAS_BED_PROBE
|
||||||
if (!forReplay) {
|
if (!forReplay) {
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOPGM_P(port, "Z-Probe Offset");
|
SERIAL_ECHOPGM_P(port, "Z-Probe Offset");
|
||||||
SAY_UNITS_P(port, true);
|
SAY_UNITS_P(port, true);
|
||||||
}
|
}
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPAIR_P(port, " M851 Z", LINEAR_UNIT(zprobe_zoffset));
|
SERIAL_ECHOLNPAIR_P(port, " M851 Z", LINEAR_UNIT(zprobe_zoffset));
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
@ -2750,23 +2681,14 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
* Bed Skew Correction
|
* Bed Skew Correction
|
||||||
*/
|
*/
|
||||||
#if ENABLED(SKEW_CORRECTION_GCODE)
|
#if ENABLED(SKEW_CORRECTION_GCODE)
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Skew Factor: ");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Skew Factor: ");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
#if ENABLED(SKEW_CORRECTION_FOR_Z)
|
#if ENABLED(SKEW_CORRECTION_FOR_Z)
|
||||||
SERIAL_ECHOPGM_P(port, " M852 I");
|
SERIAL_ECHOPAIR_F_P(port, " M852 I", LINEAR_UNIT(planner.skew_factor.xy), 6);
|
||||||
SERIAL_ECHO_F_P(port, LINEAR_UNIT(planner.skew_factor.xy), 6);
|
SERIAL_ECHOPAIR_F_P(port, " J", LINEAR_UNIT(planner.skew_factor.xz), 6);
|
||||||
SERIAL_ECHOPGM_P(port, " J");
|
SERIAL_ECHOLNPAIR_F_P(port, " K", LINEAR_UNIT(planner.skew_factor.yz), 6);
|
||||||
SERIAL_ECHO_F_P(port, LINEAR_UNIT(planner.skew_factor.xz), 6);
|
|
||||||
SERIAL_ECHOPGM_P(port, " K");
|
|
||||||
SERIAL_ECHO_F_P(port, LINEAR_UNIT(planner.skew_factor.yz), 6);
|
|
||||||
SERIAL_EOL_P(port);
|
|
||||||
#else
|
#else
|
||||||
SERIAL_ECHOPGM_P(port, " M852 S");
|
SERIAL_ECHOLNPAIR_F_P(port, " M852 S", LINEAR_UNIT(planner.skew_factor.xy), 6);
|
||||||
SERIAL_ECHO_F_P(port, LINEAR_UNIT(planner.skew_factor.xy), 6);
|
|
||||||
SERIAL_EOL_P(port);
|
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
@ -2775,11 +2697,8 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
/**
|
/**
|
||||||
* TMC stepper driver current
|
* TMC stepper driver current
|
||||||
*/
|
*/
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Stepper driver current:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Stepper driver current:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
#if AXIS_IS_TMC(X) || AXIS_IS_TMC(Y) || AXIS_IS_TMC(Z)
|
#if AXIS_IS_TMC(X) || AXIS_IS_TMC(Y) || AXIS_IS_TMC(Z)
|
||||||
say_M906(PORTVAR_SOLO);
|
say_M906(PORTVAR_SOLO);
|
||||||
#endif
|
#endif
|
||||||
|
@ -2848,11 +2767,8 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
* TMC Hybrid Threshold
|
* TMC Hybrid Threshold
|
||||||
*/
|
*/
|
||||||
#if ENABLED(HYBRID_THRESHOLD)
|
#if ENABLED(HYBRID_THRESHOLD)
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Hybrid Threshold:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Hybrid Threshold:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
#if AXIS_HAS_STEALTHCHOP(X) || AXIS_HAS_STEALTHCHOP(Y) || AXIS_HAS_STEALTHCHOP(Z)
|
#if AXIS_HAS_STEALTHCHOP(X) || AXIS_HAS_STEALTHCHOP(Y) || AXIS_HAS_STEALTHCHOP(Z)
|
||||||
say_M913(PORTVAR_SOLO);
|
say_M913(PORTVAR_SOLO);
|
||||||
#endif
|
#endif
|
||||||
|
@ -2923,11 +2839,8 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
* TMC Sensorless homing thresholds
|
* TMC Sensorless homing thresholds
|
||||||
*/
|
*/
|
||||||
#if USE_SENSORLESS
|
#if USE_SENSORLESS
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("TMC2130 StallGuard threshold:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "TMC2130 StallGuard threshold:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
#if X_SENSORLESS || Y_SENSORLESS || Z_SENSORLESS
|
#if X_SENSORLESS || Y_SENSORLESS || Z_SENSORLESS
|
||||||
say_M914(PORTVAR_SOLO);
|
say_M914(PORTVAR_SOLO);
|
||||||
#if X_SENSORLESS
|
#if X_SENSORLESS
|
||||||
|
@ -2975,12 +2888,8 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
* Linear Advance
|
* Linear Advance
|
||||||
*/
|
*/
|
||||||
#if ENABLED(LIN_ADVANCE)
|
#if ENABLED(LIN_ADVANCE)
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Linear Advance:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Linear Advance:");
|
|
||||||
}
|
|
||||||
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
#if EXTRUDERS < 2
|
#if EXTRUDERS < 2
|
||||||
SERIAL_ECHOLNPAIR_P(port, " M900 K", planner.extruder_advance_K[0]);
|
SERIAL_ECHOLNPAIR_P(port, " M900 K", planner.extruder_advance_K[0]);
|
||||||
#else
|
#else
|
||||||
|
@ -2992,11 +2901,8 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if HAS_MOTOR_CURRENT_PWM
|
#if HAS_MOTOR_CURRENT_PWM
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_HEADING("Stepper motor currents:");
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Stepper motor currents:");
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
}
|
|
||||||
SERIAL_ECHOPAIR_P(port, " M907 X", stepper.motor_current_setting[0]);
|
SERIAL_ECHOPAIR_P(port, " M907 X", stepper.motor_current_setting[0]);
|
||||||
SERIAL_ECHOPAIR_P(port, " Z", stepper.motor_current_setting[1]);
|
SERIAL_ECHOPAIR_P(port, " Z", stepper.motor_current_setting[1]);
|
||||||
SERIAL_ECHOPAIR_P(port, " E", stepper.motor_current_setting[2]);
|
SERIAL_ECHOPAIR_P(port, " E", stepper.motor_current_setting[2]);
|
||||||
|
@ -3007,11 +2913,8 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
* Advanced Pause filament load & unload lengths
|
* Advanced Pause filament load & unload lengths
|
||||||
*/
|
*/
|
||||||
#if ENABLED(ADVANCED_PAUSE_FEATURE)
|
#if ENABLED(ADVANCED_PAUSE_FEATURE)
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_HEADING("Filament load/unload lengths:");
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Filament load/unload lengths:");
|
|
||||||
}
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
#if EXTRUDERS == 1
|
#if EXTRUDERS == 1
|
||||||
say_M603(PORTVAR_SOLO);
|
say_M603(PORTVAR_SOLO);
|
||||||
SERIAL_ECHOPAIR_P(port, "L", LINEAR_UNIT(fc_settings[0].load_length));
|
SERIAL_ECHOPAIR_P(port, "L", LINEAR_UNIT(fc_settings[0].load_length));
|
||||||
|
@ -3020,27 +2923,27 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
say_M603(PORTVAR_SOLO);
|
say_M603(PORTVAR_SOLO);
|
||||||
SERIAL_ECHOPAIR_P(port, "T0 L", LINEAR_UNIT(fc_settings[0].load_length));
|
SERIAL_ECHOPAIR_P(port, "T0 L", LINEAR_UNIT(fc_settings[0].load_length));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[0].unload_length));
|
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[0].unload_length));
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
say_M603(PORTVAR_SOLO);
|
say_M603(PORTVAR_SOLO);
|
||||||
SERIAL_ECHOPAIR_P(port, "T1 L", LINEAR_UNIT(fc_settings[1].load_length));
|
SERIAL_ECHOPAIR_P(port, "T1 L", LINEAR_UNIT(fc_settings[1].load_length));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[1].unload_length));
|
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[1].unload_length));
|
||||||
#if EXTRUDERS > 2
|
#if EXTRUDERS > 2
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
say_M603(PORTVAR_SOLO);
|
say_M603(PORTVAR_SOLO);
|
||||||
SERIAL_ECHOPAIR_P(port, "T2 L", LINEAR_UNIT(fc_settings[2].load_length));
|
SERIAL_ECHOPAIR_P(port, "T2 L", LINEAR_UNIT(fc_settings[2].load_length));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[2].unload_length));
|
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[2].unload_length));
|
||||||
#if EXTRUDERS > 3
|
#if EXTRUDERS > 3
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
say_M603(PORTVAR_SOLO);
|
say_M603(PORTVAR_SOLO);
|
||||||
SERIAL_ECHOPAIR_P(port, "T3 L", LINEAR_UNIT(fc_settings[3].load_length));
|
SERIAL_ECHOPAIR_P(port, "T3 L", LINEAR_UNIT(fc_settings[3].load_length));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[3].unload_length));
|
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[3].unload_length));
|
||||||
#if EXTRUDERS > 4
|
#if EXTRUDERS > 4
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
say_M603(PORTVAR_SOLO);
|
say_M603(PORTVAR_SOLO);
|
||||||
SERIAL_ECHOPAIR_P(port, "T4 L", LINEAR_UNIT(fc_settings[4].load_length));
|
SERIAL_ECHOPAIR_P(port, "T4 L", LINEAR_UNIT(fc_settings[4].load_length));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[4].unload_length));
|
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[4].unload_length));
|
||||||
#if EXTRUDERS > 5
|
#if EXTRUDERS > 5
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_START();
|
||||||
say_M603(PORTVAR_SOLO);
|
say_M603(PORTVAR_SOLO);
|
||||||
SERIAL_ECHOPAIR_P(port, "T5 L", LINEAR_UNIT(fc_settings[5].load_length));
|
SERIAL_ECHOPAIR_P(port, "T5 L", LINEAR_UNIT(fc_settings[5].load_length));
|
||||||
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[5].unload_length));
|
SERIAL_ECHOLNPAIR_P(port, " U", LINEAR_UNIT(fc_settings[5].unload_length));
|
||||||
|
@ -3052,11 +2955,8 @@ void MarlinSettings::reset(PORTARG_SOLO) {
|
||||||
#endif // ADVANCED_PAUSE_FEATURE
|
#endif // ADVANCED_PAUSE_FEATURE
|
||||||
|
|
||||||
#if EXTRUDERS > 1
|
#if EXTRUDERS > 1
|
||||||
CONFIG_ECHO_START;
|
CONFIG_ECHO_HEADING("Tool-changing:");
|
||||||
if (!forReplay) {
|
CONFIG_ECHO_START();
|
||||||
SERIAL_ECHOLNPGM_P(port, "Tool-changing:");
|
|
||||||
CONFIG_ECHO_START;
|
|
||||||
}
|
|
||||||
M217_report(true);
|
M217_report(true);
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
|
@ -365,13 +365,13 @@ void Endstops::event_handler() {
|
||||||
|
|
||||||
static void print_es_state(const bool is_hit, PGM_P const label=NULL) {
|
static void print_es_state(const bool is_hit, PGM_P const label=NULL) {
|
||||||
if (label) serialprintPGM(label);
|
if (label) serialprintPGM(label);
|
||||||
SERIAL_PROTOCOLPGM(": ");
|
SERIAL_ECHOPGM(": ");
|
||||||
serialprintPGM(is_hit ? PSTR(MSG_ENDSTOP_HIT) : PSTR(MSG_ENDSTOP_OPEN));
|
serialprintPGM(is_hit ? PSTR(MSG_ENDSTOP_HIT) : PSTR(MSG_ENDSTOP_OPEN));
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
|
||||||
void _O2 Endstops::M119() {
|
void _O2 Endstops::M119() {
|
||||||
SERIAL_PROTOCOLLNPGM(MSG_M119_REPORT);
|
SERIAL_ECHOLNPGM(MSG_M119_REPORT);
|
||||||
#define ES_REPORT(S) print_es_state(READ(S##_PIN) != S##_ENDSTOP_INVERTING, PSTR(MSG_##S))
|
#define ES_REPORT(S) print_es_state(READ(S##_PIN) != S##_ENDSTOP_INVERTING, PSTR(MSG_##S))
|
||||||
#if HAS_X_MIN
|
#if HAS_X_MIN
|
||||||
ES_REPORT(X_MIN);
|
ES_REPORT(X_MIN);
|
||||||
|
@ -441,7 +441,7 @@ void _O2 Endstops::M119() {
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
SERIAL_PROTOCOLPGM(MSG_FILAMENT_RUNOUT_SENSOR);
|
SERIAL_ECHOPGM(MSG_FILAMENT_RUNOUT_SENSOR);
|
||||||
if (i > 1) { SERIAL_CHAR(' '); SERIAL_CHAR('0' + i); }
|
if (i > 1) { SERIAL_CHAR(' '); SERIAL_CHAR('0' + i); }
|
||||||
print_es_state(digitalRead(pin) != FIL_RUNOUT_INVERTING);
|
print_es_state(digitalRead(pin) != FIL_RUNOUT_INVERTING);
|
||||||
}
|
}
|
||||||
|
@ -825,51 +825,51 @@ void Endstops::update() {
|
||||||
|
|
||||||
if (endstop_change) {
|
if (endstop_change) {
|
||||||
#if HAS_X_MIN
|
#if HAS_X_MIN
|
||||||
if (TEST(endstop_change, X_MIN)) SERIAL_PROTOCOLPAIR(" X_MIN:", TEST(live_state_local, X_MIN));
|
if (TEST(endstop_change, X_MIN)) SERIAL_ECHOPAIR(" X_MIN:", TEST(live_state_local, X_MIN));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_X_MAX
|
#if HAS_X_MAX
|
||||||
if (TEST(endstop_change, X_MAX)) SERIAL_PROTOCOLPAIR(" X_MAX:", TEST(live_state_local, X_MAX));
|
if (TEST(endstop_change, X_MAX)) SERIAL_ECHOPAIR(" X_MAX:", TEST(live_state_local, X_MAX));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Y_MIN
|
#if HAS_Y_MIN
|
||||||
if (TEST(endstop_change, Y_MIN)) SERIAL_PROTOCOLPAIR(" Y_MIN:", TEST(live_state_local, Y_MIN));
|
if (TEST(endstop_change, Y_MIN)) SERIAL_ECHOPAIR(" Y_MIN:", TEST(live_state_local, Y_MIN));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Y_MAX
|
#if HAS_Y_MAX
|
||||||
if (TEST(endstop_change, Y_MAX)) SERIAL_PROTOCOLPAIR(" Y_MAX:", TEST(live_state_local, Y_MAX));
|
if (TEST(endstop_change, Y_MAX)) SERIAL_ECHOPAIR(" Y_MAX:", TEST(live_state_local, Y_MAX));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Z_MIN
|
#if HAS_Z_MIN
|
||||||
if (TEST(endstop_change, Z_MIN)) SERIAL_PROTOCOLPAIR(" Z_MIN:", TEST(live_state_local, Z_MIN));
|
if (TEST(endstop_change, Z_MIN)) SERIAL_ECHOPAIR(" Z_MIN:", TEST(live_state_local, Z_MIN));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Z_MAX
|
#if HAS_Z_MAX
|
||||||
if (TEST(endstop_change, Z_MAX)) SERIAL_PROTOCOLPAIR(" Z_MAX:", TEST(live_state_local, Z_MAX));
|
if (TEST(endstop_change, Z_MAX)) SERIAL_ECHOPAIR(" Z_MAX:", TEST(live_state_local, Z_MAX));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Z_MIN_PROBE_PIN
|
#if HAS_Z_MIN_PROBE_PIN
|
||||||
if (TEST(endstop_change, Z_MIN_PROBE)) SERIAL_PROTOCOLPAIR(" PROBE:", TEST(live_state_local, Z_MIN_PROBE));
|
if (TEST(endstop_change, Z_MIN_PROBE)) SERIAL_ECHOPAIR(" PROBE:", TEST(live_state_local, Z_MIN_PROBE));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_X2_MIN
|
#if HAS_X2_MIN
|
||||||
if (TEST(endstop_change, X2_MIN)) SERIAL_PROTOCOLPAIR(" X2_MIN:", TEST(live_state_local, X2_MIN));
|
if (TEST(endstop_change, X2_MIN)) SERIAL_ECHOPAIR(" X2_MIN:", TEST(live_state_local, X2_MIN));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_X2_MAX
|
#if HAS_X2_MAX
|
||||||
if (TEST(endstop_change, X2_MAX)) SERIAL_PROTOCOLPAIR(" X2_MAX:", TEST(live_state_local, X2_MAX));
|
if (TEST(endstop_change, X2_MAX)) SERIAL_ECHOPAIR(" X2_MAX:", TEST(live_state_local, X2_MAX));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Y2_MIN
|
#if HAS_Y2_MIN
|
||||||
if (TEST(endstop_change, Y2_MIN)) SERIAL_PROTOCOLPAIR(" Y2_MIN:", TEST(live_state_local, Y2_MIN));
|
if (TEST(endstop_change, Y2_MIN)) SERIAL_ECHOPAIR(" Y2_MIN:", TEST(live_state_local, Y2_MIN));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Y2_MAX
|
#if HAS_Y2_MAX
|
||||||
if (TEST(endstop_change, Y2_MAX)) SERIAL_PROTOCOLPAIR(" Y2_MAX:", TEST(live_state_local, Y2_MAX));
|
if (TEST(endstop_change, Y2_MAX)) SERIAL_ECHOPAIR(" Y2_MAX:", TEST(live_state_local, Y2_MAX));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Z2_MIN
|
#if HAS_Z2_MIN
|
||||||
if (TEST(endstop_change, Z2_MIN)) SERIAL_PROTOCOLPAIR(" Z2_MIN:", TEST(live_state_local, Z2_MIN));
|
if (TEST(endstop_change, Z2_MIN)) SERIAL_ECHOPAIR(" Z2_MIN:", TEST(live_state_local, Z2_MIN));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Z2_MAX
|
#if HAS_Z2_MAX
|
||||||
if (TEST(endstop_change, Z2_MAX)) SERIAL_PROTOCOLPAIR(" Z2_MAX:", TEST(live_state_local, Z2_MAX));
|
if (TEST(endstop_change, Z2_MAX)) SERIAL_ECHOPAIR(" Z2_MAX:", TEST(live_state_local, Z2_MAX));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Z3_MIN
|
#if HAS_Z3_MIN
|
||||||
if (TEST(endstop_change, Z3_MIN)) SERIAL_PROTOCOLPAIR(" Z3_MIN:", TEST(live_state_local, Z3_MIN));
|
if (TEST(endstop_change, Z3_MIN)) SERIAL_ECHOPAIR(" Z3_MIN:", TEST(live_state_local, Z3_MIN));
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Z3_MAX
|
#if HAS_Z3_MAX
|
||||||
if (TEST(endstop_change, Z3_MAX)) SERIAL_PROTOCOLPAIR(" Z3_MAX:", TEST(live_state_local, Z3_MAX));
|
if (TEST(endstop_change, Z3_MAX)) SERIAL_ECHOPAIR(" Z3_MAX:", TEST(live_state_local, Z3_MAX));
|
||||||
#endif
|
#endif
|
||||||
SERIAL_PROTOCOLPGM("\n\n");
|
SERIAL_ECHOPGM("\n\n");
|
||||||
analogWrite(LED_PIN, local_LED_status);
|
analogWrite(LED_PIN, local_LED_status);
|
||||||
local_LED_status ^= 255;
|
local_LED_status ^= 255;
|
||||||
old_live_state_local = live_state_local;
|
old_live_state_local = live_state_local;
|
||||||
|
|
|
@ -163,14 +163,10 @@ float cartes[XYZ];
|
||||||
* Output the current position to serial
|
* Output the current position to serial
|
||||||
*/
|
*/
|
||||||
void report_current_position() {
|
void report_current_position() {
|
||||||
SERIAL_PROTOCOLPGM("X:");
|
SERIAL_ECHOPAIR("X:", LOGICAL_X_POSITION(current_position[X_AXIS]));
|
||||||
SERIAL_PROTOCOL(LOGICAL_X_POSITION(current_position[X_AXIS]));
|
SERIAL_ECHOPAIR(" Y:", LOGICAL_Y_POSITION(current_position[Y_AXIS]));
|
||||||
SERIAL_PROTOCOLPGM(" Y:");
|
SERIAL_ECHOPAIR(" Z:", LOGICAL_Z_POSITION(current_position[Z_AXIS]));
|
||||||
SERIAL_PROTOCOL(LOGICAL_Y_POSITION(current_position[Y_AXIS]));
|
SERIAL_ECHOPAIR(" E:", current_position[E_AXIS]);
|
||||||
SERIAL_PROTOCOLPGM(" Z:");
|
|
||||||
SERIAL_PROTOCOL(LOGICAL_Z_POSITION(current_position[Z_AXIS]));
|
|
||||||
SERIAL_PROTOCOLPGM(" E:");
|
|
||||||
SERIAL_PROTOCOL(current_position[E_AXIS]);
|
|
||||||
|
|
||||||
stepper.report_positions();
|
stepper.report_positions();
|
||||||
|
|
||||||
|
@ -967,15 +963,13 @@ void prepare_move_to_destination() {
|
||||||
#if ENABLED(PREVENT_COLD_EXTRUSION)
|
#if ENABLED(PREVENT_COLD_EXTRUSION)
|
||||||
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_MSG(MSG_ERR_COLD_EXTRUDE_STOP);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP);
|
|
||||||
}
|
}
|
||||||
#endif // PREVENT_COLD_EXTRUSION
|
#endif // PREVENT_COLD_EXTRUSION
|
||||||
#if ENABLED(PREVENT_LENGTHY_EXTRUDE)
|
#if ENABLED(PREVENT_LENGTHY_EXTRUDE)
|
||||||
if (ABS(destination[E_AXIS] - current_position[E_AXIS]) * planner.e_factor[active_extruder] > (EXTRUDE_MAXLENGTH)) {
|
if (ABS(destination[E_AXIS] - current_position[E_AXIS]) * planner.e_factor[active_extruder] > (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_MSG(MSG_ERR_LONG_EXTRUDE_STOP);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP);
|
|
||||||
}
|
}
|
||||||
#endif // PREVENT_LENGTHY_EXTRUDE
|
#endif // PREVENT_LENGTHY_EXTRUDE
|
||||||
}
|
}
|
||||||
|
@ -1046,8 +1040,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_MSG("Warning: Homing Bump Divisor < 1");
|
||||||
SERIAL_ECHOLNPGM("Warning: Homing Bump Divisor < 1");
|
|
||||||
}
|
}
|
||||||
return homing_feedrate(axis) / hbd;
|
return homing_feedrate(axis) / hbd;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1661,8 +1661,7 @@ bool Planner::_populate_block(block_t * const block, bool split_move,
|
||||||
position_float[E_AXIS] = target_float[E_AXIS];
|
position_float[E_AXIS] = target_float[E_AXIS];
|
||||||
#endif
|
#endif
|
||||||
de = 0; // no difference
|
de = 0; // no difference
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(MSG_ERR_COLD_EXTRUDE_STOP);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_COLD_EXTRUDE_STOP);
|
|
||||||
}
|
}
|
||||||
#endif // PREVENT_COLD_EXTRUSION
|
#endif // PREVENT_COLD_EXTRUSION
|
||||||
#if ENABLED(PREVENT_LENGTHY_EXTRUDE)
|
#if ENABLED(PREVENT_LENGTHY_EXTRUDE)
|
||||||
|
@ -1672,8 +1671,7 @@ bool Planner::_populate_block(block_t * const block, bool split_move,
|
||||||
position_float[E_AXIS] = target_float[E_AXIS];
|
position_float[E_AXIS] = target_float[E_AXIS];
|
||||||
#endif
|
#endif
|
||||||
de = 0; // no difference
|
de = 0; // no difference
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(MSG_ERR_LONG_EXTRUDE_STOP);
|
||||||
SERIAL_ECHOLNPGM(MSG_ERR_LONG_EXTRUDE_STOP);
|
|
||||||
}
|
}
|
||||||
#endif // PREVENT_LENGTHY_EXTRUDE
|
#endif // PREVENT_LENGTHY_EXTRUDE
|
||||||
}
|
}
|
||||||
|
|
|
@ -111,7 +111,7 @@ void PrintCounter::saveStats() {
|
||||||
void PrintCounter::showStats() {
|
void PrintCounter::showStats() {
|
||||||
char buffer[21];
|
char buffer[21];
|
||||||
|
|
||||||
SERIAL_PROTOCOLPGM(MSG_STATS);
|
SERIAL_ECHOPGM(MSG_STATS);
|
||||||
|
|
||||||
SERIAL_ECHOPGM("Prints: ");
|
SERIAL_ECHOPGM("Prints: ");
|
||||||
SERIAL_ECHO(data.totalPrints);
|
SERIAL_ECHO(data.totalPrints);
|
||||||
|
@ -124,7 +124,7 @@ void PrintCounter::showStats() {
|
||||||
- ((isRunning() || isPaused()) ? 1 : 0));
|
- ((isRunning() || isPaused()) ? 1 : 0));
|
||||||
|
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
SERIAL_PROTOCOLPGM(MSG_STATS);
|
SERIAL_ECHOPGM(MSG_STATS);
|
||||||
|
|
||||||
duration_t elapsed = data.printTime;
|
duration_t elapsed = data.printTime;
|
||||||
elapsed.toString(buffer);
|
elapsed.toString(buffer);
|
||||||
|
@ -151,7 +151,7 @@ void PrintCounter::showStats() {
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
SERIAL_PROTOCOLPGM(MSG_STATS);
|
SERIAL_ECHOPGM(MSG_STATS);
|
||||||
|
|
||||||
SERIAL_ECHOPGM("Filament used: ");
|
SERIAL_ECHOPGM("Filament used: ");
|
||||||
SERIAL_ECHO(data.filamentUsed / 1000);
|
SERIAL_ECHO(data.filamentUsed / 1000);
|
||||||
|
|
|
@ -320,8 +320,7 @@ float zprobe_zoffset; // Initialized by settings.load()
|
||||||
// (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_MSG(MSG_STOP_BLTOUCH);
|
||||||
SERIAL_ERRORLNPGM(MSG_STOP_BLTOUCH);
|
|
||||||
stop(); // punt!
|
stop(); // punt!
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
@ -450,8 +449,7 @@ bool set_probe_deployed(const bool deploy) {
|
||||||
#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_MSG(MSG_STOP_UNHOMED);
|
||||||
SERIAL_ERRORLNPGM(MSG_STOP_UNHOMED);
|
|
||||||
stop();
|
stop();
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
@ -479,8 +477,7 @@ bool set_probe_deployed(const bool deploy) {
|
||||||
|
|
||||||
if (PROBE_STOWED() == deploy) { // Unchanged after deploy/stow action?
|
if (PROBE_STOWED() == deploy) { // Unchanged after deploy/stow action?
|
||||||
if (IsRunning()) {
|
if (IsRunning()) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG("Z-Probe failed");
|
||||||
SERIAL_ERRORLNPGM("Z-Probe failed");
|
|
||||||
LCD_ALERTMESSAGEPGM("Err: ZPROBE");
|
LCD_ALERTMESSAGEPGM("Err: ZPROBE");
|
||||||
}
|
}
|
||||||
stop();
|
stop();
|
||||||
|
@ -771,13 +768,9 @@ float probe_pt(const float &rx, const float &ry, const ProbePtRaise raise_after/
|
||||||
}
|
}
|
||||||
|
|
||||||
if (verbose_level > 2) {
|
if (verbose_level > 2) {
|
||||||
SERIAL_PROTOCOLPGM("Bed X: ");
|
SERIAL_ECHOPAIR_F("Bed X: ", LOGICAL_X_POSITION(rx), 3);
|
||||||
SERIAL_PROTOCOL_F(LOGICAL_X_POSITION(rx), 3);
|
SERIAL_ECHOPAIR_F(" Y: ", LOGICAL_Y_POSITION(ry), 3);
|
||||||
SERIAL_PROTOCOLPGM(" Y: ");
|
SERIAL_ECHOLNPAIR_F(" Z: ", measured_z, 3);
|
||||||
SERIAL_PROTOCOL_F(LOGICAL_Y_POSITION(ry), 3);
|
|
||||||
SERIAL_PROTOCOLPGM(" Z: ");
|
|
||||||
SERIAL_PROTOCOL_F(measured_z, 3);
|
|
||||||
SERIAL_EOL();
|
|
||||||
}
|
}
|
||||||
|
|
||||||
feedrate_mm_s = old_feedrate_mm_s;
|
feedrate_mm_s = old_feedrate_mm_s;
|
||||||
|
@ -785,8 +778,7 @@ float probe_pt(const float &rx, const float &ry, const ProbePtRaise raise_after/
|
||||||
if (isnan(measured_z)) {
|
if (isnan(measured_z)) {
|
||||||
STOW_PROBE();
|
STOW_PROBE();
|
||||||
LCD_MESSAGEPGM(MSG_ERR_PROBING_FAILED);
|
LCD_MESSAGEPGM(MSG_ERR_PROBING_FAILED);
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_PROBING_FAILED);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_PROBING_FAILED);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
#if ENABLED(DEBUG_LEVELING_FEATURE)
|
||||||
|
|
|
@ -142,8 +142,8 @@ void inverse_kinematics(const float (&raw)[XYZ]) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void scara_report_positions() {
|
void scara_report_positions() {
|
||||||
SERIAL_PROTOCOLPAIR("SCARA Theta:", planner.get_axis_position_degrees(A_AXIS));
|
SERIAL_ECHOPAIR("SCARA Theta:", planner.get_axis_position_degrees(A_AXIS));
|
||||||
SERIAL_PROTOCOLLNPAIR(" Psi+Theta:", planner.get_axis_position_degrees(B_AXIS));
|
SERIAL_ECHOLNPAIR(" Psi+Theta:", planner.get_axis_position_degrees(B_AXIS));
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -2218,25 +2218,25 @@ void Stepper::report_positions() {
|
||||||
if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
|
if (was_enabled) ENABLE_STEPPER_DRIVER_INTERRUPT();
|
||||||
|
|
||||||
#if CORE_IS_XY || CORE_IS_XZ || ENABLED(DELTA) || IS_SCARA
|
#if CORE_IS_XY || CORE_IS_XZ || ENABLED(DELTA) || IS_SCARA
|
||||||
SERIAL_PROTOCOLPGM(MSG_COUNT_A);
|
SERIAL_ECHOPGM(MSG_COUNT_A);
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOLPGM(MSG_COUNT_X);
|
SERIAL_ECHOPGM(MSG_COUNT_X);
|
||||||
#endif
|
#endif
|
||||||
SERIAL_PROTOCOL(xpos);
|
SERIAL_ECHO(xpos);
|
||||||
|
|
||||||
#if CORE_IS_XY || CORE_IS_YZ || ENABLED(DELTA) || IS_SCARA
|
#if CORE_IS_XY || CORE_IS_YZ || ENABLED(DELTA) || IS_SCARA
|
||||||
SERIAL_PROTOCOLPGM(" B:");
|
SERIAL_ECHOPGM(" B:");
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOLPGM(" Y:");
|
SERIAL_ECHOPGM(" Y:");
|
||||||
#endif
|
#endif
|
||||||
SERIAL_PROTOCOL(ypos);
|
SERIAL_ECHO(ypos);
|
||||||
|
|
||||||
#if CORE_IS_XZ || CORE_IS_YZ || ENABLED(DELTA)
|
#if CORE_IS_XZ || CORE_IS_YZ || ENABLED(DELTA)
|
||||||
SERIAL_PROTOCOLPGM(" C:");
|
SERIAL_ECHOPGM(" C:");
|
||||||
#else
|
#else
|
||||||
SERIAL_PROTOCOLPGM(" Z:");
|
SERIAL_ECHOPGM(" Z:");
|
||||||
#endif
|
#endif
|
||||||
SERIAL_PROTOCOL(zpos);
|
SERIAL_ECHO(zpos);
|
||||||
|
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
@ -2813,82 +2813,81 @@ void Stepper::report_positions() {
|
||||||
case 128: microstep_ms(driver, MICROSTEP128); break;
|
case 128: microstep_ms(driver, MICROSTEP128); break;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
default: SERIAL_ERROR_START(); SERIAL_ERRORLNPGM("Microsteps unavailable"); break;
|
default: SERIAL_ERROR_MSG("Microsteps unavailable"); break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void Stepper::microstep_readings() {
|
void Stepper::microstep_readings() {
|
||||||
SERIAL_PROTOCOLLNPGM("MS1,MS2,MS3 Pins");
|
SERIAL_ECHOPGM("MS1,MS2,MS3 Pins\nX: ");
|
||||||
SERIAL_PROTOCOLPGM("X: ");
|
|
||||||
#if HAS_X_MICROSTEPS
|
#if HAS_X_MICROSTEPS
|
||||||
SERIAL_PROTOCOL(READ(X_MS1_PIN));
|
SERIAL_ECHO(READ(X_MS1_PIN));
|
||||||
SERIAL_PROTOCOL(READ(X_MS2_PIN));
|
SERIAL_ECHO(READ(X_MS2_PIN));
|
||||||
#if PIN_EXISTS(X_MS3)
|
#if PIN_EXISTS(X_MS3)
|
||||||
SERIAL_PROTOCOLLN(READ(X_MS3_PIN));
|
SERIAL_ECHOLN(READ(X_MS3_PIN));
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Y_MICROSTEPS
|
#if HAS_Y_MICROSTEPS
|
||||||
SERIAL_PROTOCOLPGM("Y: ");
|
SERIAL_ECHOPGM("Y: ");
|
||||||
SERIAL_PROTOCOL(READ(Y_MS1_PIN));
|
SERIAL_ECHO(READ(Y_MS1_PIN));
|
||||||
SERIAL_PROTOCOL(READ(Y_MS2_PIN));
|
SERIAL_ECHO(READ(Y_MS2_PIN));
|
||||||
#if PIN_EXISTS(Y_MS3)
|
#if PIN_EXISTS(Y_MS3)
|
||||||
SERIAL_PROTOCOLLN(READ(Y_MS3_PIN));
|
SERIAL_ECHOLN(READ(Y_MS3_PIN));
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
#if HAS_Z_MICROSTEPS
|
#if HAS_Z_MICROSTEPS
|
||||||
SERIAL_PROTOCOLPGM("Z: ");
|
SERIAL_ECHOPGM("Z: ");
|
||||||
SERIAL_PROTOCOL(READ(Z_MS1_PIN));
|
SERIAL_ECHO(READ(Z_MS1_PIN));
|
||||||
SERIAL_PROTOCOL(READ(Z_MS2_PIN));
|
SERIAL_ECHO(READ(Z_MS2_PIN));
|
||||||
#if PIN_EXISTS(Z_MS3)
|
#if PIN_EXISTS(Z_MS3)
|
||||||
SERIAL_PROTOCOLLN(READ(Z_MS3_PIN));
|
SERIAL_ECHOLN(READ(Z_MS3_PIN));
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
#if HAS_E0_MICROSTEPS
|
#if HAS_E0_MICROSTEPS
|
||||||
SERIAL_PROTOCOLPGM("E0: ");
|
SERIAL_ECHOPGM("E0: ");
|
||||||
SERIAL_PROTOCOL(READ(E0_MS1_PIN));
|
SERIAL_ECHO(READ(E0_MS1_PIN));
|
||||||
SERIAL_PROTOCOL(READ(E0_MS2_PIN));
|
SERIAL_ECHO(READ(E0_MS2_PIN));
|
||||||
#if PIN_EXISTS(E0_MS3)
|
#if PIN_EXISTS(E0_MS3)
|
||||||
SERIAL_PROTOCOLLN(READ(E0_MS3_PIN));
|
SERIAL_ECHOLN(READ(E0_MS3_PIN));
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
#if HAS_E1_MICROSTEPS
|
#if HAS_E1_MICROSTEPS
|
||||||
SERIAL_PROTOCOLPGM("E1: ");
|
SERIAL_ECHOPGM("E1: ");
|
||||||
SERIAL_PROTOCOL(READ(E1_MS1_PIN));
|
SERIAL_ECHO(READ(E1_MS1_PIN));
|
||||||
SERIAL_PROTOCOL(READ(E1_MS2_PIN));
|
SERIAL_ECHO(READ(E1_MS2_PIN));
|
||||||
#if PIN_EXISTS(E1_MS3)
|
#if PIN_EXISTS(E1_MS3)
|
||||||
SERIAL_PROTOCOLLN(READ(E1_MS3_PIN));
|
SERIAL_ECHOLN(READ(E1_MS3_PIN));
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
#if HAS_E2_MICROSTEPS
|
#if HAS_E2_MICROSTEPS
|
||||||
SERIAL_PROTOCOLPGM("E2: ");
|
SERIAL_ECHOPGM("E2: ");
|
||||||
SERIAL_PROTOCOL(READ(E2_MS1_PIN));
|
SERIAL_ECHO(READ(E2_MS1_PIN));
|
||||||
SERIAL_PROTOCOL(READ(E2_MS2_PIN));
|
SERIAL_ECHO(READ(E2_MS2_PIN));
|
||||||
#if PIN_EXISTS(E2_MS3)
|
#if PIN_EXISTS(E2_MS3)
|
||||||
SERIAL_PROTOCOLLN(READ(E2_MS3_PIN));
|
SERIAL_ECHOLN(READ(E2_MS3_PIN));
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
#if HAS_E3_MICROSTEPS
|
#if HAS_E3_MICROSTEPS
|
||||||
SERIAL_PROTOCOLPGM("E3: ");
|
SERIAL_ECHOPGM("E3: ");
|
||||||
SERIAL_PROTOCOL(READ(E3_MS1_PIN));
|
SERIAL_ECHO(READ(E3_MS1_PIN));
|
||||||
SERIAL_PROTOCOL(READ(E3_MS2_PIN));
|
SERIAL_ECHO(READ(E3_MS2_PIN));
|
||||||
#if PIN_EXISTS(E3_MS3)
|
#if PIN_EXISTS(E3_MS3)
|
||||||
SERIAL_PROTOCOLLN(READ(E3_MS3_PIN));
|
SERIAL_ECHOLN(READ(E3_MS3_PIN));
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
#if HAS_E4_MICROSTEPS
|
#if HAS_E4_MICROSTEPS
|
||||||
SERIAL_PROTOCOLPGM("E4: ");
|
SERIAL_ECHOPGM("E4: ");
|
||||||
SERIAL_PROTOCOL(READ(E4_MS1_PIN));
|
SERIAL_ECHO(READ(E4_MS1_PIN));
|
||||||
SERIAL_PROTOCOL(READ(E4_MS2_PIN));
|
SERIAL_ECHO(READ(E4_MS2_PIN));
|
||||||
#if PIN_EXISTS(E4_MS3)
|
#if PIN_EXISTS(E4_MS3)
|
||||||
SERIAL_PROTOCOLLN(READ(E4_MS3_PIN));
|
SERIAL_ECHOLN(READ(E4_MS3_PIN));
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
#if HAS_E5_MICROSTEPS
|
#if HAS_E5_MICROSTEPS
|
||||||
SERIAL_PROTOCOLPGM("E5: ");
|
SERIAL_ECHOPGM("E5: ");
|
||||||
SERIAL_PROTOCOL(READ(E5_MS1_PIN));
|
SERIAL_ECHO(READ(E5_MS1_PIN));
|
||||||
SERIAL_PROTOCOLLN(READ(E5_MS2_PIN));
|
SERIAL_ECHOLN(READ(E5_MS2_PIN));
|
||||||
#if PIN_EXISTS(E5_MS3)
|
#if PIN_EXISTS(E5_MS3)
|
||||||
SERIAL_PROTOCOLLN(READ(E5_MS3_PIN));
|
SERIAL_ECHOLN(READ(E5_MS3_PIN));
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
|
@ -228,7 +228,7 @@ uint8_t Temperature::soft_pwm_amount[HOTENDS];
|
||||||
|
|
||||||
#if HAS_PID_HEATING
|
#if HAS_PID_HEATING
|
||||||
|
|
||||||
inline void say_default_() { SERIAL_PROTOCOLPGM("#define DEFAULT_"); }
|
inline void say_default_() { SERIAL_ECHOPGM("#define DEFAULT_"); }
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* PID Autotuning (M303)
|
* PID Autotuning (M303)
|
||||||
|
@ -343,37 +343,37 @@ uint8_t Temperature::soft_pwm_amount[HOTENDS];
|
||||||
bias = constrain(bias, 20, max_pow - 20);
|
bias = constrain(bias, 20, max_pow - 20);
|
||||||
d = (bias > max_pow >> 1) ? max_pow - 1 - bias : bias;
|
d = (bias > max_pow >> 1) ? max_pow - 1 - bias : bias;
|
||||||
|
|
||||||
SERIAL_PROTOCOLPAIR(MSG_BIAS, bias);
|
SERIAL_ECHOPAIR(MSG_BIAS, bias);
|
||||||
SERIAL_PROTOCOLPAIR(MSG_D, d);
|
SERIAL_ECHOPAIR(MSG_D, d);
|
||||||
SERIAL_PROTOCOLPAIR(MSG_T_MIN, min);
|
SERIAL_ECHOPAIR(MSG_T_MIN, min);
|
||||||
SERIAL_PROTOCOLPAIR(MSG_T_MAX, max);
|
SERIAL_ECHOPAIR(MSG_T_MAX, max);
|
||||||
if (cycles > 2) {
|
if (cycles > 2) {
|
||||||
float Ku = (4.0f * d) / (float(M_PI) * (max - min) * 0.5f),
|
float Ku = (4.0f * d) / (float(M_PI) * (max - min) * 0.5f),
|
||||||
Tu = ((float)(t_low + t_high) * 0.001f);
|
Tu = ((float)(t_low + t_high) * 0.001f);
|
||||||
SERIAL_PROTOCOLPAIR(MSG_KU, Ku);
|
SERIAL_ECHOPAIR(MSG_KU, Ku);
|
||||||
SERIAL_PROTOCOLPAIR(MSG_TU, Tu);
|
SERIAL_ECHOPAIR(MSG_TU, Tu);
|
||||||
tune_pid.Kp = 0.6f * Ku;
|
tune_pid.Kp = 0.6f * Ku;
|
||||||
tune_pid.Ki = 2 * tune_pid.Kp / Tu;
|
tune_pid.Ki = 2 * tune_pid.Kp / Tu;
|
||||||
tune_pid.Kd = tune_pid.Kp * Tu * 0.125f;
|
tune_pid.Kd = tune_pid.Kp * Tu * 0.125f;
|
||||||
SERIAL_PROTOCOLLNPGM("\n" MSG_CLASSIC_PID);
|
SERIAL_ECHOLNPGM("\n" MSG_CLASSIC_PID);
|
||||||
SERIAL_PROTOCOLPAIR(MSG_KP, tune_pid.Kp);
|
SERIAL_ECHOPAIR(MSG_KP, tune_pid.Kp);
|
||||||
SERIAL_PROTOCOLPAIR(MSG_KI, tune_pid.Ki);
|
SERIAL_ECHOPAIR(MSG_KI, tune_pid.Ki);
|
||||||
SERIAL_PROTOCOLLNPAIR(MSG_KD, tune_pid.Kd);
|
SERIAL_ECHOLNPAIR(MSG_KD, tune_pid.Kd);
|
||||||
/**
|
/**
|
||||||
tune_pid.Kp = 0.33*Ku;
|
tune_pid.Kp = 0.33*Ku;
|
||||||
tune_pid.Ki = tune_pid.Kp/Tu;
|
tune_pid.Ki = tune_pid.Kp/Tu;
|
||||||
tune_pid.Kd = tune_pid.Kp*Tu/3;
|
tune_pid.Kd = tune_pid.Kp*Tu/3;
|
||||||
SERIAL_PROTOCOLLNPGM(" Some overshoot");
|
SERIAL_ECHOLNPGM(" Some overshoot");
|
||||||
SERIAL_PROTOCOLPAIR(" Kp: ", tune_pid.Kp);
|
SERIAL_ECHOPAIR(" Kp: ", tune_pid.Kp);
|
||||||
SERIAL_PROTOCOLPAIR(" Ki: ", tune_pid.Ki);
|
SERIAL_ECHOPAIR(" Ki: ", tune_pid.Ki);
|
||||||
SERIAL_PROTOCOLPAIR(" Kd: ", tune_pid.Kd);
|
SERIAL_ECHOPAIR(" Kd: ", tune_pid.Kd);
|
||||||
tune_pid.Kp = 0.2*Ku;
|
tune_pid.Kp = 0.2*Ku;
|
||||||
tune_pid.Ki = 2*tune_pid.Kp/Tu;
|
tune_pid.Ki = 2*tune_pid.Kp/Tu;
|
||||||
tune_pid.Kd = tune_pid.Kp*Tu/3;
|
tune_pid.Kd = tune_pid.Kp*Tu/3;
|
||||||
SERIAL_PROTOCOLLNPGM(" No overshoot");
|
SERIAL_ECHOLNPGM(" No overshoot");
|
||||||
SERIAL_PROTOCOLPAIR(" Kp: ", tune_pid.Kp);
|
SERIAL_ECHOPAIR(" Kp: ", tune_pid.Kp);
|
||||||
SERIAL_PROTOCOLPAIR(" Ki: ", tune_pid.Ki);
|
SERIAL_ECHOPAIR(" Ki: ", tune_pid.Ki);
|
||||||
SERIAL_PROTOCOLPAIR(" Kd: ", tune_pid.Kd);
|
SERIAL_ECHOPAIR(" Kd: ", tune_pid.Kd);
|
||||||
*/
|
*/
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -389,7 +389,7 @@ uint8_t Temperature::soft_pwm_amount[HOTENDS];
|
||||||
#define MAX_OVERSHOOT_PID_AUTOTUNE 20
|
#define MAX_OVERSHOOT_PID_AUTOTUNE 20
|
||||||
#endif
|
#endif
|
||||||
if (current > target + MAX_OVERSHOOT_PID_AUTOTUNE) {
|
if (current > target + MAX_OVERSHOOT_PID_AUTOTUNE) {
|
||||||
SERIAL_PROTOCOLLNPGM(MSG_PID_TEMP_TOO_HIGH);
|
SERIAL_ECHOLNPGM(MSG_PID_TEMP_TOO_HIGH);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -432,26 +432,26 @@ uint8_t Temperature::soft_pwm_amount[HOTENDS];
|
||||||
#define MAX_CYCLE_TIME_PID_AUTOTUNE 20L
|
#define MAX_CYCLE_TIME_PID_AUTOTUNE 20L
|
||||||
#endif
|
#endif
|
||||||
if (((ms - t1) + (ms - t2)) > (MAX_CYCLE_TIME_PID_AUTOTUNE * 60L * 1000L)) {
|
if (((ms - t1) + (ms - t2)) > (MAX_CYCLE_TIME_PID_AUTOTUNE * 60L * 1000L)) {
|
||||||
SERIAL_PROTOCOLLNPGM(MSG_PID_TIMEOUT);
|
SERIAL_ECHOLNPGM(MSG_PID_TIMEOUT);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (cycles > ncycles) {
|
if (cycles > ncycles) {
|
||||||
SERIAL_PROTOCOLLNPGM(MSG_PID_AUTOTUNE_FINISHED);
|
SERIAL_ECHOLNPGM(MSG_PID_AUTOTUNE_FINISHED);
|
||||||
|
|
||||||
#if HAS_PID_FOR_BOTH
|
#if HAS_PID_FOR_BOTH
|
||||||
const char * const estring = GHV(PSTR("bed"), PSTR(""));
|
const char * const estring = GHV(PSTR("bed"), PSTR(""));
|
||||||
say_default_(); serialprintPGM(estring); SERIAL_PROTOCOLLNPAIR("Kp ", tune_pid.Kp);
|
say_default_(); serialprintPGM(estring); SERIAL_ECHOLNPAIR("Kp ", tune_pid.Kp);
|
||||||
say_default_(); serialprintPGM(estring); SERIAL_PROTOCOLLNPAIR("Ki ", tune_pid.Ki);
|
say_default_(); serialprintPGM(estring); SERIAL_ECHOLNPAIR("Ki ", tune_pid.Ki);
|
||||||
say_default_(); serialprintPGM(estring); SERIAL_PROTOCOLLNPAIR("Kd ", tune_pid.Kd);
|
say_default_(); serialprintPGM(estring); SERIAL_ECHOLNPAIR("Kd ", tune_pid.Kd);
|
||||||
#elif ENABLED(PIDTEMP)
|
#elif ENABLED(PIDTEMP)
|
||||||
say_default_(); SERIAL_PROTOCOLLNPAIR("Kp ", tune_pid.Kp);
|
say_default_(); SERIAL_ECHOLNPAIR("Kp ", tune_pid.Kp);
|
||||||
say_default_(); SERIAL_PROTOCOLLNPAIR("Ki ", tune_pid.Ki);
|
say_default_(); SERIAL_ECHOLNPAIR("Ki ", tune_pid.Ki);
|
||||||
say_default_(); SERIAL_PROTOCOLLNPAIR("Kd ", tune_pid.Kd);
|
say_default_(); SERIAL_ECHOLNPAIR("Kd ", tune_pid.Kd);
|
||||||
#else
|
#else
|
||||||
say_default_(); SERIAL_PROTOCOLLNPAIR("bedKp ", tune_pid.Kp);
|
say_default_(); SERIAL_ECHOLNPAIR("bedKp ", tune_pid.Kp);
|
||||||
say_default_(); SERIAL_PROTOCOLLNPAIR("bedKi ", tune_pid.Ki);
|
say_default_(); SERIAL_ECHOLNPAIR("bedKi ", tune_pid.Ki);
|
||||||
say_default_(); SERIAL_PROTOCOLLNPAIR("bedKd ", tune_pid.Kd);
|
say_default_(); SERIAL_ECHOLNPAIR("bedKd ", tune_pid.Kd);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#define _SET_BED_PID() do { \
|
#define _SET_BED_PID() do { \
|
||||||
|
@ -564,8 +564,8 @@ void Temperature::_temp_error(const int8_t heater, PGM_P const serial_msg, PGM_P
|
||||||
if (IsRunning()) {
|
if (IsRunning()) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_START();
|
||||||
serialprintPGM(serial_msg);
|
serialprintPGM(serial_msg);
|
||||||
SERIAL_ERRORPGM(MSG_STOPPED_HEATER);
|
SERIAL_ECHOPGM(MSG_STOPPED_HEATER);
|
||||||
if (heater >= 0) SERIAL_ERRORLN((int)heater); else SERIAL_ERRORLNPGM(MSG_HEATER_BED);
|
if (heater >= 0) SERIAL_ECHOLN((int)heater); else SERIAL_ECHOLNPGM(MSG_HEATER_BED);
|
||||||
}
|
}
|
||||||
#if DISABLED(BOGUS_TEMPERATURE_FAILSAFE_OVERRIDE)
|
#if DISABLED(BOGUS_TEMPERATURE_FAILSAFE_OVERRIDE)
|
||||||
if (!killed) {
|
if (!killed) {
|
||||||
|
@ -940,8 +940,8 @@ float Temperature::analog_to_celsius_hotend(const int raw, const uint8_t e) {
|
||||||
#endif
|
#endif
|
||||||
{
|
{
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_START();
|
||||||
SERIAL_ERROR((int)e);
|
SERIAL_ECHO((int)e);
|
||||||
SERIAL_ERRORLNPGM(MSG_INVALID_EXTRUDER_NUM);
|
SERIAL_ECHOLNPGM(MSG_INVALID_EXTRUDER_NUM);
|
||||||
kill();
|
kill();
|
||||||
return 0.0;
|
return 0.0;
|
||||||
}
|
}
|
||||||
|
@ -1684,17 +1684,17 @@ void Temperature::disable_all_heaters() {
|
||||||
|
|
||||||
if (max6675_temp & MAX6675_ERROR_MASK) {
|
if (max6675_temp & MAX6675_ERROR_MASK) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_START();
|
||||||
SERIAL_ERRORPGM("Temp measurement error! ");
|
SERIAL_ECHOPGM("Temp measurement error! ");
|
||||||
#if MAX6675_ERROR_MASK == 7
|
#if MAX6675_ERROR_MASK == 7
|
||||||
SERIAL_ERRORPGM("MAX31855 ");
|
SERIAL_ECHOPGM("MAX31855 ");
|
||||||
if (max6675_temp & 1)
|
if (max6675_temp & 1)
|
||||||
SERIAL_ERRORLNPGM("Open Circuit");
|
SERIAL_ECHOLNPGM("Open Circuit");
|
||||||
else if (max6675_temp & 2)
|
else if (max6675_temp & 2)
|
||||||
SERIAL_ERRORLNPGM("Short to GND");
|
SERIAL_ECHOLNPGM("Short to GND");
|
||||||
else if (max6675_temp & 4)
|
else if (max6675_temp & 4)
|
||||||
SERIAL_ERRORLNPGM("Short to VCC");
|
SERIAL_ECHOLNPGM("Short to VCC");
|
||||||
#else
|
#else
|
||||||
SERIAL_ERRORLNPGM("MAX6675");
|
SERIAL_ECHOLNPGM("MAX6675");
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
// Thermocouple open
|
// Thermocouple open
|
||||||
|
@ -2365,8 +2365,8 @@ void Temperature::isr() {
|
||||||
UNUSED(e);
|
UNUSED(e);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
SERIAL_PROTOCOLCHAR_P(port, ' ');
|
SERIAL_CHAR_P(port, ' ');
|
||||||
SERIAL_PROTOCOLCHAR_P(port,
|
SERIAL_CHAR_P(port,
|
||||||
#if HAS_TEMP_CHAMBER && HAS_HEATED_BED && HAS_TEMP_HOTEND
|
#if HAS_TEMP_CHAMBER && HAS_HEATED_BED && HAS_TEMP_HOTEND
|
||||||
e == -2 ? 'C' : e == -1 ? 'B' : 'T'
|
e == -2 ? 'C' : e == -1 ? 'B' : 'T'
|
||||||
#elif HAS_HEATED_BED && HAS_TEMP_HOTEND
|
#elif HAS_HEATED_BED && HAS_TEMP_HOTEND
|
||||||
|
@ -2378,14 +2378,14 @@ void Temperature::isr() {
|
||||||
#endif
|
#endif
|
||||||
);
|
);
|
||||||
#if HOTENDS > 1
|
#if HOTENDS > 1
|
||||||
if (e >= 0) SERIAL_PROTOCOLCHAR_P(port, '0' + e);
|
if (e >= 0) SERIAL_CHAR_P(port, '0' + e);
|
||||||
#endif
|
#endif
|
||||||
SERIAL_PROTOCOLCHAR_P(port, ':');
|
SERIAL_CHAR_P(port, ':');
|
||||||
SERIAL_PROTOCOL_P(port, c);
|
SERIAL_ECHO_P(port, c);
|
||||||
SERIAL_PROTOCOLPAIR_P(port, " /" , t);
|
SERIAL_ECHOPAIR_P(port, " /" , t);
|
||||||
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
#if ENABLED(SHOW_TEMP_ADC_VALUES)
|
||||||
SERIAL_PROTOCOLPAIR_P(port, " (", r / OVERSAMPLENR);
|
SERIAL_ECHOPAIR_P(port, " (", r / OVERSAMPLENR);
|
||||||
SERIAL_PROTOCOLCHAR_P(port, ')');
|
SERIAL_CHAR_P(port, ')');
|
||||||
#endif
|
#endif
|
||||||
delay(2);
|
delay(2);
|
||||||
}
|
}
|
||||||
|
@ -2435,17 +2435,17 @@ void Temperature::isr() {
|
||||||
, e
|
, e
|
||||||
);
|
);
|
||||||
#endif
|
#endif
|
||||||
SERIAL_PROTOCOLPGM_P(port, " @:");
|
SERIAL_ECHOPGM_P(port, " @:");
|
||||||
SERIAL_PROTOCOL_P(port, getHeaterPower(target_extruder));
|
SERIAL_ECHO_P(port, getHeaterPower(target_extruder));
|
||||||
#if HAS_HEATED_BED
|
#if HAS_HEATED_BED
|
||||||
SERIAL_PROTOCOLPGM_P(port, " B@:");
|
SERIAL_ECHOPGM_P(port, " B@:");
|
||||||
SERIAL_PROTOCOL_P(port, getHeaterPower(-1));
|
SERIAL_ECHO_P(port, getHeaterPower(-1));
|
||||||
#endif
|
#endif
|
||||||
#if HOTENDS > 1
|
#if HOTENDS > 1
|
||||||
HOTEND_LOOP() {
|
HOTEND_LOOP() {
|
||||||
SERIAL_PROTOCOLPAIR_P(port, " @", e);
|
SERIAL_ECHOPAIR_P(port, " @", e);
|
||||||
SERIAL_PROTOCOLCHAR_P(port, ':');
|
SERIAL_CHAR_P(port, ':');
|
||||||
SERIAL_PROTOCOL_P(port, getHeaterPower(e));
|
SERIAL_ECHO_P(port, getHeaterPower(e));
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
@ -2528,11 +2528,11 @@ void Temperature::isr() {
|
||||||
next_temp_ms = now + 1000UL;
|
next_temp_ms = now + 1000UL;
|
||||||
print_heater_states(target_extruder);
|
print_heater_states(target_extruder);
|
||||||
#if TEMP_RESIDENCY_TIME > 0
|
#if TEMP_RESIDENCY_TIME > 0
|
||||||
SERIAL_PROTOCOLPGM(" W:");
|
SERIAL_ECHOPGM(" W:");
|
||||||
if (residency_start_ms)
|
if (residency_start_ms)
|
||||||
SERIAL_PROTOCOL(long((((TEMP_RESIDENCY_TIME) * 1000UL) - (now - residency_start_ms)) / 1000UL));
|
SERIAL_ECHO(long((((TEMP_RESIDENCY_TIME) * 1000UL) - (now - residency_start_ms)) / 1000UL));
|
||||||
else
|
else
|
||||||
SERIAL_PROTOCOLCHAR('?');
|
SERIAL_CHAR('?');
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
@ -2651,11 +2651,11 @@ void Temperature::isr() {
|
||||||
next_temp_ms = now + 1000UL;
|
next_temp_ms = now + 1000UL;
|
||||||
print_heater_states(active_extruder);
|
print_heater_states(active_extruder);
|
||||||
#if TEMP_BED_RESIDENCY_TIME > 0
|
#if TEMP_BED_RESIDENCY_TIME > 0
|
||||||
SERIAL_PROTOCOLPGM(" W:");
|
SERIAL_ECHOPGM(" W:");
|
||||||
if (residency_start_ms)
|
if (residency_start_ms)
|
||||||
SERIAL_PROTOCOL(long((((TEMP_BED_RESIDENCY_TIME) * 1000UL) - (now - residency_start_ms)) / 1000UL));
|
SERIAL_ECHO(long((((TEMP_BED_RESIDENCY_TIME) * 1000UL) - (now - residency_start_ms)) / 1000UL));
|
||||||
else
|
else
|
||||||
SERIAL_PROTOCOLCHAR('?');
|
SERIAL_CHAR('?');
|
||||||
#endif
|
#endif
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
|
|
|
@ -553,8 +553,7 @@ void tool_change(const uint8_t tmp_extruder, const float fr_mm_s/*=0.0*/, bool n
|
||||||
#endif
|
#endif
|
||||||
if (should_swap) {
|
if (should_swap) {
|
||||||
if (too_cold) {
|
if (too_cold) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG(MSG_ERR_HOTEND_TOO_COLD);
|
||||||
SERIAL_ERRORLNPGM(MSG_ERR_HOTEND_TOO_COLD);
|
|
||||||
#if ENABLED(SINGLENOZZLE)
|
#if ENABLED(SINGLENOZZLE)
|
||||||
active_extruder = tmp_extruder;
|
active_extruder = tmp_extruder;
|
||||||
return;
|
return;
|
||||||
|
|
|
@ -140,11 +140,11 @@ inline void report_pin_state_extended(pin_t pin, bool ignore, bool extended = fa
|
||||||
if (pin == 46 || pin == 47) {
|
if (pin == 46 || pin == 47) {
|
||||||
if (pin == 46) {
|
if (pin == 46) {
|
||||||
print_input_or_output(GET_OUTPUT(46));
|
print_input_or_output(GET_OUTPUT(46));
|
||||||
SERIAL_PROTOCOL(READ(46));
|
SERIAL_ECHO(READ(46));
|
||||||
}
|
}
|
||||||
else if (pin == 47) {
|
else if (pin == 47) {
|
||||||
print_input_or_output(GET_OUTPUT(47));
|
print_input_or_output(GET_OUTPUT(47));
|
||||||
SERIAL_PROTOCOL(READ(47));
|
SERIAL_ECHO(READ(47));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
|
@ -160,14 +160,14 @@ inline void report_pin_state_extended(pin_t pin, bool ignore, bool extended = fa
|
||||||
// because this could interfere with inductive/capacitive
|
// because this could interfere with inductive/capacitive
|
||||||
// sensors (high impedance voltage divider) and with PT100 amplifier
|
// sensors (high impedance voltage divider) and with PT100 amplifier
|
||||||
print_input_or_output(false);
|
print_input_or_output(false);
|
||||||
SERIAL_PROTOCOL(digitalRead_mod(pin));
|
SERIAL_ECHO(digitalRead_mod(pin));
|
||||||
}
|
}
|
||||||
else if (pwm_status(pin)) {
|
else if (pwm_status(pin)) {
|
||||||
// do nothing
|
// do nothing
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
print_input_or_output(true);
|
print_input_or_output(true);
|
||||||
SERIAL_PROTOCOL(digitalRead_mod(pin));
|
SERIAL_ECHO(digitalRead_mod(pin));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
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
|
||||||
|
@ -193,23 +193,23 @@ inline void report_pin_state_extended(pin_t pin, bool ignore, bool extended = fa
|
||||||
if (extended) {
|
if (extended) {
|
||||||
#if AVR_AT90USB1286_FAMILY //Teensy IDEs don't know about these pins so must use FASTIO
|
#if AVR_AT90USB1286_FAMILY //Teensy IDEs don't know about these pins so must use FASTIO
|
||||||
if (pin == 46 || pin == 47) {
|
if (pin == 46 || pin == 47) {
|
||||||
SERIAL_PROTOCOL_SP(12);
|
SERIAL_ECHO_SP(12);
|
||||||
if (pin == 46) {
|
if (pin == 46) {
|
||||||
print_input_or_output(GET_OUTPUT(46));
|
print_input_or_output(GET_OUTPUT(46));
|
||||||
SERIAL_PROTOCOL(READ(46));
|
SERIAL_ECHO(READ(46));
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
print_input_or_output(GET_OUTPUT(47));
|
print_input_or_output(GET_OUTPUT(47));
|
||||||
SERIAL_PROTOCOL(READ(47));
|
SERIAL_ECHO(READ(47));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
#endif
|
#endif
|
||||||
{
|
{
|
||||||
if (GET_PINMODE(pin)) {
|
if (GET_PINMODE(pin)) {
|
||||||
SERIAL_PROTOCOL_SP(MAX_NAME_LENGTH - 16);
|
SERIAL_ECHO_SP(MAX_NAME_LENGTH - 16);
|
||||||
print_input_or_output(true);
|
print_input_or_output(true);
|
||||||
SERIAL_PROTOCOL(digitalRead_mod(pin));
|
SERIAL_ECHO(digitalRead_mod(pin));
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
if (IS_ANALOG(pin)) {
|
if (IS_ANALOG(pin)) {
|
||||||
|
@ -221,7 +221,7 @@ inline void report_pin_state_extended(pin_t pin, bool ignore, bool extended = fa
|
||||||
SERIAL_ECHO_SP(MAX_NAME_LENGTH - 16); // add padding if not an analog pin
|
SERIAL_ECHO_SP(MAX_NAME_LENGTH - 16); // add padding if not an analog pin
|
||||||
|
|
||||||
print_input_or_output(false);
|
print_input_or_output(false);
|
||||||
SERIAL_PROTOCOL(digitalRead_mod(pin));
|
SERIAL_ECHO(digitalRead_mod(pin));
|
||||||
}
|
}
|
||||||
//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
|
||||||
|
|
|
@ -905,7 +905,7 @@ int SdBaseFile::peek() {
|
||||||
// print uint8_t with width 2
|
// print uint8_t with width 2
|
||||||
static void print2u(const uint8_t v) {
|
static void print2u(const uint8_t v) {
|
||||||
if (v < 10) SERIAL_CHAR('0');
|
if (v < 10) SERIAL_CHAR('0');
|
||||||
SERIAL_ECHO_F(v, DEC);
|
SERIAL_ECHO(int(v));
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|
|
@ -108,7 +108,7 @@ static inline uint16_t FAT_YEAR(uint16_t fatDate) { return 1980 + (fatDate >> 9)
|
||||||
*
|
*
|
||||||
* \return Extracted month [1,12]
|
* \return Extracted month [1,12]
|
||||||
*/
|
*/
|
||||||
static inline uint8_t FAT_MONTH(uint16_t fatDate) { return (fatDate >> 5) & 0XF; }
|
static inline uint8_t FAT_MONTH(uint16_t fatDate) { return (fatDate >> 5) & 0xF; }
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* day part of FAT directory date field
|
* day part of FAT directory date field
|
||||||
|
|
|
@ -228,10 +228,10 @@ void CardReader::lsDive(const char *prepend, SdFile parent, const char * const m
|
||||||
|
|
||||||
case LS_SerialPrint:
|
case LS_SerialPrint:
|
||||||
createFilename(filename, p);
|
createFilename(filename, p);
|
||||||
if (prepend) SERIAL_PROTOCOL_P(port, prepend);
|
if (prepend) SERIAL_ECHO_P(port, prepend);
|
||||||
SERIAL_PROTOCOL_P(port, filename);
|
SERIAL_ECHO_P(port, filename);
|
||||||
SERIAL_PROTOCOLCHAR_P(port, ' ');
|
SERIAL_CHAR_P(port, ' ');
|
||||||
SERIAL_PROTOCOLLN_P(port, p.fileSize);
|
SERIAL_ECHOLN_P(port, p.fileSize);
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case LS_GetFilename:
|
case LS_GetFilename:
|
||||||
|
@ -305,8 +305,8 @@ void CardReader::ls(
|
||||||
);
|
);
|
||||||
|
|
||||||
// Print /LongNamePart to serial output
|
// Print /LongNamePart to serial output
|
||||||
SERIAL_PROTOCOLCHAR_P(port, '/');
|
SERIAL_CHAR_P(port, '/');
|
||||||
SERIAL_PROTOCOL_P(port, longFilename[0] ? longFilename : "???");
|
SERIAL_ECHO_P(port, longFilename[0] ? longFilename : "???");
|
||||||
|
|
||||||
// If the filename was printed then that's it
|
// If the filename was printed then that's it
|
||||||
if (!flag.filenameIsDir) break;
|
if (!flag.filenameIsDir) break;
|
||||||
|
@ -373,21 +373,15 @@ void CardReader::initsd() {
|
||||||
#endif
|
#endif
|
||||||
) {
|
) {
|
||||||
//if (!sd2card.init(SPI_HALF_SPEED,SDSS))
|
//if (!sd2card.init(SPI_HALF_SPEED,SDSS))
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(MSG_SD_INIT_FAIL);
|
||||||
SERIAL_ECHOLNPGM(MSG_SD_INIT_FAIL);
|
|
||||||
}
|
|
||||||
else if (!volume.init(&sd2card)) {
|
|
||||||
SERIAL_ERROR_START();
|
|
||||||
SERIAL_ERRORLNPGM(MSG_SD_VOL_INIT_FAIL);
|
|
||||||
}
|
|
||||||
else if (!root.openRoot(&volume)) {
|
|
||||||
SERIAL_ERROR_START();
|
|
||||||
SERIAL_ERRORLNPGM(MSG_SD_OPENROOT_FAIL);
|
|
||||||
}
|
}
|
||||||
|
else if (!volume.init(&sd2card))
|
||||||
|
SERIAL_ERROR_MSG(MSG_SD_VOL_INIT_FAIL);
|
||||||
|
else if (!root.openRoot(&volume))
|
||||||
|
SERIAL_ERROR_MSG(MSG_SD_OPENROOT_FAIL);
|
||||||
else {
|
else {
|
||||||
flag.cardOK = true;
|
flag.cardOK = true;
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG(MSG_SD_CARD_OK);
|
||||||
SERIAL_ECHOLNPGM(MSG_SD_CARD_OK);
|
|
||||||
}
|
}
|
||||||
setroot();
|
setroot();
|
||||||
}
|
}
|
||||||
|
@ -462,9 +456,7 @@ void CardReader::openFile(char * const path, const bool read, const bool subcall
|
||||||
if (isFileOpen()) { // Replacing current file or doing a subroutine
|
if (isFileOpen()) { // Replacing current file or doing a subroutine
|
||||||
if (subcall) {
|
if (subcall) {
|
||||||
if (file_subcall_ctr > SD_PROCEDURE_DEPTH - 1) {
|
if (file_subcall_ctr > SD_PROCEDURE_DEPTH - 1) {
|
||||||
SERIAL_ERROR_START();
|
SERIAL_ERROR_MSG("trying to call sub-gcode files with too many levels. MAX level is:" STRINGIFY(SD_PROCEDURE_DEPTH));
|
||||||
SERIAL_ERRORPGM("trying to call sub-gcode files with too many levels. MAX level is:");
|
|
||||||
SERIAL_ERRORLN((int)SD_PROCEDURE_DEPTH);
|
|
||||||
kill();
|
kill();
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
@ -482,10 +474,8 @@ void CardReader::openFile(char * const path, const bool read, const bool subcall
|
||||||
else
|
else
|
||||||
doing = 1;
|
doing = 1;
|
||||||
}
|
}
|
||||||
else if (subcall) { // Returning from a subcall?
|
else if (subcall) // Returning from a subcall?
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_MSG("END SUBROUTINE");
|
||||||
SERIAL_ECHOLNPGM("END SUBROUTINE");
|
|
||||||
}
|
|
||||||
else { // Opening fresh file
|
else { // Opening fresh file
|
||||||
doing = 2;
|
doing = 2;
|
||||||
file_subcall_ctr = 0; // Reset procedure depth in case user cancels print while in procedure
|
file_subcall_ctr = 0; // Reset procedure depth in case user cancels print while in procedure
|
||||||
|
@ -508,26 +498,26 @@ void CardReader::openFile(char * const path, const bool read, const bool subcall
|
||||||
if (file.open(curDir, fname, O_READ)) {
|
if (file.open(curDir, fname, O_READ)) {
|
||||||
filesize = file.fileSize();
|
filesize = file.fileSize();
|
||||||
sdpos = 0;
|
sdpos = 0;
|
||||||
SERIAL_PROTOCOLPAIR(MSG_SD_FILE_OPENED, fname);
|
SERIAL_ECHOPAIR(MSG_SD_FILE_OPENED, fname);
|
||||||
SERIAL_PROTOCOLLNPAIR(MSG_SD_SIZE, filesize);
|
SERIAL_ECHOLNPAIR(MSG_SD_SIZE, filesize);
|
||||||
SERIAL_PROTOCOLLNPGM(MSG_SD_FILE_SELECTED);
|
SERIAL_ECHOLNPGM(MSG_SD_FILE_SELECTED);
|
||||||
|
|
||||||
getfilename(0, fname);
|
getfilename(0, fname);
|
||||||
ui.set_status(longFilename[0] ? longFilename : fname);
|
ui.set_status(longFilename[0] ? longFilename : fname);
|
||||||
//if (longFilename[0]) {
|
//if (longFilename[0]) {
|
||||||
// SERIAL_PROTOCOLPAIR(MSG_SD_FILE_LONG_NAME, longFilename);
|
// SERIAL_ECHOPAIR(MSG_SD_FILE_LONG_NAME, longFilename);
|
||||||
//}
|
//}
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
SERIAL_PROTOCOLPAIR(MSG_SD_OPEN_FILE_FAIL, fname);
|
SERIAL_ECHOPAIR(MSG_SD_OPEN_FILE_FAIL, fname);
|
||||||
SERIAL_PROTOCOLCHAR('.');
|
SERIAL_CHAR('.');
|
||||||
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_ECHOPAIR(MSG_SD_OPEN_FILE_FAIL, fname);
|
||||||
SERIAL_PROTOCOLCHAR('.');
|
SERIAL_CHAR('.');
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
|
@ -536,7 +526,7 @@ void CardReader::openFile(char * const path, const bool read, const bool subcall
|
||||||
#if ENABLED(EMERGENCY_PARSER)
|
#if ENABLED(EMERGENCY_PARSER)
|
||||||
emergency_parser.disable();
|
emergency_parser.disable();
|
||||||
#endif
|
#endif
|
||||||
SERIAL_PROTOCOLLNPAIR(MSG_SD_WRITE_TO_FILE, fname);
|
SERIAL_ECHOLNPAIR(MSG_SD_WRITE_TO_FILE, fname);
|
||||||
ui.set_status(fname);
|
ui.set_status(fname);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -552,17 +542,15 @@ void CardReader::removeFile(const char * const name) {
|
||||||
if (!fname) return;
|
if (!fname) return;
|
||||||
|
|
||||||
if (file.remove(curDir, fname)) {
|
if (file.remove(curDir, fname)) {
|
||||||
SERIAL_PROTOCOLPGM("File deleted:");
|
SERIAL_ECHOLNPAIR("File deleted:", fname);
|
||||||
SERIAL_PROTOCOLLN(fname);
|
|
||||||
sdpos = 0;
|
sdpos = 0;
|
||||||
#if ENABLED(SDCARD_SORT_ALPHA)
|
#if ENABLED(SDCARD_SORT_ALPHA)
|
||||||
presort();
|
presort();
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
SERIAL_PROTOCOLPGM("Deletion failed, File: ");
|
SERIAL_ECHOPAIR("Deletion failed, File: ", fname);
|
||||||
SERIAL_PROTOCOL(fname);
|
SERIAL_CHAR('.');
|
||||||
SERIAL_PROTOCOLCHAR('.');
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -572,13 +560,13 @@ void CardReader::getStatus(
|
||||||
#endif
|
#endif
|
||||||
) {
|
) {
|
||||||
if (flag.cardOK && flag.sdprinting) {
|
if (flag.cardOK && flag.sdprinting) {
|
||||||
SERIAL_PROTOCOLPGM_P(port, MSG_SD_PRINTING_BYTE);
|
SERIAL_ECHOPGM_P(port, MSG_SD_PRINTING_BYTE);
|
||||||
SERIAL_PROTOCOL_P(port, sdpos);
|
SERIAL_ECHO_P(port, sdpos);
|
||||||
SERIAL_PROTOCOLCHAR_P(port, '/');
|
SERIAL_CHAR_P(port, '/');
|
||||||
SERIAL_PROTOCOLLN_P(port, filesize);
|
SERIAL_ECHOLN_P(port, filesize);
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
SERIAL_PROTOCOLLNPGM_P(port, MSG_SD_NOT_PRINTING);
|
SERIAL_ECHOLNPGM_P(port, MSG_SD_NOT_PRINTING);
|
||||||
}
|
}
|
||||||
|
|
||||||
void CardReader::write_command(char *buf) {
|
void CardReader::write_command(char *buf) {
|
||||||
|
@ -595,10 +583,8 @@ void CardReader::write_command(char *buf) {
|
||||||
end[2] = '\n';
|
end[2] = '\n';
|
||||||
end[3] = '\0';
|
end[3] = '\0';
|
||||||
file.write(begin);
|
file.write(begin);
|
||||||
if (file.writeError) {
|
|
||||||
SERIAL_ERROR_START();
|
if (file.writeError) SERIAL_ERROR_MSG(MSG_SD_ERR_WRITE_TO_FILE);
|
||||||
SERIAL_ERRORLNPGM(MSG_SD_ERR_WRITE_TO_FILE);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
//
|
//
|
||||||
|
@ -715,8 +701,8 @@ const char* CardReader::diveToFile(SdFile*& curDir, const char * const path, con
|
||||||
if (echo) SERIAL_ECHOLN(dosSubdirname);
|
if (echo) SERIAL_ECHOLN(dosSubdirname);
|
||||||
|
|
||||||
if (!myDir.open(curDir, dosSubdirname, O_READ)) {
|
if (!myDir.open(curDir, dosSubdirname, O_READ)) {
|
||||||
SERIAL_PROTOCOLPAIR(MSG_SD_OPEN_FILE_FAIL, dosSubdirname);
|
SERIAL_ECHOPAIR(MSG_SD_OPEN_FILE_FAIL, dosSubdirname);
|
||||||
SERIAL_PROTOCOLCHAR('.');
|
SERIAL_CHAR('.');
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
@ -740,8 +726,7 @@ void CardReader::chdir(const char * relpath) {
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
SERIAL_ECHO_START();
|
SERIAL_ECHO_START();
|
||||||
SERIAL_ECHOPGM(MSG_SD_CANT_ENTER_SUBDIR);
|
SERIAL_ECHOLNPAIR(MSG_SD_CANT_ENTER_SUBDIR, relpath);
|
||||||
SERIAL_ECHOLN(relpath);
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -1081,12 +1066,12 @@ void CardReader::printingHasFinished() {
|
||||||
if (!flag.cardOK) return;
|
if (!flag.cardOK) return;
|
||||||
if (recovery.file.isOpen()) return;
|
if (recovery.file.isOpen()) return;
|
||||||
if (!recovery.file.open(&root, job_recovery_file_name, read ? O_READ : O_CREAT | O_WRITE | O_TRUNC | O_SYNC)) {
|
if (!recovery.file.open(&root, job_recovery_file_name, read ? O_READ : O_CREAT | O_WRITE | O_TRUNC | O_SYNC)) {
|
||||||
SERIAL_PROTOCOLPAIR(MSG_SD_OPEN_FILE_FAIL, job_recovery_file_name);
|
SERIAL_ECHOPAIR(MSG_SD_OPEN_FILE_FAIL, job_recovery_file_name);
|
||||||
SERIAL_PROTOCOLCHAR('.');
|
SERIAL_CHAR('.');
|
||||||
SERIAL_EOL();
|
SERIAL_EOL();
|
||||||
}
|
}
|
||||||
else if (!read)
|
else if (!read)
|
||||||
SERIAL_PROTOCOLLNPAIR(MSG_SD_WRITE_TO_FILE, job_recovery_file_name);
|
SERIAL_ECHOLNPAIR(MSG_SD_WRITE_TO_FILE, job_recovery_file_name);
|
||||||
}
|
}
|
||||||
|
|
||||||
// Removing the job recovery file currently requires closing
|
// Removing the job recovery file currently requires closing
|
||||||
|
@ -1097,7 +1082,7 @@ void CardReader::printingHasFinished() {
|
||||||
//closefile();
|
//closefile();
|
||||||
removeFile(job_recovery_file_name);
|
removeFile(job_recovery_file_name);
|
||||||
#if ENABLED(DEBUG_POWER_LOSS_RECOVERY)
|
#if ENABLED(DEBUG_POWER_LOSS_RECOVERY)
|
||||||
SERIAL_PROTOCOLPGM("Power-loss file delete");
|
SERIAL_ECHOPGM("Power-loss file delete");
|
||||||
serialprintPGM(jobRecoverFileExists() ? PSTR(" failed.\n") : PSTR("d.\n"));
|
serialprintPGM(jobRecoverFileExists() ? PSTR(" failed.\n") : PSTR("d.\n"));
|
||||||
#endif
|
#endif
|
||||||
}
|
}
|
||||||
|
|
Reference in a new issue