ed790c9fa2
- Increment to v1.1d due to interface tweaks. - Based on GUI dev feedback, the toggle overrides report was removed and replace with showing “accessory state”. This shows a character if a particular accessory is enabled, like the spindle or flood coolant. These can be directly altered by the toggle overrides, so when they execute, a GUI will be able to observe the state altering as feedback. - Altered the real-time feed rate to show real-time spindle speed as well. It was an over-sight on my part. It’s needed because it’s hard to know what the current spindle speed is when overrides are altering it. Especially during something like a laser cutting job when its important to know how spindle speed overrides are effecting things. - Real-time spindle speed is not shown if VARIABLE_SPINDLE is disabled. The old real-time feed rate data field will show instead. - Compile-time option data is now included in another message immediately following the build info version string, starting with `[OPT:`. A character code follows the data type name with each indicating a particular option enabled or disabled. This will help immensely with debugging Grbl as well as help GUIs know exactly how Grbl was compiled. - These interface changes are detailed in the updated documentation. - Reduced the default planner buffer size from 17 to 16. Needed to free up some memory… - For increasing the serial TX buffer size from 90 to 104 bytes. The addition of real-time spindle speeds and accessory enable data required a bigger buffer. This is to ensure Grbl is performing at optimal levels. - Refactored parts of the spindle and coolant control code to make it more consistent to each other and how it was called. It was a little messy. The changes made it easier to track what each function call was doing based on what was calling it. - Created a couple of new get_state functions for the spindle and coolant. These are called by the accessory state report to look directly at the pin state, rather than track how it was set. This guarantees that the state is reported correctly. - Updated the g-code parser, parking motion, sleep mode, and spindle stop calls to refactored spindle and coolant code. - Added a compile-time option to enable homing individual axes, rather than having only the main homing cycle. The actual use case for this is pretty rare. It’s not recommended you enable this, unless you have a specific application for it. Otherwise, just alter the homing cycle itself. - Refactored the printFloat() function to not show a decimal point if there are no trailing values after it. For example, `1.` now shows `1`. - Fixed an issue regarding spindle speed overrides no being applied to blocks without motions. - Removed the toggle_ovr_mask system variable and replaced with spindle_stop_ovr system variable. Coolant toggles don’t need to be tracked. - Updated README
931 lines
37 KiB
C
931 lines
37 KiB
C
/*
|
|
report.c - reporting and messaging methods
|
|
Part of Grbl
|
|
|
|
Copyright (c) 2012-2016 Sungeun K. Jeon for Gnea Research LLC
|
|
|
|
Grbl is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Grbl is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Grbl. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/*
|
|
This file functions as the primary feedback interface for Grbl. Any outgoing data, such
|
|
as the protocol status messages, feedback messages, and status reports, are stored here.
|
|
For the most part, these functions primarily are called from protocol.c methods. If a
|
|
different style feedback is desired (i.e. JSON), then a user can change these following
|
|
methods to accomodate their needs.
|
|
*/
|
|
|
|
#include "grbl.h"
|
|
|
|
|
|
// Internal report utilities to reduce flash with repetitive tasks turned into functions.
|
|
void report_util_setting_prefix(uint8_t n) { serial_write('$'); print_uint8_base10(n); serial_write('='); }
|
|
static void report_util_line_feed() { printPgmString(PSTR("\r\n")); }
|
|
static void report_util_feedback_line_feed() { serial_write(']'); report_util_line_feed(); }
|
|
// static void report_util_comment_line_feed() { serial_write(')'); report_util_line_feed(); }
|
|
static void report_util_axis_values(float *axis_value) {
|
|
uint8_t idx;
|
|
for (idx=0; idx<N_AXIS; idx++) {
|
|
printFloat_CoordValue(axis_value[idx]);
|
|
if (idx < (N_AXIS-1)) { serial_write(','); }
|
|
}
|
|
}
|
|
|
|
// static void report_util_setting_string(uint8_t n) {
|
|
// serial_write(' ');
|
|
// serial_write('(');
|
|
// switch(n) {
|
|
// case 0: printPgmString(PSTR("stp pulse:us")); break;
|
|
// case 1: printPgmString(PSTR("idl delay:ms")); break;
|
|
// case 2: printPgmString(PSTR("stp inv:msk")); break;
|
|
// case 3: printPgmString(PSTR("dir inv:msk")); break;
|
|
// case 4: printPgmString(PSTR("stp enbl inv")); break;
|
|
// case 5: printPgmString(PSTR("lim inv")); break;
|
|
// case 6: printPgmString(PSTR("prb inv")); break;
|
|
// case 10: printPgmString(PSTR("rpt:msk")); break;
|
|
// case 11: printPgmString(PSTR("jnc dev:mm")); break;
|
|
// case 12: printPgmString(PSTR("arc tol:mm")); break;
|
|
// case 13: printPgmString(PSTR("rpt inch")); break;
|
|
// case 20: printPgmString(PSTR("sft lim")); break;
|
|
// case 21: printPgmString(PSTR("hrd lim")); break;
|
|
// case 22: printPgmString(PSTR("hm cyc")); break;
|
|
// case 23: printPgmString(PSTR("hm dir inv:msk")); break;
|
|
// case 24: printPgmString(PSTR("hm feed:mm/min")); break;
|
|
// case 25: printPgmString(PSTR("hm seek:mm/min")); break;
|
|
// case 26: printPgmString(PSTR("hm delay:ms")); break;
|
|
// case 27: printPgmString(PSTR("hm off:mm")); break;
|
|
// case 30: printPgmString(PSTR("rpm max")); break;
|
|
// case 31: printPgmString(PSTR("rpm min")); break;
|
|
// case 32: printPgmString(PSTR("laser")); break;
|
|
// default:
|
|
// n -= AXIS_SETTINGS_START_VAL;
|
|
// uint8_t idx = 0;
|
|
// while (n < 10) {
|
|
// if (n<10) {
|
|
// print_uint8_base10(n+idx);
|
|
// switch (idx) {
|
|
// case 0: printPgmString(PSTR(":stp/mm")); break;
|
|
// case 1: printPgmString(PSTR(":mm/min")); break;
|
|
// case 2: printPgmString(PSTR(":mm/s^2")); break;
|
|
// case 3: printPgmString(PSTR(":mm max")); break;
|
|
// }
|
|
// } else {
|
|
// n -= 10;
|
|
// idx++;
|
|
// }
|
|
// }
|
|
// }
|
|
// report_util_comment_line_feed();
|
|
// }
|
|
|
|
static void report_util_uint8_setting(uint8_t n, int val) {
|
|
report_util_setting_prefix(n);
|
|
print_uint8_base10(val);
|
|
report_util_line_feed();
|
|
// report_util_setting_string(n);
|
|
}
|
|
static void report_util_float_setting(uint8_t n, float val, uint8_t n_decimal) {
|
|
report_util_setting_prefix(n);
|
|
printFloat(val,n_decimal);
|
|
report_util_line_feed();
|
|
// report_util_setting_string(n);
|
|
}
|
|
|
|
|
|
// Handles the primary confirmation protocol response for streaming interfaces and human-feedback.
|
|
// For every incoming line, this method responds with an 'ok' for a successful command or an
|
|
// 'error:' to indicate some error event with the line or some critical system error during
|
|
// operation. Errors events can originate from the g-code parser, settings module, or asynchronously
|
|
// from a critical error, such as a triggered hard limit. Interface should always monitor for these
|
|
// responses.
|
|
// NOTE: In REPORT_GUI_MODE, all error codes are greater than zero.
|
|
void report_status_message(uint8_t status_code)
|
|
{
|
|
switch(status_code) {
|
|
case STATUS_OK: // STATUS_OK
|
|
printPgmString(PSTR("ok\r\n")); break;
|
|
default:
|
|
#ifdef REPORT_GUI_MODE
|
|
printPgmString(PSTR("error:"));
|
|
print_uint8_base10(status_code);
|
|
#else
|
|
printPgmString(PSTR("error: "));
|
|
switch(status_code) {
|
|
case STATUS_EXPECTED_COMMAND_LETTER:
|
|
printPgmString(PSTR("Expected command letter")); break;
|
|
case STATUS_BAD_NUMBER_FORMAT:
|
|
printPgmString(PSTR("Bad number format")); break;
|
|
case STATUS_INVALID_STATEMENT:
|
|
printPgmString(PSTR("Invalid statement")); break;
|
|
case STATUS_NEGATIVE_VALUE:
|
|
printPgmString(PSTR("Value < 0")); break;
|
|
case STATUS_SETTING_DISABLED:
|
|
printPgmString(PSTR("Setting disabled")); break;
|
|
case STATUS_SETTING_STEP_PULSE_MIN:
|
|
printPgmString(PSTR("Value < 3 usec")); break;
|
|
case STATUS_SETTING_READ_FAIL:
|
|
printPgmString(PSTR("EEPROM read fail. Using defaults")); break;
|
|
case STATUS_IDLE_ERROR:
|
|
printPgmString(PSTR("Not idle")); break;
|
|
case STATUS_SYSTEM_GC_LOCK:
|
|
printPgmString(PSTR("G-code lock")); break;
|
|
case STATUS_SOFT_LIMIT_ERROR:
|
|
printPgmString(PSTR("Homing not enabled")); break;
|
|
case STATUS_OVERFLOW:
|
|
printPgmString(PSTR("Line overflow")); break;
|
|
#ifdef MAX_STEP_RATE_HZ
|
|
case STATUS_MAX_STEP_RATE_EXCEEDED:
|
|
printPgmString(PSTR("Step rate > 30kHz")); break;
|
|
#endif
|
|
case STATUS_CHECK_DOOR:
|
|
printPgmString(PSTR("Check Door")); break;
|
|
// case STATUS_LINE_LENGTH_EXCEEDED: // Supported on Grbl-Mega only.
|
|
// printPgmString(PSTR("Line length exceeded")); break;
|
|
case STATUS_TRAVEL_EXCEEDED:
|
|
printPgmString(PSTR("Travel exceeded")); break;
|
|
case STATUS_INVALID_JOG_COMMAND:
|
|
printPgmString(PSTR("Invalid jog command")); break;
|
|
// Common g-code parser errors.
|
|
case STATUS_GCODE_UNSUPPORTED_COMMAND:
|
|
printPgmString(PSTR("Unsupported command")); break;
|
|
case STATUS_GCODE_MODAL_GROUP_VIOLATION:
|
|
printPgmString(PSTR("Modal group violation")); break;
|
|
case STATUS_GCODE_UNDEFINED_FEED_RATE:
|
|
printPgmString(PSTR("Undefined feed rate")); break;
|
|
default:
|
|
// Remaining g-code parser errors with error codes
|
|
printPgmString(PSTR("Invalid gcode ID:"));
|
|
print_uint8_base10(status_code); // Print error code for user reference
|
|
}
|
|
#endif
|
|
report_util_line_feed();
|
|
}
|
|
}
|
|
|
|
// Prints alarm messages.
|
|
void report_alarm_message(int8_t alarm_code)
|
|
{
|
|
#ifdef REPORT_GUI_MODE
|
|
printPgmString(PSTR("ALARM:"));
|
|
print_uint8_base10(alarm_code);
|
|
#else
|
|
printPgmString(PSTR("ALARM: "));
|
|
switch (alarm_code) {
|
|
case ALARM_HARD_LIMIT_ERROR:
|
|
printPgmString(PSTR("Hard limit")); break;
|
|
case ALARM_SOFT_LIMIT_ERROR:
|
|
printPgmString(PSTR("Soft limit")); break;
|
|
case ALARM_ABORT_CYCLE:
|
|
printPgmString(PSTR("Abort during cycle")); break;
|
|
case ALARM_PROBE_FAIL_INITIAL:
|
|
case ALARM_PROBE_FAIL_CONTACT:
|
|
printPgmString(PSTR("Probe fail")); break;
|
|
case ALARM_HOMING_FAIL_RESET:
|
|
case ALARM_HOMING_FAIL_DOOR:
|
|
case ALARM_HOMING_FAIL_PULLOFF:
|
|
case ALARM_HOMING_FAIL_APPROACH:
|
|
printPgmString(PSTR("Homing fail")); break;
|
|
}
|
|
#endif
|
|
report_util_line_feed();
|
|
delay_ms(500); // Force delay to ensure message clears serial write buffer.
|
|
}
|
|
|
|
// Prints feedback messages. This serves as a centralized method to provide additional
|
|
// user feedback for things that are not of the status/alarm message protocol. These are
|
|
// messages such as setup warnings, switch toggling, and how to exit alarms.
|
|
// NOTE: For interfaces, messages are always placed within brackets. And if silent mode
|
|
// is installed, the message number codes are less than zero.
|
|
void report_feedback_message(uint8_t message_code)
|
|
{
|
|
printPgmString(PSTR("[MSG:"));
|
|
switch(message_code) {
|
|
case MESSAGE_CRITICAL_EVENT:
|
|
printPgmString(PSTR("Reset to continue")); break;
|
|
case MESSAGE_ALARM_LOCK:
|
|
printPgmString(PSTR("'$H'|'$X' to unlock")); break;
|
|
case MESSAGE_ALARM_UNLOCK:
|
|
printPgmString(PSTR("Caution: Unlocked")); break;
|
|
case MESSAGE_ENABLED:
|
|
printPgmString(PSTR("Enabled")); break;
|
|
case MESSAGE_DISABLED:
|
|
printPgmString(PSTR("Disabled")); break;
|
|
case MESSAGE_SAFETY_DOOR_AJAR:
|
|
printPgmString(PSTR("Check Door")); break;
|
|
case MESSAGE_CHECK_LIMITS:
|
|
printPgmString(PSTR("Check Limits")); break;
|
|
case MESSAGE_PROGRAM_END:
|
|
printPgmString(PSTR("Pgm End")); break;
|
|
case MESSAGE_RESTORE_DEFAULTS:
|
|
printPgmString(PSTR("Restoring defaults")); break;
|
|
case MESSAGE_SPINDLE_RESTORE:
|
|
printPgmString(PSTR("Restoring spindle")); break;
|
|
case MESSAGE_SLEEP_MODE:
|
|
printPgmString(PSTR("Sleeping")); break;
|
|
}
|
|
report_util_feedback_line_feed();
|
|
}
|
|
|
|
|
|
// Welcome message
|
|
void report_init_message()
|
|
{
|
|
printPgmString(PSTR("\r\nGrbl " GRBL_VERSION " ['$' for help]\r\n"));
|
|
}
|
|
|
|
// Grbl help message
|
|
void report_grbl_help() {
|
|
#ifdef REPORT_GUI_MODE
|
|
printPgmString(PSTR("[HLP:$$ $# $G $I $N $x=val $Nx=line $J=line $SLP $C $X $H ~ ! ? ctrl-x]\r\n"));
|
|
#else
|
|
printPgmString(PSTR("$$ (view Grbl settings)\r\n"
|
|
"$# (view # parameters)\r\n"
|
|
"$G (view parser state)\r\n"
|
|
"$I (view build info)\r\n"
|
|
"$N (view startup blocks)\r\n"
|
|
"$x=value (save Grbl setting)\r\n"
|
|
"$Nx=line (save startup block)\r\n"
|
|
"$J=line (jog)\r\n"
|
|
"$SLP (sleep mode)\r\n"
|
|
"$C (check gcode mode)\r\n"
|
|
"$X (kill alarm lock)\r\n"
|
|
"$H (run homing cycle)\r\n"
|
|
"~ (cycle start)\r\n"
|
|
"! (feed hold)\r\n"
|
|
"? (current status)\r\n"
|
|
"ctrl-x (reset Grbl)\r\n"));
|
|
#endif
|
|
}
|
|
|
|
|
|
// Grbl global settings print out.
|
|
// NOTE: The numbering scheme here must correlate to storing in settings.c
|
|
void report_grbl_settings() {
|
|
// Print Grbl settings.
|
|
#ifdef REPORT_GUI_MODE
|
|
|
|
report_util_uint8_setting(0,settings.pulse_microseconds);
|
|
report_util_uint8_setting(1,settings.stepper_idle_lock_time);
|
|
report_util_uint8_setting(2,settings.step_invert_mask);
|
|
report_util_uint8_setting(3,settings.dir_invert_mask);
|
|
report_util_uint8_setting(4,bit_istrue(settings.flags,BITFLAG_INVERT_ST_ENABLE));
|
|
report_util_uint8_setting(5,bit_istrue(settings.flags,BITFLAG_INVERT_LIMIT_PINS));
|
|
report_util_uint8_setting(6,bit_istrue(settings.flags,BITFLAG_INVERT_PROBE_PIN));
|
|
report_util_uint8_setting(10,settings.status_report_mask);
|
|
report_util_float_setting(11,settings.junction_deviation,N_DECIMAL_SETTINGVALUE);
|
|
report_util_float_setting(12,settings.arc_tolerance,N_DECIMAL_SETTINGVALUE);
|
|
report_util_uint8_setting(13,bit_istrue(settings.flags,BITFLAG_REPORT_INCHES));
|
|
report_util_uint8_setting(20,bit_istrue(settings.flags,BITFLAG_SOFT_LIMIT_ENABLE));
|
|
report_util_uint8_setting(21,bit_istrue(settings.flags,BITFLAG_HARD_LIMIT_ENABLE));
|
|
report_util_uint8_setting(22,bit_istrue(settings.flags,BITFLAG_HOMING_ENABLE));
|
|
report_util_uint8_setting(23,settings.homing_dir_mask);
|
|
report_util_float_setting(24,settings.homing_feed_rate,N_DECIMAL_SETTINGVALUE);
|
|
report_util_float_setting(25,settings.homing_seek_rate,N_DECIMAL_SETTINGVALUE);
|
|
report_util_uint8_setting(26,settings.homing_debounce_delay);
|
|
report_util_float_setting(27,settings.homing_pulloff,N_DECIMAL_SETTINGVALUE);
|
|
report_util_float_setting(30,settings.rpm_max,N_DECIMAL_RPMVALUE);
|
|
report_util_float_setting(31,settings.rpm_min,N_DECIMAL_RPMVALUE);
|
|
#ifdef VARIABLE_SPINDLE
|
|
report_util_uint8_setting(32,bit_istrue(settings.flags,BITFLAG_LASER_MODE));
|
|
#else
|
|
report_util_uint8_setting(32,0);
|
|
#endif
|
|
// Print axis settings
|
|
uint8_t idx, set_idx;
|
|
uint8_t val = AXIS_SETTINGS_START_VAL;
|
|
for (set_idx=0; set_idx<AXIS_N_SETTINGS; set_idx++) {
|
|
for (idx=0; idx<N_AXIS; idx++) {
|
|
switch (set_idx) {
|
|
case 0: report_util_float_setting(val+idx,settings.steps_per_mm[idx],N_DECIMAL_SETTINGVALUE); break;
|
|
case 1: report_util_float_setting(val+idx,settings.max_rate[idx],N_DECIMAL_SETTINGVALUE); break;
|
|
case 2: report_util_float_setting(val+idx,settings.acceleration[idx]/(60*60),N_DECIMAL_SETTINGVALUE); break;
|
|
case 3: report_util_float_setting(val+idx,-settings.max_travel[idx],N_DECIMAL_SETTINGVALUE); break;
|
|
}
|
|
}
|
|
val += AXIS_SETTINGS_INCREMENT;
|
|
}
|
|
|
|
#else
|
|
|
|
printPgmString(PSTR("$0=")); print_uint8_base10(settings.pulse_microseconds);
|
|
printPgmString(PSTR(" (step pulse, usec)\r\n$1=")); print_uint8_base10(settings.stepper_idle_lock_time);
|
|
printPgmString(PSTR(" (step idle delay, msec)\r\n$2=")); print_uint8_base10(settings.step_invert_mask);
|
|
printPgmString(PSTR(" (step port invert mask)\r\n$3=")); print_uint8_base10(settings.dir_invert_mask);
|
|
printPgmString(PSTR(" (dir port invert mask)\r\n$4=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_INVERT_ST_ENABLE));
|
|
printPgmString(PSTR(" (step enable invert, bool)\r\n$5=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_INVERT_LIMIT_PINS));
|
|
printPgmString(PSTR(" (limit pins invert, bool)\r\n$6=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_INVERT_PROBE_PIN));
|
|
printPgmString(PSTR(" (probe pin invert, bool)\r\n$10=")); print_uint8_base10(settings.status_report_mask);
|
|
printPgmString(PSTR(" (status report mask)\r\n$11=")); printFloat_SettingValue(settings.junction_deviation);
|
|
printPgmString(PSTR(" (junction deviation, mm)\r\n$12=")); printFloat_SettingValue(settings.arc_tolerance);
|
|
printPgmString(PSTR(" (arc tolerance, mm)\r\n$13=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_REPORT_INCHES));
|
|
printPgmString(PSTR(" (report inches, bool)\r\n$20=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_SOFT_LIMIT_ENABLE));
|
|
printPgmString(PSTR(" (soft limits, bool)\r\n$21=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_HARD_LIMIT_ENABLE));
|
|
printPgmString(PSTR(" (hard limits, bool)\r\n$22=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_HOMING_ENABLE));
|
|
printPgmString(PSTR(" (homing cycle, bool)\r\n$23=")); print_uint8_base10(settings.homing_dir_mask);
|
|
printPgmString(PSTR(" (homing dir invert mask\r\n$24=")); printFloat_SettingValue(settings.homing_feed_rate);
|
|
printPgmString(PSTR(" (homing feed, mm/min)\r\n$25=")); printFloat_SettingValue(settings.homing_seek_rate);
|
|
printPgmString(PSTR(" (homing seek, mm/min)\r\n$26=")); print_uint8_base10(settings.homing_debounce_delay);
|
|
printPgmString(PSTR(" (homing debounce, msec)\r\n$27=")); printFloat_SettingValue(settings.homing_pulloff);
|
|
printPgmString(PSTR(" (homing pull-off, mm)\r\n$30=")); printFloat_RPMValue(settings.rpm_max);
|
|
printPgmString(PSTR(" (rpm max)\r\n$31=")); printFloat_RPMValue(settings.rpm_min);
|
|
#ifdef VARIABLE_SPINDLE
|
|
printPgmString(PSTR(" (rpm min)\r\n$32=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_LASER_MODE));
|
|
printPgmString(PSTR(" (laser mode, bool)\r\n"));
|
|
#else
|
|
printPgmString(PSTR(" (rpm min)\r\n$32=0 (laser mode, bool)\r\n"));
|
|
#endif
|
|
// Print axis settings
|
|
uint8_t idx, set_idx;
|
|
uint8_t val = AXIS_SETTINGS_START_VAL;
|
|
for (set_idx=0; set_idx<AXIS_N_SETTINGS; set_idx++) {
|
|
for (idx=0; idx<N_AXIS; idx++) {
|
|
serial_write('$');
|
|
print_uint8_base10(val+idx);
|
|
serial_write('=');
|
|
switch (set_idx) {
|
|
case 0: printFloat_SettingValue(settings.steps_per_mm[idx]); break;
|
|
case 1: printFloat_SettingValue(settings.max_rate[idx]); break;
|
|
case 2: printFloat_SettingValue(settings.acceleration[idx]/(60*60)); break;
|
|
case 3: printFloat_SettingValue(-settings.max_travel[idx]); break;
|
|
}
|
|
serial_write(' ');
|
|
serial_write('(');
|
|
switch (idx) {
|
|
case X_AXIS: printPgmString(PSTR("x")); break;
|
|
case Y_AXIS: printPgmString(PSTR("y")); break;
|
|
case Z_AXIS: printPgmString(PSTR("z")); break;
|
|
}
|
|
switch (set_idx) {
|
|
case 0: printPgmString(PSTR(", step/mm")); break;
|
|
case 1: printPgmString(PSTR(" max rate, mm/min")); break;
|
|
case 2: printPgmString(PSTR(" accel, mm/sec^2")); break;
|
|
case 3: printPgmString(PSTR(" max travel, mm")); break;
|
|
}
|
|
printPgmString(PSTR(")\r\n"));
|
|
}
|
|
val += AXIS_SETTINGS_INCREMENT;
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
// Prints current probe parameters. Upon a probe command, these parameters are updated upon a
|
|
// successful probe or upon a failed probe with the G38.3 without errors command (if supported).
|
|
// These values are retained until Grbl is power-cycled, whereby they will be re-zeroed.
|
|
void report_probe_parameters()
|
|
{
|
|
// Report in terms of machine position.
|
|
printPgmString(PSTR("[PRB:"));
|
|
float print_position[N_AXIS];
|
|
system_convert_array_steps_to_mpos(print_position,sys_probe_position);
|
|
report_util_axis_values(print_position);
|
|
serial_write(':');
|
|
print_uint8_base10(sys.probe_succeeded);
|
|
report_util_feedback_line_feed();
|
|
}
|
|
|
|
|
|
// Prints Grbl NGC parameters (coordinate offsets, probing)
|
|
void report_ngc_parameters()
|
|
{
|
|
float coord_data[N_AXIS];
|
|
uint8_t coord_select;
|
|
for (coord_select = 0; coord_select <= SETTING_INDEX_NCOORD; coord_select++) {
|
|
if (!(settings_read_coord_data(coord_select,coord_data))) {
|
|
report_status_message(STATUS_SETTING_READ_FAIL);
|
|
return;
|
|
}
|
|
printPgmString(PSTR("[G"));
|
|
switch (coord_select) {
|
|
case 6: printPgmString(PSTR("28")); break;
|
|
case 7: printPgmString(PSTR("30")); break;
|
|
default: print_uint8_base10(coord_select+54); break; // G54-G59
|
|
}
|
|
serial_write(':');
|
|
report_util_axis_values(coord_data);
|
|
report_util_feedback_line_feed();
|
|
}
|
|
printPgmString(PSTR("[G92:")); // Print G92,G92.1 which are not persistent in memory
|
|
report_util_axis_values(gc_state.coord_offset);
|
|
report_util_feedback_line_feed();
|
|
printPgmString(PSTR("[TLO:")); // Print tool length offset value
|
|
printFloat_CoordValue(gc_state.tool_length_offset);
|
|
report_util_feedback_line_feed();
|
|
report_probe_parameters(); // Print probe parameters. Not persistent in memory.
|
|
}
|
|
|
|
|
|
// Print current gcode parser mode state
|
|
void report_gcode_modes()
|
|
{
|
|
printPgmString(PSTR("[GC:G"));
|
|
switch (gc_state.modal.motion) {
|
|
case MOTION_MODE_SEEK : serial_write('0'); break;
|
|
case MOTION_MODE_LINEAR : serial_write('1'); break;
|
|
case MOTION_MODE_CW_ARC : serial_write('2'); break;
|
|
case MOTION_MODE_CCW_ARC : serial_write('3'); break;
|
|
case MOTION_MODE_NONE : printPgmString(PSTR("80")); break;
|
|
default:
|
|
printPgmString(PSTR("38."));
|
|
print_uint8_base10(gc_state.modal.motion - (MOTION_MODE_PROBE_TOWARD-2));
|
|
}
|
|
|
|
printPgmString(PSTR(" G"));
|
|
print_uint8_base10(gc_state.modal.coord_select+54);
|
|
|
|
printPgmString(PSTR(" G1"));
|
|
switch (gc_state.modal.plane_select) {
|
|
case PLANE_SELECT_XY : serial_write('7'); break;
|
|
case PLANE_SELECT_ZX : serial_write('8'); break;
|
|
case PLANE_SELECT_YZ : serial_write('9'); break;
|
|
}
|
|
|
|
printPgmString(PSTR(" G2"));
|
|
if (gc_state.modal.units == UNITS_MODE_MM) { serial_write('1'); }
|
|
else { serial_write('0'); }
|
|
|
|
printPgmString(PSTR(" G9"));
|
|
if (gc_state.modal.distance == DISTANCE_MODE_ABSOLUTE) { serial_write('0'); }
|
|
else { serial_write('1'); }
|
|
|
|
printPgmString(PSTR(" G9"));
|
|
if (gc_state.modal.feed_rate == FEED_RATE_MODE_INVERSE_TIME) { serial_write('3'); }
|
|
else { serial_write('4'); }
|
|
|
|
printPgmString(PSTR(" M"));
|
|
switch (gc_state.modal.program_flow) {
|
|
case PROGRAM_FLOW_RUNNING : serial_write('0'); break;
|
|
case PROGRAM_FLOW_PAUSED : serial_write('1'); break;
|
|
case PROGRAM_FLOW_COMPLETED : serial_write('2'); break;
|
|
}
|
|
|
|
printPgmString(PSTR(" M"));
|
|
switch (gc_state.modal.spindle) {
|
|
case SPINDLE_ENABLE_CW : serial_write('3'); break;
|
|
case SPINDLE_ENABLE_CCW : serial_write('4'); break;
|
|
case SPINDLE_DISABLE : serial_write('5'); break;
|
|
}
|
|
|
|
printPgmString(PSTR(" M"));
|
|
#ifdef ENABLE_M7
|
|
if (gc_state.modal.coolant) { // Note: Multiple coolant states may be active at the same time.
|
|
if (gc_state.modal.coolant & PL_COND_FLAG_COOLANT_MIST) { serial_write('7'); }
|
|
if (gc_state.modal.coolant & PL_COND_FLAG_COOLANT_FLOOD) { serial_write('8'); }
|
|
} else { serial_write('9'); }
|
|
#else
|
|
if (gc_state.modal.coolant) { serial_write('8'); }
|
|
else { serial_write('9'); }
|
|
#endif
|
|
|
|
printPgmString(PSTR(" T"));
|
|
print_uint8_base10(gc_state.tool);
|
|
|
|
printPgmString(PSTR(" F"));
|
|
printFloat_RateValue(gc_state.feed_rate);
|
|
|
|
#ifdef VARIABLE_SPINDLE
|
|
printPgmString(PSTR(" S"));
|
|
printFloat(gc_state.spindle_speed,N_DECIMAL_RPMVALUE);
|
|
#endif
|
|
|
|
report_util_feedback_line_feed();
|
|
}
|
|
|
|
// Prints specified startup line
|
|
void report_startup_line(uint8_t n, char *line)
|
|
{
|
|
printPgmString(PSTR("$N"));
|
|
print_uint8_base10(n);
|
|
serial_write('=');
|
|
printString(line);
|
|
report_util_line_feed();
|
|
}
|
|
|
|
void report_execute_startup_message(char *line, uint8_t status_code)
|
|
{
|
|
serial_write('>');
|
|
printString(line);
|
|
serial_write(':');
|
|
report_status_message(status_code);
|
|
}
|
|
|
|
// Prints build info line
|
|
void report_build_info(char *line)
|
|
{
|
|
printPgmString(PSTR("[VER:" GRBL_VERSION "." GRBL_VERSION_BUILD ":"));
|
|
printString(line);
|
|
report_util_feedback_line_feed();
|
|
printPgmString(PSTR("[OPT:")); // Generate compile-time build option list
|
|
#ifdef VARIABLE_SPINDLE
|
|
serial_write('V');
|
|
#endif
|
|
#ifdef USE_LINE_NUMBERS
|
|
serial_write('N');
|
|
#endif
|
|
#ifdef ENABLE_M7
|
|
serial_write('M');
|
|
#endif
|
|
#ifdef COREXY
|
|
serial_write('C');
|
|
#endif
|
|
#ifdef PARKING_ENABLE
|
|
serial_write('P');
|
|
#endif
|
|
#ifdef HOMING_FORCE_SET_ORIGIN
|
|
serial_write('Z');
|
|
#endif
|
|
#ifdef HOMING_SINGLE_AXIS_COMMANDS
|
|
serial_write('H');
|
|
#endif
|
|
#ifdef LIMITS_TWO_SWITCHES_ON_AXES
|
|
serial_write('L');
|
|
#endif
|
|
#ifdef USE_CLASSIC_REALTIME_REPORT
|
|
serial_write('R');
|
|
#endif
|
|
#ifndef ENABLE_RESTORE_EEPROM_WIPE_ALL // NOTE: Shown when disabled.
|
|
serial_write('*');
|
|
#endif
|
|
#ifndef ENABLE_RESTORE_EEPROM_DEFAULT_SETTINGS // NOTE: Shown when disabled.
|
|
serial_write('$');
|
|
#endif
|
|
#ifndef ENABLE_RESTORE_EEPROM_CLEAR_PARAMETERS // NOTE: Shown when disabled.
|
|
serial_write('#');
|
|
#endif
|
|
#ifndef ENABLE_BUILD_INFO_WRITE_COMMAND // NOTE: Shown when disabled.
|
|
serial_write('I');
|
|
#endif
|
|
#ifndef FORCE_BUFFER_SYNC_DURING_EEPROM_WRITE // NOTE: Shown when disabled.
|
|
serial_write('E');
|
|
#endif
|
|
#ifndef FORCE_BUFFER_SYNC_DURING_WCO_CHANGE // NOTE: Shown when disabled.
|
|
serial_write('W');
|
|
#endif
|
|
|
|
// NOTE: Compiled values, like override increments/max/min values, may be added at some point later.
|
|
// These will likely have a comma delimiter to separate them.
|
|
|
|
report_util_feedback_line_feed();
|
|
}
|
|
|
|
|
|
// Prints the character string line Grbl has received from the user, which has been pre-parsed,
|
|
// and has been sent into protocol_execute_line() routine to be executed by Grbl.
|
|
void report_echo_line_received(char *line)
|
|
{
|
|
printPgmString(PSTR("[echo: ")); printString(line);
|
|
report_util_feedback_line_feed();
|
|
}
|
|
|
|
|
|
// Prints real-time data. This function grabs a real-time snapshot of the stepper subprogram
|
|
// and the actual location of the CNC machine. Users may change the following function to their
|
|
// specific needs, but the desired real-time data report must be as short as possible. This is
|
|
// requires as it minimizes the computational overhead and allows grbl to keep running smoothly,
|
|
// especially during g-code programs with fast, short line segments and high frequency reports (5-20Hz).
|
|
void report_realtime_status()
|
|
{
|
|
#ifdef USE_CLASSIC_REALTIME_REPORT
|
|
|
|
uint8_t idx;
|
|
int32_t current_position[N_AXIS]; // Copy current state of the system position variable
|
|
memcpy(current_position,sys_position,sizeof(sys_position));
|
|
float print_position[N_AXIS];
|
|
|
|
// Report current machine state
|
|
switch (sys.state) {
|
|
case STATE_IDLE: printPgmString(PSTR("<Idle")); break;
|
|
case STATE_CYCLE: printPgmString(PSTR("<Run")); break;
|
|
case STATE_HOLD:
|
|
if (!(sys.suspend & SUSPEND_JOG_CANCEL)) {
|
|
printPgmString(PSTR("<Hold"));
|
|
break;
|
|
} // Continues to print jog state during jog cancel.
|
|
case STATE_JOG: printPgmString(PSTR("<Jog")); break;
|
|
case STATE_HOMING: printPgmString(PSTR("<Home")); break;
|
|
case STATE_ALARM: printPgmString(PSTR("<Alarm")); break;
|
|
case STATE_CHECK_MODE: printPgmString(PSTR("<Check")); break;
|
|
case STATE_SAFETY_DOOR:
|
|
if (!(sys.suspend & SUSPEND_RETRACT_COMPLETE)) {
|
|
printPgmString(PSTR("<Door"));
|
|
} else {
|
|
if (sys.suspend & SUSPEND_SAFETY_DOOR_AJAR) { printPgmString(PSTR("<Door")); }
|
|
else { printPgmString(PSTR("<Hold")); }
|
|
}
|
|
break;
|
|
case STATE_SLEEP: printPgmString(PSTR("<Sleep")); break;
|
|
}
|
|
|
|
// If reporting a position, convert the current step count (current_position) to millimeters.
|
|
if (bit_istrue(settings.status_report_mask,(BITFLAG_RT_STATUS_MACHINE_POSITION | BITFLAG_RT_STATUS_WORK_POSITION))) {
|
|
system_convert_array_steps_to_mpos(print_position,current_position);
|
|
}
|
|
|
|
// Report machine position
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_MACHINE_POSITION)) {
|
|
printPgmString(PSTR(",MPos:"));
|
|
for (idx=0; idx< N_AXIS; idx++) {
|
|
printFloat_CoordValue(print_position[idx]);
|
|
if (idx < (N_AXIS-1)) { serial_write(','); }
|
|
}
|
|
}
|
|
|
|
// Report work position
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_WORK_POSITION)) {
|
|
printPgmString(PSTR(",WPos:"));
|
|
for (idx=0; idx< N_AXIS; idx++) {
|
|
// Apply work coordinate offsets and tool length offset to current position.
|
|
print_position[idx] -= gc_state.coord_system[idx]+gc_state.coord_offset[idx];
|
|
if (idx == TOOL_LENGTH_OFFSET_AXIS) { print_position[idx] -= gc_state.tool_length_offset; }
|
|
printFloat_CoordValue(print_position[idx]);
|
|
if (idx < (N_AXIS-1)) { serial_write(','); }
|
|
}
|
|
}
|
|
|
|
// Returns the number of active blocks are in the planner buffer.
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_PLANNER_BUFFER)) {
|
|
printPgmString(PSTR(",Buf:"));
|
|
print_uint8_base10(plan_get_block_buffer_count());
|
|
}
|
|
|
|
// Report serial read buffer status
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_SERIAL_RX)) {
|
|
printPgmString(PSTR(",RX:"));
|
|
print_uint8_base10(serial_get_rx_buffer_count());
|
|
}
|
|
|
|
#ifdef USE_LINE_NUMBERS
|
|
// Report current line number
|
|
printPgmString(PSTR(",Ln:"));
|
|
int32_t ln=0;
|
|
plan_block_t * pb = plan_get_current_block();
|
|
if(pb != NULL) {
|
|
ln = pb->line_number;
|
|
}
|
|
printInteger(ln);
|
|
#endif
|
|
|
|
#ifdef REPORT_REALTIME_RATE
|
|
// Report realtime rate
|
|
printPgmString(PSTR(",F:"));
|
|
printFloat_RateValue(st_get_realtime_rate());
|
|
#endif
|
|
|
|
#ifdef REPORT_ALL_PIN_STATES
|
|
if (bit_istrue(settings.status_report_mask,
|
|
( BITFLAG_RT_STATUS_LIMIT_PINS| BITFLAG_RT_STATUS_PROBE_PIN | BITFLAG_RT_STATUS_CONTROL_PINS ))) {
|
|
printPgmString(PSTR(",Pin:"));
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_LIMIT_PINS)) {
|
|
print_uint8_base2_ndigit(limits_get_state(),N_AXIS);
|
|
}
|
|
printPgmString(PSTR("|"));
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_PROBE_PIN)) {
|
|
if (probe_get_state()) { printPgmString(PSTR("1")); }
|
|
else { printPgmString(PSTR("0")); }
|
|
}
|
|
printPgmString(PSTR("|"));
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_CONTROL_PINS)) {
|
|
print_uint8_base2_ndigit(system_control_get_state(),N_CONTROL_PIN);
|
|
}
|
|
}
|
|
#else
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_LIMIT_PINS)) {
|
|
printPgmString(PSTR(",Lim:"));
|
|
print_uint8_base2_ndigit(limits_get_state(),N_AXIS);
|
|
}
|
|
#endif
|
|
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_OVERRIDES)) {
|
|
printPgmString(PSTR(",Ov:"));
|
|
print_uint8_base10(sys.f_override);
|
|
serial_write(',');
|
|
print_uint8_base10(sys.r_override);
|
|
serial_write(',');
|
|
print_uint8_base10(sys.spindle_speed_ovr);
|
|
|
|
uint8_t sp_state = spindle_get_state();
|
|
uint8_t cl_state = coolant_get_state();
|
|
if (sp_state || cl_state) {
|
|
printPgmString(PSTR(",A:"));
|
|
if (sp_state) { // != SPINDLE_STATE_DISABLE
|
|
#ifdef VARIABLE_SPINDLE
|
|
#ifdef USE_SPINDLE_DIR_AS_ENABLE_PIN
|
|
serial_write('S'); // CW
|
|
#else
|
|
if (sp_state == SPINDLE_STATE_CW) { serial_write('S'); } // CW
|
|
else { serial_write('C'); } // CCW
|
|
#endif
|
|
#else
|
|
if (sp_state & SPINDLE_STATE_CW) { serial_write('S'); } // CW
|
|
else { serial_write('C'); } // CCW
|
|
#endif
|
|
}
|
|
if (cl_state & COOLANT_STATE_FLOOD) { serial_write('F'); }
|
|
#ifdef ENABLE_M7
|
|
if (cl_state & COOLANT_STATE_MIST) { serial_write('M'); }
|
|
#endif
|
|
}
|
|
}
|
|
|
|
printPgmString(PSTR(">\r\n"));
|
|
|
|
#else
|
|
|
|
uint8_t idx;
|
|
int32_t current_position[N_AXIS]; // Copy current state of the system position variable
|
|
memcpy(current_position,sys_position,sizeof(sys_position));
|
|
float print_position[N_AXIS];
|
|
system_convert_array_steps_to_mpos(print_position,current_position);
|
|
|
|
// Report current machine state and sub-states
|
|
serial_write('<');
|
|
switch (sys.state) {
|
|
case STATE_IDLE: printPgmString(PSTR("Idle")); break;
|
|
case STATE_CYCLE: printPgmString(PSTR("Run")); break;
|
|
case STATE_HOLD:
|
|
if (!(sys.suspend & SUSPEND_JOG_CANCEL)) {
|
|
printPgmString(PSTR("Hold:"));
|
|
if (sys.suspend & SUSPEND_HOLD_COMPLETE) { serial_write('0'); } // Ready to resume
|
|
else { serial_write('1'); } // Actively holding
|
|
break;
|
|
} // Continues to print jog state during jog cancel.
|
|
case STATE_JOG: printPgmString(PSTR("Jog")); break;
|
|
case STATE_HOMING: printPgmString(PSTR("Home")); break;
|
|
case STATE_ALARM: printPgmString(PSTR("Alarm")); break;
|
|
case STATE_CHECK_MODE: printPgmString(PSTR("Check")); break;
|
|
case STATE_SAFETY_DOOR:
|
|
printPgmString(PSTR("Door:"));
|
|
if (sys.suspend & SUSPEND_INITIATE_RESTORE) {
|
|
serial_write('3'); // Restoring
|
|
} else {
|
|
if (sys.suspend & SUSPEND_RETRACT_COMPLETE) {
|
|
if (sys.suspend & SUSPEND_SAFETY_DOOR_AJAR) {
|
|
serial_write('1'); // Door ajar
|
|
} else {
|
|
serial_write('0');
|
|
} // Door closed and ready to resume
|
|
} else {
|
|
serial_write('2'); // Retracting
|
|
}
|
|
}
|
|
break;
|
|
case STATE_SLEEP: printPgmString(PSTR("Sleep")); break;
|
|
}
|
|
|
|
float wco[N_AXIS];
|
|
if (bit_isfalse(settings.status_report_mask,BITFLAG_RT_STATUS_POSITION_TYPE) ||
|
|
(sys.report_wco_counter >= REPORT_WCO_REFRESH_BUSY_COUNT) ) {
|
|
for (idx=0; idx< N_AXIS; idx++) {
|
|
// Apply work coordinate offsets and tool length offset to current position.
|
|
wco[idx] = gc_state.coord_system[idx]+gc_state.coord_offset[idx];
|
|
if (idx == TOOL_LENGTH_OFFSET_AXIS) { wco[idx] += gc_state.tool_length_offset; }
|
|
if (bit_isfalse(settings.status_report_mask,BITFLAG_RT_STATUS_POSITION_TYPE)) {
|
|
print_position[idx] -= wco[idx];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Report machine position
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_POSITION_TYPE)) {
|
|
printPgmString(PSTR("|MPos:"));
|
|
} else {
|
|
printPgmString(PSTR("|WPos:"));
|
|
}
|
|
report_util_axis_values(print_position);
|
|
|
|
// Returns planner and serial read buffer states.
|
|
#ifdef REPORT_FIELD_BUFFER_STATE
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_BUFFER_STATE)) {
|
|
printPgmString(PSTR("|Bf:"));
|
|
print_uint8_base10(plan_get_block_buffer_available());
|
|
serial_write(',');
|
|
print_uint8_base10(serial_get_rx_buffer_available());
|
|
}
|
|
#endif
|
|
|
|
#ifdef USE_LINE_NUMBERS
|
|
#ifdef REPORT_FIELD_LINE_NUMBERS
|
|
// Report current line number
|
|
plan_block_t * cur_block = plan_get_current_block();
|
|
if (cur_block != NULL) {
|
|
uint32_t ln = cur_block->line_number;
|
|
if (ln > 0) {
|
|
printPgmString(PSTR("|Ln:"));
|
|
printInteger(ln);
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
// Report realtime feed speed
|
|
#ifdef REPORT_FIELD_CURRENT_FEED_SPEED
|
|
#ifdef VARIABLE_SPINDLE
|
|
printPgmString(PSTR("|FS:"));
|
|
printFloat_RateValue(st_get_realtime_rate());
|
|
serial_write(',');
|
|
printFloat(sys.spindle_speed,N_DECIMAL_RPMVALUE);
|
|
#else
|
|
printPgmString(PSTR("|F:"));
|
|
printFloat_RateValue(st_get_realtime_rate());
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef REPORT_FIELD_PIN_STATE
|
|
uint8_t lim_pin_state = limits_get_state();
|
|
uint8_t ctrl_pin_state = system_control_get_state();
|
|
uint8_t prb_pin_state = probe_get_state();
|
|
if (lim_pin_state | ctrl_pin_state | prb_pin_state) {
|
|
printPgmString(PSTR("|Pn:"));
|
|
if (prb_pin_state) { serial_write('P'); }
|
|
if (lim_pin_state) {
|
|
if (bit_istrue(lim_pin_state,bit(X_AXIS))) { serial_write('X'); }
|
|
if (bit_istrue(lim_pin_state,bit(Y_AXIS))) { serial_write('Y'); }
|
|
if (bit_istrue(lim_pin_state,bit(Z_AXIS))) { serial_write('Z'); }
|
|
}
|
|
if (ctrl_pin_state) {
|
|
#ifdef ENABLE_SAFETY_DOOR_INPUT_PIN
|
|
if (bit_istrue(ctrl_pin_state,CONTROL_PIN_INDEX_SAFETY_DOOR)) { serial_write('D'); }
|
|
#endif
|
|
if (bit_istrue(ctrl_pin_state,CONTROL_PIN_INDEX_RESET)) { serial_write('R'); }
|
|
if (bit_istrue(ctrl_pin_state,CONTROL_PIN_INDEX_FEED_HOLD)) { serial_write('H'); }
|
|
if (bit_istrue(ctrl_pin_state,CONTROL_PIN_INDEX_CYCLE_START)) { serial_write('S'); }
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#ifdef REPORT_FIELD_WORK_COORD_OFFSET
|
|
if (sys.report_wco_counter++ >= REPORT_WCO_REFRESH_BUSY_COUNT) {
|
|
if (sys.state & (STATE_HOMING | STATE_CYCLE | STATE_HOLD | STATE_JOG | STATE_SAFETY_DOOR)) {
|
|
sys.report_wco_counter = 1; // Reset counter for slow refresh
|
|
} else { sys.report_wco_counter = (REPORT_WCO_REFRESH_BUSY_COUNT-REPORT_WCO_REFRESH_IDLE_COUNT+1); }
|
|
if (sys.report_ovr_counter >= REPORT_OVR_REFRESH_BUSY_COUNT) {
|
|
sys.report_ovr_counter = (REPORT_OVR_REFRESH_BUSY_COUNT-1); // Set override on next report.
|
|
}
|
|
printPgmString(PSTR("|WCO:"));
|
|
report_util_axis_values(wco);
|
|
}
|
|
#endif
|
|
|
|
#ifdef REPORT_FIELD_OVERRIDES
|
|
if (sys.report_ovr_counter++ >= REPORT_OVR_REFRESH_BUSY_COUNT) {
|
|
if (sys.state & (STATE_HOMING | STATE_CYCLE | STATE_HOLD | STATE_JOG | STATE_SAFETY_DOOR)) {
|
|
sys.report_ovr_counter = 1; // Reset counter for slow refresh
|
|
} else { sys.report_ovr_counter = (REPORT_OVR_REFRESH_BUSY_COUNT-REPORT_OVR_REFRESH_IDLE_COUNT+1); }
|
|
printPgmString(PSTR("|Ov:"));
|
|
print_uint8_base10(sys.f_override);
|
|
serial_write(',');
|
|
print_uint8_base10(sys.r_override);
|
|
serial_write(',');
|
|
print_uint8_base10(sys.spindle_speed_ovr);
|
|
|
|
uint8_t sp_state = spindle_get_state();
|
|
uint8_t cl_state = coolant_get_state();
|
|
if (sp_state || cl_state) {
|
|
printPgmString(PSTR("|A:"));
|
|
if (sp_state) { // != SPINDLE_STATE_DISABLE
|
|
#ifdef VARIABLE_SPINDLE
|
|
#ifdef USE_SPINDLE_DIR_AS_ENABLE_PIN
|
|
serial_write('S'); // CW
|
|
#else
|
|
if (sp_state == SPINDLE_STATE_CW) { serial_write('S'); } // CW
|
|
else { serial_write('C'); } // CCW
|
|
#endif
|
|
#else
|
|
if (sp_state & SPINDLE_STATE_CW) { serial_write('S'); } // CW
|
|
else { serial_write('C'); } // CCW
|
|
#endif
|
|
}
|
|
if (cl_state & COOLANT_STATE_FLOOD) { serial_write('F'); }
|
|
#ifdef ENABLE_M7
|
|
if (cl_state & COOLANT_STATE_MIST) { serial_write('M'); }
|
|
#endif
|
|
}
|
|
}
|
|
#endif
|
|
|
|
serial_write('>');
|
|
report_util_line_feed();
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
void report_realtime_debug()
|
|
{
|
|
|
|
}
|
|
#endif
|