12f48a008a
- Feature: Realtime feed, rapid, and spindle speed overrides. These
alter the running machine state within tens of milliseconds!
- Feed override: 100%, +/-10%, +/-1% commands with values 1-200% of
programmed feed
- Rapid override: 100%, 50%, 25% rapid rate commands
- Spindle speed override: 100%, +/-10%, +/-1% commands with values
50-200% of programmed speed
- Override values have configurable limits and increments in
config.h.
- Feature: Realtime toggle overrides for spindle stop, flood coolant,
and optionally mist coolant
- Spindle stop: Enables and disables spindle during a feed hold.
Automatically restores last spindles state.
- Flood and mist coolant: Immediately toggles coolant state until
next toggle or g-code coolant command.
- Feature: Jogging mode! Incremental and absolute modes supported.
- Grbl accepts jogging-specific commands like $J=X100F50. An axis
word and feed rate are required. G20/21 and G90/G91 commands are
accepted.
- Jog motions can be canceled at any time by a feed hold `!`
command. The buffer is automatically flushed. (No resetting required).
- Jog motions do not alter the g-code parser state so GUIs don’t
have to track what they changed and correct it.
- Feature: Laser mode setting. Allows Grbl to execute continuous
motions with spindle speed and state changes.
- Feature: Significantly improved status reports. Overhauled to cram in
more meaningful data and still make it smaller on average.
- All available data is now sent by default, but does not appear if
it doesn’t change or is not active.
- Machine position(MPos) or work position(WPos) is reported but not
both at the same time. Instead, the work coordinate offsets (WCO)are
sent intermittently whenever it changes or refreshes after 10-30 status
reports. Position vectors are easily computed by WPos = MPos - WCO.
- All data has changed in some way. Details of changes are in the
markdown documents and wiki.
- Feature: 16 new realtime commands to control overrides. All in
extended-ASCII character space.
- While they are not easily typeable and requires a GUI, they can’t
be accidentally triggered by some latent character in the g-code
program and have tons of room for expansion.
- Feature: New substates for HOLD and SAFETY DOOR. A `:x` is appended
to the state, where `x` is an integer and indicates a substate.
- For example, each integer of a door state describes in what phase
the machine is in during parking. Substates are detailed in the
documentation.
- Feature: With the alarm codes, homing and probe alarms have been
expanded with more codes to provide more exact feedback on what caused
the alarm.
- Feature: New hard limit check upon power-up or reset. If detected, a
feedback message to check the limit switches sent immediately after the
welcome message.
- May be disabled in config.h.
- OEM feature: Enable/disable `$RST=` individual commands based on
desired behavior in config.h.
- OEM feature: Configurable EEPROM wipe to prevent certain data from
being deleted during firmware upgrade to a new settings version or
`RST=*` command.
- OEM feature: Enable/disable the `$I=` build info write string with
external EEPROM write example sketch.
- This prevents a user from altering the build info string in
EEPROM. This requires the vendor to write the string to EEPROM via
external means. An Arduino example sketch is provided to accomplish
this. This would be useful for contain product data that is
retrievable.
- Tweak: All feedback has been drastically trimmed to free up flash
space for the v1.0 release.
- The `$` help message is just one string, listing available
commands.
- The `$$` settings printout no longer includes descriptions. Only
the setting values. (Sorry it’s this or remove overrides!)
- Grbl `error:` and `ALARM:` responses now only contain codes. No
descriptions. All codes are explained in documentation.
- Grbl’s old feedback style may be restored via a config.h, but
keep in mind that it will likely not fit into the Arduino’s flash space.
- Tweak: Grbl now forces a buffer sync or stop motion whenever a g-code
command needs to update and write a value to EEPROM or changes the work
coordinate offset.
- This addresses two old issues in all prior Grbl versions. First,
an EEPROM write requires interrupts to be disabled, including stepper
and serial comm. Steps can be lost and data can be corrupted. Second,
the work position may not be correlated to the actual machine position,
since machine position is derived from the actual current execution
state, while work position is based on the g-code parser offset state.
They are usually not in sync and the parser state is several motions
behind. This forced sync ensures work and machine positions are always
correct.
- This behavior can be disabled through a config.h option, but it’s
not recommended to do so.
- Tweak: To make status reports standardized, users can no longer
change what is reported via status report mask, except for only
toggling machine or work positions.
- All other data fields are included in the report and can only be
disabled through the config.h file. It’s not recommended to alter this,
because GUIs will be expecting this data to be present and may not be
compatible.
- Tweak: Homing cycle and parking motion no longer report a negative
line number in a status report. These will now not report a line number
at all.
- Tweak: New `[Restoring spindle]` message when restoring from a
spindle stop override. Provides feedback what Grbl is doing while the
spindle is powering up and a 4.0 second delay is enforced.
- Tweak: Override values are reset to 100% upon M2/30. This behavior
can be disabled in config.h
- Tweak: The planner buffer size has been reduced from 18 to 16 to free
up RAM for tracking and controlling overrides.
- Tweak: TX buffer size has been increased from 64 to 90 bytes to
improve status reporting and overall performance.
- Tweak: Removed the MOTION CANCEL state. It was redundant and didn’t
affect Grbl’s overall operation by doing so.
- Tweak: Grbl’s serial buffer increased by +1 internally, such that 128
bytes means 128, not 127 due to the ring buffer implementation. Long
overdue.
- Tweak: Altered sys.alarm variable to be set by alarm codes, rather
than bit flags. Simplified how it worked overall.
- Tweak: Planner buffer and serial RX buffer usage has been combined in
the status reports.
- Tweak: Pin state reporting has been refactored to report only the
pins “triggered” and nothing when not “triggered”.
- Tweak: Current machine rate or speed is now included in every report.
- Tweak: The work coordinate offset (WCO) and override states only need
to be refreshed intermittently or reported when they change. The
refresh rates may be altered for each in the config.h file with
different idle and busy rates to lessen Grbl’s load during a job.
- Tweak: For temporary compatibility to existing GUIs until they are
updated, an option to revert back to the old style status reports is
available in config.h, but not recommended for long term use.
- Tweak: Removed old limit pin state reporting option from config.h in
lieu of new status report that includes them.
- Tweak: Updated the defaults.h file to include laser mode, altered
status report mask, and fix an issue with a missing invert probe pin
default.
- Refactor: Changed how planner line data is generated and passed to
the planner and onto the step generator. By making it a struct
variable, this saved significant flash space.
- Refactor: Major re-factoring of the planner to incorporate override
values and allow for re-calculations fast enough to immediately take
effect during operation. No small feat.
- Refactor: Re-factored the step segment generator for re-computing new
override states.
- Refactor: Re-factored spindle_control.c to accommodate the spindle
speed overrides and laser mode.
- Refactor: Re-factored parts of the codebase for a new jogging mode.
Still under development though and slated to be part of the official
v1.0 release. Hang tight.
- Refactor: Created functions for computing a unit vector and value
limiting based on axis maximums to free up more flash.
- Refactor: The spindle PWM is now set directly inside of the stepper
ISR as it loads new step segments.
- Refactor: Moved machine travel checks out of soft limits function
into its own since jogging uses this too.
- Refactor: Removed coolant_stop() and combined with
coolant_set_state().
- Refactor: The serial RX ISR forks off extended ASCII values to
quickly assess the new override realtime commands.
- Refactor: Altered some names of the step control flags.
- Refactor: Improved efficiency of the serial RX get buffer count
function.
- Refactor: Saved significant flash by removing and combining print
functions. Namely the uint8 base10 and base2 functions.
- Refactor: Moved the probe state check in the main stepper ISR to
improve its efficiency.
- Refactor: Single character printPgmStrings() went converted to direct
serial_write() commands to save significant flash space.
- Documentation: Detailed Markdown documents on error codes, alarm
codes, messages, new real-time commands, new status reports, and how
jogging works. More to come later and will be posted on the Wiki as
well.
- Documentation: CSV files for quick importing of Grbl error and alarm
codes.
- Bug Fix: Applied v0.9 master fixes to CoreXY homing.
- Bug Fix: The print float function would cause Grbl to crash if a
value was 1e6 or greater. Increased the buffer by 3 bytes to help
prevent this in the future.
- Bug Fix: Build info and startup string EEPROM restoring was not
writing the checksum value.
- Bug Fix: Corrected an issue with safety door restoring the proper
spindle and coolant state. It worked before, but breaks with laser mode
that can continually change spindle state per planner block.
- Bug Fix: Move system position and probe position arrays out of the
system_t struct. Ran into some compiling errors that were hard to track
down as to why. Moving them out fixed it.
754 lines
32 KiB
C
754 lines
32 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"
|
|
|
|
|
|
// 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 silent mode, all error codes are greater than zero.
|
|
// TODO: Install silent mode to return only numeric values, primarily for GUIs.
|
|
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
|
|
printPgmString(PSTR("\r\n"));
|
|
}
|
|
}
|
|
|
|
// 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
|
|
printPgmString(PSTR("\r\n"));
|
|
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.
|
|
// TODO: Install silence feedback messages option in settings
|
|
void report_feedback_message(uint8_t message_code)
|
|
{
|
|
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;
|
|
}
|
|
printPgmString(PSTR("]\r\n"));
|
|
}
|
|
|
|
|
|
// 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("[$$ $# $G $I $N $x=val $Nx=line $J=line $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"
|
|
"$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
|
|
printPgmString(PSTR("$0=")); print_uint8_base10(settings.pulse_microseconds);
|
|
printPgmString(PSTR("\r\n$1=")); print_uint8_base10(settings.stepper_idle_lock_time);
|
|
printPgmString(PSTR("\r\n$2=")); print_uint8_base10(settings.step_invert_mask);
|
|
printPgmString(PSTR("\r\n$3=")); print_uint8_base10(settings.dir_invert_mask);
|
|
printPgmString(PSTR("\r\n$4=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_INVERT_ST_ENABLE));
|
|
printPgmString(PSTR("\r\n$5=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_INVERT_LIMIT_PINS));
|
|
printPgmString(PSTR("\r\n$6=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_INVERT_PROBE_PIN));
|
|
printPgmString(PSTR("\r\n$10=")); print_uint8_base10(settings.status_report_mask);
|
|
printPgmString(PSTR("\r\n$11=")); printFloat_SettingValue(settings.junction_deviation);
|
|
printPgmString(PSTR("\r\n$12=")); printFloat_SettingValue(settings.arc_tolerance);
|
|
printPgmString(PSTR("\r\n$13=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_REPORT_INCHES));
|
|
printPgmString(PSTR("\r\n$20=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_SOFT_LIMIT_ENABLE));
|
|
printPgmString(PSTR("\r\n$21=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_HARD_LIMIT_ENABLE));
|
|
printPgmString(PSTR("\r\n$22=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_HOMING_ENABLE));
|
|
printPgmString(PSTR("\r\n$23=")); print_uint8_base10(settings.homing_dir_mask);
|
|
printPgmString(PSTR("\r\n$24=")); printFloat_SettingValue(settings.homing_feed_rate);
|
|
printPgmString(PSTR("\r\n$25=")); printFloat_SettingValue(settings.homing_seek_rate);
|
|
printPgmString(PSTR("\r\n$26=")); print_uint8_base10(settings.homing_debounce_delay);
|
|
printPgmString(PSTR("\r\n$27=")); printFloat_SettingValue(settings.homing_pulloff);
|
|
printPgmString(PSTR("\r\n$30=")); printFloat_RPMValue(settings.rpm_max);
|
|
printPgmString(PSTR("\r\n$31=")); printFloat_RPMValue(settings.rpm_min);
|
|
#ifdef VARIABLE_SPINDLE
|
|
printPgmString(PSTR("\r\n$32=")); print_uint8_base10(bit_istrue(settings.flags,BITFLAG_LASER_MODE));
|
|
#else
|
|
printPgmString(PSTR("\r\n$32=0\r\n"));
|
|
#endif
|
|
#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
|
|
#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;
|
|
}
|
|
#ifdef REPORT_GUI_MODE
|
|
printPgmString(PSTR("\r\n"));
|
|
#else
|
|
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"));
|
|
#endif
|
|
}
|
|
val += AXIS_SETTINGS_INCREMENT;
|
|
}
|
|
}
|
|
|
|
|
|
// 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()
|
|
{
|
|
uint8_t i;
|
|
float print_position[N_AXIS];
|
|
|
|
// Report in terms of machine position.
|
|
printPgmString(PSTR("[PRB:"));
|
|
for (i=0; i< N_AXIS; i++) {
|
|
print_position[i] = system_convert_axis_steps_to_mpos(sys_probe_position,i);
|
|
printFloat_CoordValue(print_position[i]);
|
|
if (i < (N_AXIS-1)) { serial_write(','); }
|
|
}
|
|
serial_write(':');
|
|
print_uint8_base10(sys.probe_succeeded);
|
|
printPgmString(PSTR("]\r\n"));
|
|
}
|
|
|
|
|
|
// Prints Grbl NGC parameters (coordinate offsets, probing)
|
|
void report_ngc_parameters()
|
|
{
|
|
float coord_data[N_AXIS];
|
|
uint8_t coord_select, i;
|
|
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(':');
|
|
for (i=0; i<N_AXIS; i++) {
|
|
printFloat_CoordValue(coord_data[i]);
|
|
if (i < (N_AXIS-1)) { serial_write(','); }
|
|
else { printPgmString(PSTR("]\r\n")); }
|
|
}
|
|
}
|
|
printPgmString(PSTR("[G92:")); // Print G92,G92.1 which are not persistent in memory
|
|
for (i=0; i<N_AXIS; i++) {
|
|
printFloat_CoordValue(gc_state.coord_offset[i]);
|
|
if (i < (N_AXIS-1)) { serial_write(','); }
|
|
else { printPgmString(PSTR("]\r\n")); }
|
|
}
|
|
printPgmString(PSTR("[TLO:")); // Print tool length offset value
|
|
printFloat_CoordValue(gc_state.tool_length_offset);
|
|
printPgmString(PSTR("]\r\n"));
|
|
report_probe_parameters(); // Print probe parameters. Not persistent in memory.
|
|
}
|
|
|
|
|
|
// Print current gcode parser mode state
|
|
void report_gcode_modes()
|
|
{
|
|
switch (gc_state.modal.motion) {
|
|
case MOTION_MODE_SEEK : printPgmString(PSTR("[G0")); break;
|
|
case MOTION_MODE_LINEAR : printPgmString(PSTR("[G1")); break;
|
|
case MOTION_MODE_CW_ARC : printPgmString(PSTR("[G2")); break;
|
|
case MOTION_MODE_CCW_ARC : printPgmString(PSTR("[G3")); break;
|
|
case MOTION_MODE_NONE : printPgmString(PSTR("[G80")); break;
|
|
default:
|
|
printPgmString(PSTR("[G38."));
|
|
print_uint8_base10(gc_state.modal.motion - (MOTION_MODE_PROBE_TOWARD-2));
|
|
}
|
|
|
|
printPgmString(PSTR(" G"));
|
|
print_uint8_base10(gc_state.modal.coord_select+54);
|
|
|
|
switch (gc_state.modal.plane_select) {
|
|
case PLANE_SELECT_XY : printPgmString(PSTR(" G17")); break;
|
|
case PLANE_SELECT_ZX : printPgmString(PSTR(" G18")); break;
|
|
case PLANE_SELECT_YZ : printPgmString(PSTR(" G19")); break;
|
|
}
|
|
|
|
if (gc_state.modal.units == UNITS_MODE_MM) { printPgmString(PSTR(" G21")); }
|
|
else { printPgmString(PSTR(" G20")); }
|
|
|
|
if (gc_state.modal.distance == DISTANCE_MODE_ABSOLUTE) { printPgmString(PSTR(" G90")); }
|
|
else { printPgmString(PSTR(" G91")); }
|
|
|
|
if (gc_state.modal.feed_rate == FEED_RATE_MODE_INVERSE_TIME) { printPgmString(PSTR(" G93")); }
|
|
else { printPgmString(PSTR(" G94")); }
|
|
|
|
switch (gc_state.modal.program_flow) {
|
|
case PROGRAM_FLOW_RUNNING : printPgmString(PSTR(" M0")); break;
|
|
case PROGRAM_FLOW_PAUSED : printPgmString(PSTR(" M1")); break;
|
|
case PROGRAM_FLOW_COMPLETED : printPgmString(PSTR(" M2")); break;
|
|
}
|
|
|
|
switch (gc_state.modal.spindle) {
|
|
case SPINDLE_ENABLE_CW : printPgmString(PSTR(" M3")); break;
|
|
case SPINDLE_ENABLE_CCW : printPgmString(PSTR(" M4")); break;
|
|
case SPINDLE_DISABLE : printPgmString(PSTR(" M5")); break;
|
|
}
|
|
|
|
#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) { printPgmString(PSTR(" M7")); }
|
|
if (gc_state.modal.coolant & PL_COND_FLAG_COOLANT_FLOOD) { printPgmString(PSTR(" M8")); }
|
|
} else { printPgmString(PSTR(" M9")); }
|
|
#else
|
|
if (gc_state.modal.coolant) { printPgmString(PSTR(" M8")); }
|
|
else { printPgmString(PSTR(" M9")); }
|
|
#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_RPMValue(gc_state.spindle_speed);
|
|
#endif
|
|
|
|
printPgmString(PSTR("]\r\n"));
|
|
}
|
|
|
|
// Prints specified startup line
|
|
void report_startup_line(uint8_t n, char *line)
|
|
{
|
|
printPgmString(PSTR("$N"));
|
|
print_uint8_base10(n);
|
|
serial_write('=');
|
|
printString(line);
|
|
printPgmString(PSTR("\r\n"));
|
|
}
|
|
|
|
|
|
// Prints build info line
|
|
void report_build_info(char *line)
|
|
{
|
|
printPgmString(PSTR("[" GRBL_VERSION "." GRBL_VERSION_BUILD ":"));
|
|
printString(line);
|
|
printPgmString(PSTR("]\r\n"));
|
|
}
|
|
|
|
|
|
// 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);
|
|
printPgmString(PSTR("]\r\n"));
|
|
}
|
|
|
|
|
|
// 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;
|
|
}
|
|
|
|
// 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);
|
|
if (sys.toggle_ovr_mask) {
|
|
printPgmString(PSTR("|T:"));
|
|
if (sys.toggle_ovr_mask & TOGGLE_OVR_STOP_ACTIVE_MASK) { serial_write('S'); }
|
|
if (sys.toggle_ovr_mask & TOGGLE_OVR_FLOOD_COOLANT) { serial_write('F'); }
|
|
#ifdef ENABLE_M7
|
|
if (sys.toggle_ovr_mask & TOGGLE_OVR_MIST_COOLANT) { serial_write('M'); }
|
|
#endif
|
|
bit_false(sys.toggle_ovr_mask, (TOGGLE_OVR_FLOOD_COOLANT|TOGGLE_OVR_FLOOD_COOLANT));
|
|
}
|
|
}
|
|
|
|
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
|
|
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:")); // [Grbl-Mega Only]
|
|
// if (sys.suspend & SUSPEND_RETRACT_COMPLETE) { printPgmString(PSTR("0")); } // Parked
|
|
// else { printPgmString(PSTR("1")); } // Actively holding and retracting
|
|
// break;
|
|
}
|
|
|
|
// Report machine position
|
|
if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_POSITION_TYPE)) {
|
|
printPgmString(PSTR("|MPos:"));
|
|
} else {
|
|
// Report 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; }
|
|
}
|
|
}
|
|
for (idx=0; idx< N_AXIS; idx++) {
|
|
printFloat_CoordValue(print_position[idx]);
|
|
if (idx < (N_AXIS-1)) { serial_write(','); }
|
|
}
|
|
|
|
// Returns planner and serial read buffer states.
|
|
#ifdef REPORT_FIELD_BUFFER_STATE
|
|
printPgmString(PSTR("|Bf:"));
|
|
print_uint8_base10(plan_get_block_buffer_count());
|
|
serial_write(',');
|
|
print_uint8_base10(serial_get_rx_buffer_count());
|
|
#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 rate
|
|
#ifdef REPORT_FIELD_CURRENT_RATE
|
|
printPgmString(PSTR("|F:"));
|
|
printFloat_RateValue(st_get_realtime_rate());
|
|
#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:"));
|
|
float axis_offset;
|
|
uint8_t idx;
|
|
for (idx=0; idx<N_AXIS; idx++) {
|
|
axis_offset = gc_state.coord_system[idx]+gc_state.coord_offset[idx];
|
|
if (idx == TOOL_LENGTH_OFFSET_AXIS) { axis_offset += gc_state.tool_length_offset; }
|
|
printFloat_CoordValue(axis_offset);
|
|
if (idx < (N_AXIS-1)) { serial_write(','); }
|
|
}
|
|
}
|
|
#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);
|
|
|
|
if (sys.toggle_ovr_mask) {
|
|
printPgmString(PSTR("|T:"));
|
|
if (sys.toggle_ovr_mask & TOGGLE_OVR_STOP_ACTIVE_MASK) { serial_write('S'); }
|
|
if (sys.toggle_ovr_mask & TOGGLE_OVR_FLOOD_COOLANT) { serial_write('F'); }
|
|
#ifdef ENABLE_M7
|
|
if (sys.toggle_ovr_mask & TOGGLE_OVR_MIST_COOLANT) { serial_write('M'); }
|
|
#endif
|
|
bit_false(sys.toggle_ovr_mask, (TOGGLE_OVR_FLOOD_COOLANT|TOGGLE_OVR_FLOOD_COOLANT));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
printPgmString(PSTR(">\r\n"));
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
void report_realtime_debug()
|
|
{
|
|
|
|
}
|
|
#endif
|