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
228 lines
7.6 KiB
C
228 lines
7.6 KiB
C
/*
|
|
spindle_control.c - spindle control methods
|
|
Part of Grbl
|
|
|
|
Copyright (c) 2012-2016 Sungeun K. Jeon for Gnea Research LLC
|
|
Copyright (c) 2009-2011 Simen Svale Skogsrud
|
|
|
|
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/>.
|
|
*/
|
|
|
|
#include "grbl.h"
|
|
|
|
|
|
#ifdef SPINDLE_MINIMUM_PWM
|
|
#define SPINDLE_PWM_MIN_VALUE SPINDLE_MINIMUM_PWM
|
|
#else
|
|
#define SPINDLE_PWM_MIN_VALUE 0.0
|
|
#endif
|
|
#define SPINDLE_PWM_RANGE (SPINDLE_PWM_MAX_VALUE-SPINDLE_PWM_MIN_VALUE)
|
|
|
|
#ifdef VARIABLE_SPINDLE
|
|
static float pwm_gradient; // Precalulated value to speed up rpm to PWM conversions.
|
|
#endif
|
|
|
|
|
|
void spindle_init()
|
|
{
|
|
#ifdef VARIABLE_SPINDLE
|
|
|
|
// Configure variable spindle PWM and enable pin, if requried. On the Uno, PWM and enable are
|
|
// combined unless configured otherwise.
|
|
SPINDLE_PWM_DDR |= (1<<SPINDLE_PWM_BIT); // Configure as PWM output pin.
|
|
SPINDLE_TCCRA_REGISTER = SPINDLE_TCCRA_INIT_MASK; // Configure PWM output compare timer
|
|
SPINDLE_TCCRB_REGISTER = SPINDLE_TCCRB_INIT_MASK;
|
|
#ifdef USE_SPINDLE_DIR_AS_ENABLE_PIN
|
|
SPINDLE_ENABLE_DDR |= (1<<SPINDLE_ENABLE_BIT); // Configure as output pin.
|
|
#else
|
|
SPINDLE_DIRECTION_DDR |= (1<<SPINDLE_DIRECTION_BIT); // Configure as output pin.
|
|
#endif
|
|
|
|
pwm_gradient = SPINDLE_PWM_RANGE/(settings.rpm_max-settings.rpm_min);
|
|
|
|
#else
|
|
|
|
// Configure no variable spindle and only enable pin.
|
|
SPINDLE_ENABLE_DDR |= (1<<SPINDLE_ENABLE_BIT); // Configure as output pin.
|
|
SPINDLE_DIRECTION_DDR |= (1<<SPINDLE_DIRECTION_BIT); // Configure as output pin.
|
|
|
|
#endif
|
|
|
|
spindle_stop();
|
|
}
|
|
|
|
|
|
uint8_t spindle_get_state()
|
|
{
|
|
#ifdef VARIABLE_SPINDLE
|
|
#ifdef USE_SPINDLE_DIR_AS_ENABLE_PIN
|
|
// No spindle direction output pin.
|
|
#ifdef INVERT_SPINDLE_ENABLE_PIN
|
|
if (bit_isfalse(SPINDLE_ENABLE_PORT,(1<<SPINDLE_ENABLE_BIT))) { return(SPINDLE_STATE_CW); }
|
|
#else
|
|
if (bit_istrue(SPINDLE_ENABLE_PORT,(1<<SPINDLE_ENABLE_BIT))) { return(SPINDLE_STATE_CW); }
|
|
#endif
|
|
#else
|
|
if (SPINDLE_TCCRA_REGISTER & (1<<SPINDLE_COMB_BIT)) { // Check if PWM is enabled.
|
|
if (SPINDLE_DIRECTION_PORT & (1<<SPINDLE_DIRECTION_BIT)) { return(SPINDLE_STATE_CCW); }
|
|
else { return(SPINDLE_STATE_CW); }
|
|
}
|
|
#endif
|
|
#else
|
|
#ifdef INVERT_SPINDLE_ENABLE_PIN
|
|
if (bit_isfalse(SPINDLE_ENABLE_PORT,(1<<SPINDLE_ENABLE_BIT))) {
|
|
#else
|
|
if (bit_istrue(SPINDLE_ENABLE_PORT,(1<<SPINDLE_ENABLE_BIT))) {
|
|
#endif
|
|
if (SPINDLE_DIRECTION_PORT & (1<<SPINDLE_DIRECTION_BIT)) { return(SPINDLE_STATE_CCW); }
|
|
else { return(SPINDLE_STATE_CW); }
|
|
}
|
|
#endif
|
|
return(SPINDLE_STATE_DISABLE);
|
|
}
|
|
|
|
|
|
// Disables the spindle and sets PWM output to zero when PWM variable spindle speed is enabled.
|
|
// Called by various main program and ISR routines. Keep routine small, fast, and efficient.
|
|
// Called by spindle_init(), spindle_set_speed(), spindle_set_state(), and mc_reset().
|
|
void spindle_stop()
|
|
{
|
|
#ifdef VARIABLE_SPINDLE
|
|
SPINDLE_TCCRA_REGISTER &= ~(1<<SPINDLE_COMB_BIT); // Disable PWM. Output voltage is zero.
|
|
#ifdef USE_SPINDLE_DIR_AS_ENABLE_PIN
|
|
#ifdef INVERT_SPINDLE_ENABLE_PIN
|
|
SPINDLE_ENABLE_PORT |= (1<<SPINDLE_ENABLE_BIT); // Set pin to high
|
|
#else
|
|
SPINDLE_ENABLE_PORT &= ~(1<<SPINDLE_ENABLE_BIT); // Set pin to low
|
|
#endif
|
|
#endif
|
|
#else
|
|
#ifdef INVERT_SPINDLE_ENABLE_PIN
|
|
SPINDLE_ENABLE_PORT |= (1<<SPINDLE_ENABLE_BIT); // Set pin to high
|
|
#else
|
|
SPINDLE_ENABLE_PORT &= ~(1<<SPINDLE_ENABLE_BIT); // Set pin to low
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
|
|
#ifdef VARIABLE_SPINDLE
|
|
// Sets spindle speed PWM output and enable pin, if configured. Called by spindle_set_state()
|
|
// and stepper ISR. Keep routine small and efficient.
|
|
void spindle_set_speed(uint8_t pwm_value)
|
|
{
|
|
if (pwm_value == SPINDLE_PWM_OFF_VALUE) {
|
|
spindle_stop();
|
|
} else {
|
|
SPINDLE_OCR_REGISTER = pwm_value; // Set PWM output level.
|
|
SPINDLE_TCCRA_REGISTER |= (1<<SPINDLE_COMB_BIT); // Ensure PWM output is enabled.
|
|
|
|
#if defined(USE_SPINDLE_DIR_AS_ENABLE_PIN)
|
|
#ifdef INVERT_SPINDLE_ENABLE_PIN
|
|
SPINDLE_ENABLE_PORT &= ~(1<<SPINDLE_ENABLE_BIT);
|
|
#else
|
|
SPINDLE_ENABLE_PORT |= (1<<SPINDLE_ENABLE_BIT);
|
|
#endif
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
// Called by spindle_set_state() and step segment generator. Keep routine small and efficient.
|
|
uint8_t spindle_compute_pwm_value(float rpm) // 328p PWM register is 8-bit.
|
|
{
|
|
rpm *= (0.01*sys.spindle_speed_ovr); // Scale by spindle speed override value.
|
|
// Calculate PWM register value based on rpm max/min settings and programmed rpm.
|
|
if ((settings.rpm_min >= settings.rpm_max) || (rpm >= settings.rpm_max)) {
|
|
// No PWM range possible. Set simple on/off spindle control pin state.
|
|
sys.spindle_speed = settings.rpm_max;
|
|
return(SPINDLE_PWM_MAX_VALUE);
|
|
} else if (rpm < settings.rpm_min) {
|
|
if (rpm == 0.0) {
|
|
sys.spindle_speed = 0.0;
|
|
return(SPINDLE_PWM_OFF_VALUE); }
|
|
else {
|
|
sys.spindle_speed = settings.rpm_min;
|
|
return(SPINDLE_PWM_MIN_VALUE);
|
|
}
|
|
} else {
|
|
sys.spindle_speed = rpm;
|
|
return(floor( (rpm-settings.rpm_min)*pwm_gradient + (SPINDLE_PWM_MIN_VALUE+0.5)));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
// Immediately sets spindle running state with direction and spindle rpm via PWM, if enabled.
|
|
// Called by g-code parser spindle_sync(), parking retract and restore, g-code program end,
|
|
// sleep, and spindle stop override.
|
|
#ifdef VARIABLE_SPINDLE
|
|
void spindle_set_state(uint8_t state, float rpm)
|
|
#else
|
|
void spindle_set_state(uint8_t state)
|
|
#endif
|
|
{
|
|
if (sys.abort) { return; } // Block during abort.
|
|
if (state == SPINDLE_DISABLE) { // Halt or set spindle direction and rpm.
|
|
|
|
#ifdef VARIABLE_SPINDLE
|
|
sys.spindle_speed = 0.0;
|
|
#endif
|
|
spindle_stop();
|
|
|
|
} else {
|
|
|
|
#ifndef USE_SPINDLE_DIR_AS_ENABLE_PIN
|
|
if (state == SPINDLE_ENABLE_CW) {
|
|
SPINDLE_DIRECTION_PORT &= ~(1<<SPINDLE_DIRECTION_BIT);
|
|
} else {
|
|
SPINDLE_DIRECTION_PORT |= (1<<SPINDLE_DIRECTION_BIT);
|
|
}
|
|
#endif
|
|
|
|
#ifdef VARIABLE_SPINDLE
|
|
spindle_set_speed(spindle_compute_pwm_value(rpm));
|
|
#else
|
|
// NOTE: Without variable spindle, the enable bit should just turn on or off, regardless
|
|
// if the spindle speed value is zero, as its ignored anyhow.
|
|
#ifdef INVERT_SPINDLE_ENABLE_PIN
|
|
SPINDLE_ENABLE_PORT &= ~(1<<SPINDLE_ENABLE_BIT);
|
|
#else
|
|
SPINDLE_ENABLE_PORT |= (1<<SPINDLE_ENABLE_BIT);
|
|
#endif
|
|
#endif
|
|
|
|
}
|
|
|
|
sys.report_ovr_counter = REPORT_OVR_REFRESH_BUSY_COUNT; // Set to report change immediately
|
|
}
|
|
|
|
|
|
// G-code parser entry-point for setting spindle state. Forces a planner buffer sync and bails
|
|
// if an abort or check-mode is active.
|
|
#ifdef VARIABLE_SPINDLE
|
|
void spindle_sync(uint8_t state, float rpm)
|
|
{
|
|
if (sys.state == STATE_CHECK_MODE) { return; }
|
|
protocol_buffer_synchronize(); // Empty planner buffer to ensure spindle is set when programmed.
|
|
spindle_set_state(state,rpm);
|
|
}
|
|
#else
|
|
void spindle_sync(uint8_t state)
|
|
{
|
|
if (sys.state == STATE_CHECK_MODE) { return; }
|
|
protocol_buffer_synchronize(); // Empty planner buffer to ensure spindle is set when programmed.
|
|
spindle_set_state(state);
|
|
}
|
|
#endif |