spindle_control.c

/*
  spindle_control.c - spindle control methods

  Part of grblHAL

  Copyright (c) 2017-2026 Terje Io
  Copyright (c) 2012-2015 Sungeun K. Jeon
  Copyright (c) 2009-2011 Simen Svale Skogsrud

  grblHAL 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.

  grblHAL 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 grblHAL. If not, see <http://www.gnu.org/licenses/>.
*/

#include <math.h>
#include <string.h>

#include "hal.h"
#include "protocol.h"
#include "state_machine.h"
#include "settings.h"

#if ENABLE_SPINDLE_LINEARIZATION
#include <stdio.h>
#endif

#ifndef UNUSED
#define UNUSED(x) (void)(x)
#endif

/*! \brief Structure for holding spindle registration data */
typedef struct {
    const spindle_ptrs_t *cfg;
    spindle_ptrs_t hal;
    const char *name;
    bool init_ok;
} spindle_reg_t;

/*! \brief Structure for holding data about an enabled spindle */
typedef struct {
    spindle_param_t param;
    spindle_ptrs_t hal;
    bool enabled;
    bool activated;
} spindle_sys_t;

static uint8_t n_spindle = 0;

#if N_SYS_SPINDLE == 1
#define N_ENA_SPINDLE N_SPINDLE_SELECTABLE
#else
#define N_ENA_SPINDLE N_SYS_SPINDLE
#endif

static spindle_sys_t sys_spindle[N_ENA_SPINDLE] = {0};
static spindle_reg_t spindles[N_SPINDLE] = {0}, *pwm_spindle = NULL;
static spindle_sys_t *active_spindle = &sys_spindle[0];

static const spindle_data_ptrs_t *encoder;

FLASHMEM static void spindle_init (void *data)
{
    spindle_reg_t *spindle = (spindle_reg_t *)data;

    if((spindle->init_ok = spindle->hal.config == NULL || spindle->hal.config(&spindle->hal)))
        spindle->hal.set_state(&spindle->hal, (spindle_state_t){0}, 0.0f);
}

/*! \internal \brief Activates and registers a spindle as enabled with a specific spindle number.
\param spindle_id spindle id of spindle to activate as a \ref spindle_id_t.
\param spindle_num spindle number to set as enabled as a \ref spindle_num_t.
\returns \a true if succsesful, \a false if not.
*/
FLASHMEM static bool spindle_activate (spindle_reg_t *spindle)
{
    bool ok;
#if N_SYS_SPINDLE > 1
    static spindle_sys_t *active_spindle = &sys_spindle[0];
#endif

    if(spindle->hal.spindle_num == -1)
        spindle->hal.spindle_num = 0;

    // Always configure PWM spindle on startup to ensure outputs are set correctly.
    if(pwm_spindle && pwm_spindle->cfg->config) {

        if(!pwm_spindle->hal.cap.rpm_range_locked) {
            pwm_spindle->hal.rpm_min = settings.pwm_spindle.rpm_min;
            pwm_spindle->hal.rpm_max = settings.pwm_spindle.rpm_max;
        }

        spindle_init(pwm_spindle);
    }
    pwm_spindle = NULL;

    if((ok = !!spindle->cfg)) {

        if(active_spindle != &sys_spindle[spindle->hal.spindle_num] && active_spindle->activated && active_spindle->hal.set_state)
            gc_spindle_off(); // TODO: switch off only the default spindle?

        if(!spindle->hal.cap.rpm_range_locked) {
            spindle->hal.rpm_min = settings.pwm_spindle.rpm_min;
            spindle->hal.rpm_max = settings.pwm_spindle.rpm_max;
        }

        if(!spindle->init_ok)
            ok = spindle->init_ok = spindle->hal.config == NULL || spindle->hal.config(&spindle->hal);

        if(ok) {

            spindle_ptrs_t spindle_hal;

            memcpy(&spindle_hal, &spindle->hal, sizeof(spindle_ptrs_t));

            spindle_hal.cap.laser &= settings.mode == Mode_Laser;

            if(grbl.on_spindle_select)
                ok = grbl.on_spindle_select(&spindle_hal);

            if(ok) {
                active_spindle = &sys_spindle[spindle->hal.spindle_num];
                active_spindle->enabled = active_spindle->activated = true;
                active_spindle->param.hal = &active_spindle->hal;
                if(active_spindle->param.override_pct == 0)
                    active_spindle->param.override_pct = DEFAULT_SPINDLE_RPM_OVERRIDE;
                active_spindle->param.option.ramp_up = active_spindle->param.option.ramp_down = active_spindle->param.option.ignore_delays = Off;
                if(spindle_hal.type == SpindleType_PWM) {
                    if(!spindle_hal.cap.laser && spindle_hal.context.pwm->flags.ramp_pwm ) {
                        active_spindle->param.option.ramp_up = settings.spindle.on_delay > 0;
                        active_spindle->param.option.ramp_down = settings.spindle.off_delay > 0;
                    }
                    if(!active_spindle->param.option.ramp_up)
                        active_spindle->param.option.ignore_delays = spindle_hal.context.pwm->settings->flags.ignore_delays;
                }
                spindle_hal.param = &active_spindle->param;
                memcpy(&active_spindle->hal, &spindle_hal, sizeof(spindle_ptrs_t));
                if(grbl.on_spindle_selected)
                    grbl.on_spindle_selected(&active_spindle->hal);
#if N_SPINDLE > 1
                report_add_realtime(Report_SpindleId);
#endif
            }
        }
    }

    return ok;
}

/*! \brief Register a spindle with the core.
\param spindle pointer to a \a spindle_ptrs_t structure.
\param name pointer to a null terminated string.
\returns assigned \a spindle id as a \ref spindle_id_t if successful, -1 if not.

__NOTE:__ The first spindle registered will become the default active spindle.
__NOTE:__ up to \ref N_SPINDLE spindles can be registered at a time.
*/
FLASHMEM spindle_id_t spindle_register (const spindle_ptrs_t *spindle, const char *name)
{
    if(n_spindle == 1 && spindles[0].cfg->type == SpindleType_Null)
        n_spindle = 0;

    if(n_spindle < N_SPINDLE && settings_add_spindle_type(name)) {

        spindles[n_spindle].cfg = spindle;
        spindles[n_spindle].name = name;
        memcpy(&spindles[n_spindle].hal, spindles[n_spindle].cfg, sizeof(spindle_ptrs_t));
        spindles[n_spindle].hal.id = n_spindle;
#if N_SPINDLE > 1
        spindles[n_spindle].hal.spindle_num = -1;
#endif
        if(spindle->type == SpindleType_PWM) {
            if(pwm_spindle == NULL) {
                pwm_spindle = &spindles[n_spindle];
                hal.driver_cap.pwm_spindle = On;
            } // else
              //  task_run_on_startup(spindle_init, &spindles[n_spindle]);
        }

        if(n_spindle == 0)
            memcpy(&sys_spindle[0].hal, spindle, sizeof(spindle_ptrs_t));

        return n_spindle++;
    }

    return -1;
}

/*! \brief Enable a spindle and make it available for use by gcode.
\param spindle_id spindle id as a \ref spindle_id_t.
\returns assigned spindle number as a \a spindle_num_t if successful \a -1 if not.

__NOTE:__ up to \ref N_SYS_SPINDLE spindles can be enabled at a time.
*/
FLASHMEM spindle_num_t spindle_enable (spindle_id_t spindle_id)
{
    uint_fast8_t idx = 0;
    spindle_num_t spindle_num = -1;

    if(spindle_id >= 0 && spindle_id < n_spindle) do {

        spindle_reg_t *spindle = &spindles[spindle_id];

#if N_SYS_SPINDLE == 1
        if(!sys_spindle[idx].enabled) {
            spindle->hal.spindle_num = spindle_num = idx;
            sys_spindle[idx].enabled = true;
            memcpy(&sys_spindle[idx].hal, &spindle->hal, sizeof(spindle_ptrs_t));
            if(spindle->hal.type != SpindleType_VFD && (spindle->init_ok = spindle->hal.config == NULL || spindle->hal.config(&spindle->hal)))
                spindle->hal.set_state(&spindle->hal, (spindle_state_t){0}, 0.0f);
        }
#else
        if(!sys_spindle[idx].enabled) {
            spindle->hal.spindle_num = idx;
            if(spindle_activate(spindle))
                spindle_num = idx;
        }
#endif
    } while(++idx < N_ENA_SPINDLE && spindle_num == -1);

    return spindle_num;
}

/*! \brief Enables a spindle and sets it as the active spindle.
\param spindle_id spindle id as a \ref spindle_id_t.
\returns \a true if succsesful, \a false if not.
*/
FLASHMEM bool spindle_select (spindle_id_t spindle_id)
{
    if(n_spindle == 0 && spindle_id >= 0) {
        spindle_id = 0;
        spindle_add_null();
    }

    return (active_spindle->hal.id == spindle_id && active_spindle->activated) ||
            (spindle_id >= 0 && spindle_id < n_spindle && spindle_activate(&spindles[spindle_id]));
}


/*! \brief Get the handlers (function pointers) etc. associated with the spindle.
\param spindle_id spindle id as a \ref spindle_id_t.
\param hal a \ref spindle_hal_t enum value:
<br>\ref SpindleHAL_Raw - get the read only version as supplied at registration
<br>\ref SpindleHAL_Configured - get the version with run-time modifications applied by the spindle driver.
<br>\ref SpindleHAL_Active - get the enabled version available from gcode. Can be overriden by event handlers prior to activation.
\returns pointer to a \ref spindle_ptrs_t structure if successful, \a NULL if not.

__NOTE:__ do not modify the returned structure!
*/
FLASHMEM spindle_ptrs_t *spindle_get_hal (spindle_id_t spindle_id, spindle_hal_t hal)
{
    spindle_ptrs_t *spindle = NULL;

    if(hal == SpindleHAL_Active) {

        uint_fast8_t idx = N_ENA_SPINDLE;

        do {
            idx--;
            if(sys_spindle[idx].hal.id == spindle_id && sys_spindle[idx].enabled)
                spindle = &sys_spindle[idx].hal;
        } while(idx && spindle == NULL);

    } else if(spindle_id >= 0 && spindle_id < n_spindle && spindles[spindle_id].cfg)
        spindle = hal == SpindleHAL_Raw ? (spindle_ptrs_t *)spindles[spindle_id].cfg : &spindles[spindle_id].hal;

    return spindle;
}

/*! \brief Get the spindle id of the default spindle (spindle number 0).
\returns spindle id as a \ref spindle_id_t if successful, \a -2 if not (no spindle available).
*/
FLASHMEM spindle_id_t spindle_get_default (void)
{
    return sys_spindle[0].enabled ? sys_spindle[0].hal.id : -2;
}

/*! \brief Get the merged spindle capabilities of all registered spindles.
\param active true to return active capabilities, false to return default capabilities.
\returns capabilities in a \ref spindle_cap_t structure.
*/
FLASHMEM spindle_cap_t spindle_get_caps (bool active)
{
    spindle_cap_t caps = {0};
    uint_fast8_t idx = n_spindle;

    if(n_spindle) do {
        --idx;
        caps.value |= (active ? spindles[idx].hal.cap.value : spindles[idx].cfg->cap.value);
    } while(idx);

    return caps;
}

/*! \brief Get the registered name of a spindle.
\param spindle_id spindle id as a \ref spindle_id_t.
\returns pointer to a null terminated string if succesful, \a NULL if not.
*/
FLASHMEM const char *spindle_get_name (spindle_id_t spindle_id)
{
    return spindle_id >= 0 && spindle_id < n_spindle && spindles[spindle_id].cfg ? spindles[spindle_id].name : NULL;
}

/*! \brief Update the capabilities of a registered PWM spindle.
May be used by the driver on spindle initialization or when spindle settings has been changed.
\param spindle pointer to a \ref spindle_ptrs_t structure.
\param pwm_caps pointer to a \ref spindle_pwm_t structure.
*/
FLASHMEM void spindle_update_caps (spindle_ptrs_t *spindle, spindle_pwm_t *pwm_caps)
{
    uint_fast8_t idx = N_ENA_SPINDLE;

    spindle->type = pwm_caps ? SpindleType_PWM : SpindleType_Basic;
    spindle->cap.laser = !!pwm_caps && !pwm_caps->flags.laser_mode_disable && !!spindle->update_pwm && settings.mode == Mode_Laser;
    spindle->pwm_off_value = pwm_caps ? pwm_caps->off_value : 0;

    do {
        spindle_sys_t *sspindle = &sys_spindle[--idx];

        if(sspindle->enabled && spindle->id == sspindle->hal.id) {
            sspindle->hal.type = spindle->type;
            sspindle->hal.rpm_min = spindle->rpm_min;
            sspindle->hal.rpm_max = spindle->rpm_max;
            sspindle->hal.pwm_off_value = spindle->pwm_off_value;
            if((sspindle->hal.cap.laser = spindle->cap.laser) || spindle->type != SpindleType_PWM || !spindle->context.pwm->flags.ramp_pwm)
                sspindle->param.option.ramp_up = sspindle->param.option.ramp_down = Off;
            else {
                sspindle->param.option.ramp_up = settings.spindle.on_delay > 0;
                sspindle->param.option.ramp_down = settings.spindle.off_delay > 0;
            }
            if(sspindle->hal.cap.laser)
                sspindle->hal.cap.at_speed = Off;
            sspindle->param.option.ignore_delays = spindle->type == SpindleType_PWM && !sspindle->param.option.ramp_up && spindle->context.pwm->settings->flags.ignore_delays;
            break;
        }
    } while(idx);
}

/*! \brief Get number of registered spindles.
\returns number of registered spindles.
*/
FLASHMEM uint8_t spindle_get_count (void)
{
    if(n_spindle == 0)
        spindle_select(0);

    return n_spindle == 1 && spindles[0].cfg->type == SpindleType_Null ? 0 : n_spindle;
}

FLASHMEM bool spindle_get_id (uint8_t ref_id, spindle_id_t *spindle_id)
{
    bool ok = false;
    uint_fast8_t idx;

    *spindle_id = -1;

    for(idx = 0; idx < n_spindle; idx++) {
        if((ok = spindles[idx].cfg->ref_id == ref_id)) {
            *spindle_id = idx;
            break;
        }
    }

    return ok;
}

FLASHMEM static spindle_num_t spindle_get_num (spindle_id_t spindle_id)
{
    spindle_num_t spindle_num;

    if((spindle_num = spindle_get_count() == 1 ? 0 : -1) == -1) {

        const setting_detail_t *setting;
        uint_fast8_t idx = N_SPINDLE_SELECTABLE;

        do {
            idx--;
            if((setting = setting_get_details(idx == 0 ? Setting_SpindleType : (setting_id_t)(Setting_SpindleEnable0 + idx), NULL))) {
                if(setting_get_int_value(setting, setting->flags.increment ? idx : 0) - (idx == 0 ? 0 : 1) == spindle_id)
                    spindle_num = idx;
            }
        } while(idx && spindle_num == -1);
    }

    return spindle_num;
}

FLASHMEM void spindle_bind_encoder (const spindle_data_ptrs_t *encoder_data)
{
    uint_fast8_t idx;
    spindle_ptrs_t *spindle;

    encoder = encoder_data;

    for(idx = 0; idx < n_spindle; idx++) {

        spindle = spindle_get(spindle_get_num(idx));

        if(spindles[idx].hal.cap.laser) {
            spindles[idx].hal.get_data = NULL;
            spindles[idx].hal.reset_data = NULL;
            spindles[idx].hal.cap.at_speed = Off;
        } else if(encoder_data && spindles[idx].hal.ref_id == settings.spindle.encoder_spindle) {
            spindles[idx].hal.get_data = encoder_data->get;
            spindles[idx].hal.reset_data = encoder_data->reset;
            spindles[idx].hal.cap.at_speed = spindles[idx].hal.cap.variable;
        } else {
            spindles[idx].hal.get_data = spindles[idx].cfg->get_data;
            spindles[idx].hal.reset_data = spindles[idx].cfg->reset_data;
            spindles[idx].hal.cap.at_speed = spindles[idx].cfg->cap.at_speed;
        }

        if(spindle) {
            spindle->get_data = spindles[idx].hal.get_data;
            spindle->reset_data = spindles[idx].hal.reset_data;
            spindle->cap.at_speed = spindles[idx].hal.cap.at_speed;
        }
    }
}

FLASHMEM bool spindle_set_at_speed_range (spindle_ptrs_t *spindle, spindle_data_t *spindle_data, float rpm)
{
    spindle_data->rpm_programmed = rpm;
    spindle_data->state_programmed.at_speed = false;

    if((spindle_data->at_speed_enabled = spindle->at_speed_tolerance > 0.0f)) {
        spindle_data->rpm_low_limit = rpm * (1.0f - (spindle->at_speed_tolerance / 100.0f));
        spindle_data->rpm_high_limit = rpm * (1.0f + (spindle->at_speed_tolerance / 100.0f));
    }

    return spindle_data->at_speed_enabled;
}

/*! \brief Enumerate registered spindles by calling a callback function for each of them.
\param callback pointer to a \ref spindle_enumerate_callback_ptr type function.
\param data pointer to optional data to pass to the callback function.
\returns \a true if spindles are registered and a callback function was provided, \a false otherwise.
*/
FLASHMEM bool spindle_enumerate_spindles (spindle_enumerate_callback_ptr callback, void *data)
{
    if(callback == NULL || n_spindle == 0)
        return false;

    uint_fast8_t idx;
    spindle_info_t spindle;

    for(idx = 0; idx < n_spindle; idx++) {

        spindle.id = idx;
        spindle.ref_id = spindles[idx].cfg->ref_id;
        spindle.name = spindles[idx].name;
        spindle.num = spindles[idx].hal.spindle_num == -1 ? spindle_get_num(idx) : spindles[idx].hal.spindle_num;
        spindle.enabled = spindle.num != -1;
        spindle.hal = spindle.enabled ? &sys_spindle[spindle.num].hal : &spindles[idx].hal;
        spindle.is_current = spindle.enabled && active_spindle == &sys_spindle[spindle.num];

        if(callback(&spindle, data))
            return true;
    }

    return false;
}

// The following calls uses logical spindle numbers pointing into the sys_spindle array
// containing enabled spindles (spindle number as used by the $ gcode word)

/*! \brief Check if a spindle is enabled and available or not.
\param spindle_num spindle number as a \ref spindle_num_t.
\returns \a true if the spindle is enabled, \a false otherwise.
*/
FLASHMEM bool spindle_is_enabled (spindle_num_t spindle_num)
{
    spindle_sys_t *spindle = spindle_num == -1
                              ? active_spindle
                              : (spindle_num >= 0 && spindle_num < N_ENA_SPINDLE ? &sys_spindle[spindle_num] : NULL);

    return spindle && spindle->activated;
}

/*! \brief Get the handlers (function pointers) etc. associated with an enabled spindle.
\param spindle_num spindle number as a \ref spindle_num_t.
\returns pointer to a \ref spindle_ptrs_t structure if successful, \a NULL if not.

__NOTE:__ do not modify the returned structure!
*/
FLASHMEM spindle_ptrs_t *spindle_get (spindle_num_t spindle_num)
{
    spindle_sys_t *spindle = spindle_num == -1
                              ? active_spindle
                              : (spindle_num >= 0 && spindle_num < N_ENA_SPINDLE ? &sys_spindle[spindle_num] : NULL);

    return spindle && spindle->activated ? &spindle->hal : NULL;
}

//

//
// Null (dummy) spindle, automatically installed if no spindles are registered.
//

static spindle_state_t null_state;

FLASHMEM static void null_set_state (spindle_ptrs_t *spindle, spindle_state_t state, float rpm)
{
    UNUSED(spindle);
    UNUSED(rpm);
	
	null_state.mask = state.mask;
}

FLASHMEM static spindle_state_t null_get_state (spindle_ptrs_t *spindle)
{
    UNUSED(spindle);

    return null_state;
}

// Sets spindle speed
FLASHMEM static void null_update_pwm (spindle_ptrs_t *spindle, uint_fast16_t pwm_value)
{
    UNUSED(spindle);
    UNUSED(pwm_value);
}

FLASHMEM static uint_fast16_t null_get_pwm (spindle_ptrs_t *spindle, float rpm)
{
    UNUSED(spindle);
    UNUSED(rpm);

    return 0;
}

FLASHMEM static void null_update_rpm (spindle_ptrs_t *spindle, float rpm)
{
    UNUSED(spindle);
    UNUSED(rpm);
}

#ifdef GRBL_ESP32
static void null_esp32_off (spindle_ptrs_t *spindle)
{
    UNUSED(spindle);
}
#endif

/*! \brief Register a null spindle that has no connection to the outside world.
This is done automatically on startup if no spindle can be succesfully enabled.
\returns assigned spindle id as a \ref spindle_id_t if successful, \a -1 if not.
*/
FLASHMEM spindle_id_t spindle_add_null (void)
{
    PROGMEM static const spindle_ptrs_t spindle = {
        .type = SpindleType_Null,
        .cap.variable = Off,
        .cap.at_speed = Off,
        .cap.direction = On,
        .set_state = null_set_state,
#ifdef GRBL_ESP32
        .esp32_off = null_esp32_off,
#endif
        .get_state = null_get_state,
        .get_pwm = null_get_pwm,
        .update_pwm = null_update_pwm,
        .update_rpm = null_update_rpm
    };

    bool registered = false;
    uint_fast8_t idx = n_spindle;

    if(idx) do {
        if((registered = spindles[--idx].hal.type == SpindleType_Null))
            break;
    } while(idx);

    if(!registered)
        return spindle_register(&spindle, "NULL");

    return idx;
}

// End null (dummy) spindle.

typedef struct rpm_override {
    spindle_ptrs_t *spindle;
    uint16_t delay;
    uint32_t start, end;
    volatile float rpm;
    float rpm_delta;
    float rpm_target;
    struct rpm_override *next;
} rpm_override_t;

FLASHMEM static void spindle_ramp_task (void *data)
{
    bool ok;
    rpm_override_t *ramp = (rpm_override_t *)data;

    ramp->rpm = ramp->rpm + ramp->rpm_delta;

    if(ramp->rpm_delta > 0.0f) {
        if((ok = ramp->rpm >= ramp->rpm_target))
            ramp->rpm = ramp->rpm_target;
    } else if((ok = ramp->rpm <= ramp->rpm_target))
        ramp->rpm = ramp->rpm_target;

    if(!ok)
        task_add_delayed(spindle_ramp_task, data, ramp->delay);
    else
        ramp->delay = 0; // done

    ramp->end = hal.get_elapsed_ticks();

    ramp->spindle->update_pwm(ramp->spindle, ramp->spindle->get_pwm(ramp->spindle, ramp->rpm));
}

FLASHMEM static rpm_override_t *_get_ramp (spindle_ptrs_t *spindle)
{
    static rpm_override_t rampd = {0};

    if(rampd.spindle == spindle)
        return &rampd;

    rpm_override_t *ramp = &rampd;

    if(ramp->spindle == NULL)
        ramp->spindle = spindle;
    else {
        while(ramp->next && ramp->next->spindle != spindle && (ramp = ramp->next));

        if(ramp->next == NULL && (ramp->next = calloc(1, sizeof(rpm_override_t))))
            ramp->next->spindle = spindle;

        ramp = ramp->next;
    }

    return ramp;
}

FLASHMEM static uint16_t spindle_get_ramp (spindle_ptrs_t *spindle, float rpm, float target_rpm, uint16_t delay_ms, rpm_override_t *ramp)
{
    if(rpm != -1.0f)
        ramp->rpm = rpm;
    ramp->rpm_target = target_rpm;
    ramp->rpm_delta = target_rpm - ramp->rpm;
    ramp->delay = DWELL_TIME_STEP;

    uint16_t dly = ((uint16_t)(float)delay_ms * fabsf(ramp->rpm_delta / spindle->rpm_max));

    ramp->rpm_delta /= (float)(dly / ramp->delay) + 1;

    if(ramp->start == 0)
        ramp->start = hal.get_elapsed_ticks();

    return dly;
}

FLASHMEM static bool spindle_ramp_override (spindle_ptrs_t *spindle, float rpm, float target_rpm)
{
    rpm_override_t *ramp;

    if((ramp = _get_ramp(spindle))) {

        task_delete(spindle_ramp_task, ramp);

        if(ramp->delay)
            rpm = ramp->rpm;

        if(!(spindle_get_ramp(spindle, rpm, spindle->param->rpm_overridden, settings.spindle.on_delay, ramp) &&
             task_add_delayed(spindle_ramp_task, ramp, ramp->delay)))
            ramp = NULL;
    }

    return !!ramp;
}

/*! \brief Set spindle speed override.
\param spindle pointer to a \ref spindle_ptrs_t structure.
\param speed_override override as a percentage of the programmed RPM.
\returns overridden RPM
__NOTE:__ Unlike motion overrides, spindle overrides do not require a planner reinitialization.
*/
FLASHMEM float spindle_set_override (spindle_ptrs_t *spindle, override_t speed_override)
{
    speed_override = speed_override == 0 ? spindle->param->override_pct : constrain(speed_override, MIN_SPINDLE_RPM_OVERRIDE, MAX_SPINDLE_RPM_OVERRIDE);

    if((uint8_t)speed_override != spindle->param->override_pct || spindle->param->state.override_disable != spindle->param->option.override_disable) {

        float rpm = spindle->param->rpm_overridden;

        spindle_set_rpm(spindle, spindle->param->rpm, speed_override);

        if(!(spindle->param->option.ramp_up &&
              spindle->get_state(spindle).on &&
               spindle_ramp_override(spindle, rpm, spindle->param->rpm_overridden))) {
            if(state_get() == STATE_IDLE) {
                if(spindle->get_pwm && spindle->update_pwm)
                    spindle->update_pwm(spindle, spindle->get_pwm(spindle, spindle->param->rpm_overridden));
                else if(spindle->update_rpm)
                    spindle->update_rpm(spindle, spindle->param->rpm_overridden);
            } else {
                sys.step_control.update_spindle_rpm = On;
                spindle->param->option.override_pending = state_get() == STATE_HOLD;
            }
        }

        report_add_realtime(Report_Overrides); // Set to report change immediately

//       if(grbl.on_spindle_programmed)
//           grbl.on_spindle_programmed(spindle, spindle->param->state, spindle->param->rpm, spindle->param->rpm_mode);

       if(grbl.on_override_changed)
           grbl.on_override_changed(OverrideChanged_SpindleRPM);
    }

    return spindle->param->rpm_overridden;
}

FLASHMEM bool spindle_override_disable (spindle_ptrs_t *spindle, bool disable)
{
    spindle->param->option.override_disable = disable;
    spindle_set_override(spindle, spindle->param->override_pct);

    return disable;
}

/*! \brief Checks actual spindle state against given state.
\param spindle pointer to a \ref spindle_ptrs_t structure.
\param state a \ref spindle_state_t structure.
\returns \a true if on and ccw fields are equal, \a false otherwise.
*/
FLASHMEM bool spindle_check_state (spindle_ptrs_t *spindle, spindle_state_t state)
{
    static const spindle_state_t mask = {
       .on = On,
       .ccw = On
    };

    return (state.value & mask.value) == (spindle->get_state(spindle).value & mask.value);
}

FLASHMEM static void spindle_ramp (spindle_ptrs_t *spindle, spindle_state_t state, float rpm, float target_rpm, uint16_t delay_ms)
{
    bool ok = true;
    rpm_override_t *ramp;

    if(delay_ms > DWELL_TIME_STEP && (ramp = _get_ramp(spindle))) {

        task_delete(spindle_ramp_task, ramp);

        if(spindle_get_ramp(spindle, rpm, target_rpm, delay_ms, ramp) > DWELL_TIME_STEP) {

            float delay = (float)ramp->delay / 1000.0f;

            if(rpm == -1.0f) {
                rpm = ramp->rpm;
            }

            if(ramp->rpm_delta > 0.0f) {
                if(spindle->param->state.on != state.on || state.ccw != spindle->param->state.ccw) {
                    spindle->param->state.on = state.on;
                    spindle->set_state(spindle, state, (rpm += ramp->rpm_delta));
                }
                while(ok && (rpm + ramp->rpm_delta) < target_rpm) {
                    spindle->update_pwm(spindle, spindle->get_pwm(spindle, rpm += ramp->rpm_delta));
                    ok = delay_sec(delay, sys.suspend ? DelayMode_SysSuspend : DelayMode_Dwell);
                }
            } else while(ok && (rpm + ramp->rpm_delta) > target_rpm) {
                spindle->update_pwm(spindle, spindle->get_pwm(spindle, rpm += ramp->rpm_delta));
                ok = delay_sec(delay, sys.suspend ? DelayMode_SysSuspend : DelayMode_Dwell);
            }

            ramp->rpm = target_rpm;
            ramp->end = hal.get_elapsed_ticks();
        }
    }

    if(ok && rpm != target_rpm) {
        if(state.on == spindle->param->state.on)
            spindle->update_pwm(spindle, spindle->get_pwm(spindle, target_rpm));
        else
            spindle->set_state(spindle, state, target_rpm);
    }
}

/*! \internal \brief Immediately sets spindle running state with direction and spindle rpm, if enabled.
Called by g-code parser spindle_set_state_synced(), parking retract and restore, g-code program end,
sleep, and spindle stop override.
\param spindle pointer to a \ref spindle_ptrs_t structure.
\param state a \ref spindle_state_t structure.
\param rpm the spindle RPM to set.
\returns \a true if successful, \a false if the current controller state is \ref ABORTED.
*/
FLASHMEM static bool _spindle_set_state (spindle_ptrs_t *spindle, spindle_state_t state, float rpm, uint16_t on_delay_ms)
{
    if(!ABORTED) { // Block during abort.

        if(!state.on) { // Halt or set spindle direction and rpm.
            rpm = 0.0f;
            if(spindle->param->option.ramp_down)
                spindle_ramp(spindle, spindle->param->state, -1.0f, 0.0f, settings.spindle.off_delay);
            spindle->set_state(spindle, (spindle_state_t){0}, (spindle->param->rpm_overridden = 0.0f));
        } else {
            // NOTE: Assumes all calls to this function is when grblHAL is not moving or must remain off.
            // TODO: alarm/interlock if going from CW to CCW directly in non-laser mode?
            if(spindle->cap.laser && state.ccw)
                rpm = 0.0f; // TODO: May need to be rpm_min*(100/MAX_SPINDLE_RPM_OVERRIDE);

            if(spindle->param->option.ramp_up) {
                if(spindle->param->state.on && spindle->param->state.ccw != state.ccw) {
                    spindle_ramp(spindle, spindle->param->state, spindle->param->rpm_overridden, 0.0f, settings.spindle.off_delay);
                    spindle->param->rpm = spindle->param->rpm_overridden = 0.0f;
                }
                float arpm = spindle->param->rpm_overridden;
                spindle_ramp(spindle, state, arpm, spindle_set_rpm(spindle, rpm, spindle->param->override_pct), on_delay_ms ? on_delay_ms : settings.spindle.on_delay);
            } else
                spindle->set_state(spindle, state, spindle_set_rpm(spindle, rpm, spindle->param->override_pct));
        }

        spindle->param->rpm = rpm;
        spindle->param->state.on = state.on;
        spindle->param->state.ccw = state.ccw;

        report_add_realtime(Report_Spindle); // Set to report change immediately

        st_rpm_changed(rpm);
    }

    return !ABORTED;
}

FLASHMEM bool spindle_set_state (spindle_ptrs_t *spindle, spindle_state_t state, float rpm)
{
    return state_get() == STATE_CHECK_MODE || _spindle_set_state(spindle, state, rpm, 0);
}

/*! \brief If the spindle supports at speed functionality it will wait
for it to reach the speed and raise an alarm if the speed is not reached within the timeout period.
\param spindle pointer to a \ref spindle_ptrs_t structure.
\param state a \ref spindle_state_t structure.
\param rpm the spindle RPM to set.
\returns \a true if successful, \a false if the current controller state is \ref ABORTED.
*/
FLASHMEM static bool spindle_set_state_wait (spindle_ptrs_t *spindle, spindle_state_t state, float rpm, uint16_t delay_ms)
{
    bool ok;

    if(!(ok = state_get() == STATE_CHECK_MODE)) {

        if((ok = _spindle_set_state(spindle, state, rpm, delay_ms))) {

            if(sys.override.control.spindle_wait_disable ||
               spindle->param->option.ignore_delays ||
                (state.on ? spindle->param->option.ramp_up : spindle->param->option.ramp_down)) {
                sys.override.control.spindle_wait_disable = Off;
            } else {

                bool at_speed = !spindle->cap.at_speed || spindle->cap.torch || spindle->at_speed_tolerance <= 0.0f;

                if(at_speed)
                    ok = delay_ms == 0 || spindle->cap.torch || delay_sec((float)delay_ms / 1000.0f, sys.suspend ? DelayMode_SysSuspend : DelayMode_Dwell);
                else {
                    uint16_t delay = 0;
                    if(delay_ms == 0)
                        delay_ms = 60000; // one minute...
                    do {
                        if(!delay_sec(0.2f, sys.suspend ? DelayMode_SysSuspend : DelayMode_Dwell))
                            break;
                        delay += 200;
                        if(delay > delay_ms) {
                            gc_spindle_off();
                            system_raise_alarm(Alarm_Spindle);
                            break;
                        }
                    } while(!(at_speed = spindle->get_state(spindle).at_speed));

                    ok &= at_speed;
                }
            }
        }

        if(ok && grbl.on_spindle_at_speed)
            grbl.on_spindle_at_speed(spindle, state);
    }

    return ok;
}

/*! \brief G-code parser entry-point for setting spindle state. Forces a planner buffer sync and bails
if an abort or check-mode is active. If the spindle supports at speed functionality it will wait
for it to reach the speed and raise an alarm if the speed is not reached within the timeout period.
\param spindle pointer to a \ref spindle_ptrs_t structure.
\param state a \ref spindle_state_t structure.
\param rpm the spindle RPM to set.
\returns \a true if successful, \a false if the current controller state is \ref ABORTED.
*/
FLASHMEM bool spindle_set_state_synced (spindle_ptrs_t *spindle, spindle_state_t state, float rpm, spindle_rpm_mode_t mode)
{
    bool ok;

    if((ok = protocol_buffer_synchronize())) {  // Empty planner buffer to ensure spindle is set when programmed.

        if(grbl.on_spindle_programmed)
            grbl.on_spindle_programmed(spindle, state, rpm, mode);

        ok = spindle_set_state_wait(spindle, state, rpm, state.on ? settings.spindle.on_delay : settings.spindle.off_delay);
    }

    return ok;
}

/*! \brief Restore spindle running state with direction, enable, spindle RPM and appropriate delay.
\param spindle pointer to a \ref spindle_ptrs_t structure.
\param state a \ref spindle_state_t structure.
\param rpm the spindle RPM to set.
\returns \a true if successful, \a false if the current controller state is \ref ABORTED.
*/
FLASHMEM bool spindle_restore (spindle_ptrs_t *spindle, spindle_state_t state, float rpm, uint16_t delay_ms)
{
    bool ok;

    if(!spindle->param->option.restore_rpm && spindle->cap.laser) { // When in laser mode, ignore spindle spin-up delay. Set to turn on laser when cycle starts.
        if(!(ok = !settings.flags.disable_laser_during_hold && state.on && spindle_check_state(spindle, state)))
            ok = (sys.step_control.update_spindle_rpm = _spindle_set_state(spindle, state, 0.0f, 0));
    } else if(!(ok = !(spindle->param->option.restore_rpm || spindle->param->option.override_pending) && spindle_check_state(spindle, state) && spindle->param->rpm == rpm)) {
        ok = spindle_set_state_wait(spindle, state, rpm, delay_ms);
        if(!spindle->param->option.override_pending)
            spindle->param->option.restore_rpm = Off;
    }

    spindle->param->option.override_pending = Off;

    return ok;
}

/*! \brief Calculate and set programmed RPM according to override and max/min limits
\param spindle pointer to a \ref spindle_ptrs_t structure.
\param rpm the programmed RPM.
\param override_pct override value in percent.
\returns the calulated RPM.
*/
float spindle_set_rpm (spindle_ptrs_t *spindle, float rpm, override_t override_pct)
{
    if(override_pct != 100 && !spindle->param->option.override_disable)
        rpm *= 0.01f * (float)override_pct; // Scale RPM by override value.

    rpm = rpm <= 0.0f ? 0.0f : constrain(rpm, spindle->rpm_min, spindle->rpm_max);

    spindle->param->rpm_overridden = rpm;
    spindle->param->override_pct = override_pct;
    spindle->param->state.override_disable = spindle->param->option.override_disable;

    return rpm;
}

/*! \brief Turn off all enabled spindles.
*/
FLASHMEM void spindle_all_off (bool reset)
{
    spindle_ptrs_t *spindle;
    uint_fast8_t spindle_num = N_ENA_SPINDLE;

    do {
        if((spindle = spindle_get(--spindle_num))) {

            if(!reset && spindle->param->option.ramp_down)
                spindle_set_state(spindle, (spindle_state_t){0}, 0.0f);

            spindle->param->rpm = spindle->param->rpm_overridden = 0.0f;
            spindle->param->state.value = 0;
            spindle->param->option.restore_rpm = Off;
#ifdef GRBL_ESP32
            spindle->esp32_off(spindle);
#else
            spindle->set_state(spindle, (spindle_state_t){0}, 0.0f);
#endif
        }
    } while(spindle_num);

    report_add_realtime(Report_Spindle);
}

/*! \brief Check if any of the enabled spindles is running.
\returns \a true if a spindle is running, \a false otherwise.
*/
FLASHMEM bool spindle_is_on (void)
{
    bool on = false;

    spindle_ptrs_t *spindle;
    uint_fast8_t spindle_num = N_SYS_SPINDLE;
    do {
        if((spindle = spindle_get(--spindle_num)))
            on = spindle->get_state(spindle).on;
    } while(spindle_num && !on);

    return on;
}

//
// The following functions are not called by the core, may be called by driver code.
//

/*! \brief calculate inverted pwm value if configured
\param pwm_data pointer t a \a spindle_pwm_t structure.
\param pwm_value non inverted PWM value.
\returns the inverted PWM value to use.
*/
static inline uint_fast16_t invert_pwm (spindle_pwm_t *pwm_data, uint_fast16_t pwm_value)
{
    return pwm_data->flags.invert_pwm ? pwm_data->period - pwm_value : pwm_value;
}

/*! \brief Spindle RPM to PWM conversion.
\param pwm_data pointer t a \a spindle_pwm_t structure.
\param rpm spindle RPM.
\param pid_limit boolean, \a true if PID based spindle sync is used, \a false otherwise.
\returns the PWM value to use.

__NOTE:__ \a spindle_precompute_pwm_values() must be called to precompute values before this function is called.
Typically this is done by the spindle initialization code.
*/
static uint_fast16_t spindle_compute_pwm_value (spindle_pwm_t *pwm_data, float rpm, bool pid_limit)
{
    uint_fast16_t pwm_value;

    if(rpm > pwm_data->rpm_min) {

#if ENABLE_SPINDLE_LINEARIZATION
        // Compute intermediate PWM value with linear spindle speed model via piecewise linear fit model.
        uint_fast8_t idx = pwm_data->n_pieces;

        if(idx) {
            do {
                idx--;
                if(idx == 0 || rpm > pwm_data->piece[idx].rpm) {
                    pwm_value = floorf((pwm_data->piece[idx].start * rpm - pwm_data->piece[idx].end) * pwm_data->pwm_gradient);
                    break;
                }
            } while(idx);
        } else
#endif
        // Compute intermediate PWM value with linear spindle speed model.
        pwm_value = (uint_fast16_t)floorf((rpm - pwm_data->rpm_min) * pwm_data->pwm_gradient) + pwm_data->min_value;

        if(pwm_value >= (pid_limit ? pwm_data->period : pwm_data->max_value))
            pwm_value = pid_limit ? pwm_data->period - 1 : pwm_data->max_value;
        else if(pwm_value < pwm_data->min_value)
            pwm_value = pwm_data->min_value;

        if(pwm_data->flags.laser_off_overdrive) {
            int32_t pwm_overdrive;
            pwm_overdrive = (uint32_t)pwm_value + (uint32_t)((float)pwm_value * pwm_data->off_overdrive_pct) / 100.0f;
            pwm_data->pwm_overdrive = invert_pwm(pwm_data, constrain((uint_fast16_t)pwm_overdrive, pwm_data->min_value, pwm_data->max_value));
        }

        pwm_value = invert_pwm(pwm_data, pwm_value);

    } else
        pwm_value = rpm == 0.0f ? pwm_data->off_value : invert_pwm(pwm_data, pwm_data->min_value);

    return pwm_value;
}

/*! \internal \brief Dummy spindle RPM to PWM conversion, used if precompute fails.
\param pwm_data pointer t a \a spindle_pwm_t structure.
\param rpm spindle RPM.
\param pid_limit boolean, \a true if PID based spindle sync is used, \a false otherwise.
\returns the PWM value to use.
*/
static uint_fast16_t compute_dummy_pwm_value (spindle_pwm_t *pwm_data, float rpm, bool pid_limit)
{
    return pwm_data->off_value;
}

static void set_laser_overdrive (struct spindle_pwm *pwm_data, float overdrive_pct)
{
    pwm_data->flags.laser_off_overdrive = pwm_data->flags.rpm_controlled && (pwm_data->off_overdrive_pct = overdrive_pct) != 0.0f;
}

/*! \brief Precompute PWM values for faster conversion.
\param spindle pointer to a \ref spindle_ptrs_t structure.
\param pwm_data pointer to a \a spindle_pwm_t structure, to hold the precomputed values.
\param clock_hz timer clock frequency used for PWM generation.
\returns \a true if successful, \a false if no PWM range possible - driver should then revert to simple on/off spindle control.
*/
FLASHMEM bool spindle_precompute_pwm_values (spindle_ptrs_t *spindle, spindle_pwm_t *pwm_data, spindle_pwm_settings_t *settings, uint32_t clock_hz)
{
    pwm_data->settings = settings;
    pwm_data->off_value = pwm_data->pwm_overdrive = 0;
    pwm_data->set_laser_overdrive = set_laser_overdrive;

    spindle->rpm_min = pwm_data->rpm_min = settings->rpm_min;
    spindle->rpm_max = settings->rpm_max;
    spindle->at_speed_tolerance = settings->at_speed_tolerance;
    spindle->cap.rpm_range_locked = On;

    if((spindle->cap.variable = !settings->flags.pwm_disable && spindle->rpm_max > spindle->rpm_min)) {
        pwm_data->f_clock = clock_hz;
        pwm_data->period = (uint_fast16_t)((float)clock_hz / settings->pwm_freq);
        pwm_data->flags.always_on = settings->pwm_off_value != 0.0f;
        pwm_data->flags.invert_pwm = settings->invert.pwm & spindle->cap.pwm_invert;
        pwm_data->flags.rpm_controlled = settings->flags.enable_rpm_controlled;
        pwm_data->flags.laser_mode_disable = settings->flags.laser_mode_disable;
        pwm_data->flags.ramp_pwm = settings->flags.pwm_ramped;
        if(settings->pwm_off_value == 0.0f)
            pwm_data->off_value = pwm_data->flags.invert_pwm ? pwm_data->period - pwm_data->offset : 0;
        else
            pwm_data->off_value = invert_pwm(pwm_data, (uint_fast16_t)(pwm_data->period * settings->pwm_off_value / 100.0f));
        pwm_data->max_value = (uint_fast16_t)(pwm_data->period * settings->pwm_max_value / 100.0f) + pwm_data->offset;
        if((pwm_data->min_value = (uint_fast16_t)(pwm_data->period * settings->pwm_min_value / 100.0f)) == 0 && spindle->rpm_min > 0.0f)
            pwm_data->min_value = (uint_fast16_t)((float)pwm_data->max_value * 0.004f);

        pwm_data->pwm_gradient = (float)(pwm_data->max_value - pwm_data->min_value) / (spindle->rpm_max - spindle->rpm_min);
        pwm_data->compute_value = spindle_compute_pwm_value;
    } else {
        pwm_data->flags.value &= ((spindle_pwm_flags_t){ .cloned = pwm_data->flags.cloned }).value;
        pwm_data->compute_value = compute_dummy_pwm_value;
    }

    spindle->context.pwm = pwm_data;

#if ENABLE_SPINDLE_LINEARIZATION
    uint_fast8_t idx;

    pwm_data->n_pieces = 0;

    for(idx = 0; idx < SPINDLE_NPWM_PIECES; idx++) {
        if(!isnan(settings->pwm_piece[idx].rpm) && settings->pwm_piece[idx].start != 0.0f)
            memcpy(&pwm_data->piece[pwm_data->n_pieces++], &settings->pwm_piece[idx], sizeof(pwm_piece_t));
    }

    spindle->cap.pwm_linearization = pwm_data->n_pieces > 0;
#endif

    return spindle->cap.variable;
}

#if N_SPINDLE > 1

#include "grbl/nvs_buffer.h"

static spindle1_pwm_settings_t sp1_settings;
static uint32_t nvs_address;
static char spindle_signals[] = "Spindle enable,Spindle direction,PWM";
static bool ports_ok = false;
static char max_aport[4], max_dport[4];
static spindle_cap_t spindle_cap;
static settings_changed_ptr on_settings_changed;
static spindle1_settings_changed_ptr on_spindle1_settings_changed;

#if ENABLE_SPINDLE_LINEARIZATION

FLASHMEM static status_code_t set_linear_piece (setting_id_t id, char *svalue)
{
    uint32_t idx = id - Setting_LinearSpindle1Piece1;
    float rpm, start, end;

    if(*svalue == '\0' || (svalue[0] == '0' && svalue[1] == '\0')) {
        sp1_settings.cfg.pwm_piece[idx].rpm = NAN;
        sp1_settings.cfg.pwm_piece[idx].start =
        sp1_settings.cfg.pwm_piece[idx].end = 0.0f;
    } else if(sscanf(svalue, "%f,%f,%f", &rpm, &start, &end) == 3) {
        sp1_settings.cfg.pwm_piece[idx].rpm = rpm;
        sp1_settings.cfg.pwm_piece[idx].start = start;
        sp1_settings.cfg.pwm_piece[idx].end = end;
//??       if(idx == 0)
//            sp1_settings.cfg.rpm_min = rpm;
    } else
        return Status_SettingValueOutOfRange;

    return Status_OK;
}

FLASHMEM static char *get_linear_piece (setting_id_t id)
{
    static char buf[40];

    uint32_t idx = id - Setting_LinearSpindle1Piece1;

    if(isnan(sp1_settings.cfg.pwm_piece[idx].rpm))
        *buf = '\0';
    else
        snprintf(buf, sizeof(buf), "%g,%g,%g", sp1_settings.cfg.pwm_piece[idx].rpm, sp1_settings.cfg.pwm_piece[idx].start, sp1_settings.cfg.pwm_piece[idx].end);

    return buf;
}

#endif // ENABLE_SPINDLE_LINEARIZATION

FLASHMEM static status_code_t set_spindle_invert (setting_id_t id, uint_fast16_t int_value)
{
    sp1_settings.cfg.invert.mask = int_value;
    if(sp1_settings.cfg.invert.pwm && !spindle_cap.pwm_invert) {
        sp1_settings.cfg.invert.pwm = Off;
        return Status_SettingDisabled;
    }

    return Status_OK;
}

FLASHMEM static status_code_t set_pwm_options (setting_id_t id, uint_fast16_t int_value)
{
    if(int_value & 0b0001) {
#if N_SPINDLE > 1
        if(int_value > 0b11111)
            return Status_SettingValueOutOfRange;
#else
        if(int_value > 0b01111)
            return Status_SettingValueOutOfRange;
#endif
        sp1_settings.cfg.flags.pwm_disable = Off;
        sp1_settings.cfg.flags.enable_rpm_controlled = !!(int_value & 0b00010);
        sp1_settings.cfg.flags.laser_mode_disable = !!(int_value & 0b00100);
        sp1_settings.cfg.flags.pwm_ramped = !!(int_value & 0b01000);
#if N_SPINDLE > 1
        sp1_settings.cfg.flags.ignore_delays = !!(int_value & 0b10000);
#endif
        } else {
        sp1_settings.cfg.flags.pwm_disable = On;
        sp1_settings.cfg.flags.enable_rpm_controlled =
         sp1_settings.cfg.flags.laser_mode_disable =
          sp1_settings.cfg.flags.pwm_ramped =
           sp1_settings.cfg.flags.ignore_delays = Off;
    }

    return Status_OK;
}

FLASHMEM static uint32_t get_int (setting_id_t id)
{
    uint32_t value = 0;

    switch(id) {

        case Setting_SpindlePWMOptions1:
            value = sp1_settings.cfg.flags.pwm_disable
                     ? 0
                     : (0b0001 |
                        (sp1_settings.cfg.flags.enable_rpm_controlled ? 0b00010 : 0) |
                         (sp1_settings.cfg.flags.laser_mode_disable ? 0b00100 : 0) |
                          (sp1_settings.cfg.flags.pwm_ramped ? 0b01000 : 0) |
                           (sp1_settings.cfg.flags.ignore_delays ? 0b10000 : 0));
            break;

        case Setting_SpindleInvertMask1:
            value = sp1_settings.cfg.invert.value;
            break;

        default:
            break;
    }

    return value;
}

FLASHMEM static float get_port (setting_id_t id)
{
    uint8_t port;

    switch(id) {

        case Setting_Spindle_OnPort:
            port = sp1_settings.port_on;
            break;

        case Setting_Spindle_DirPort:
            port = sp1_settings.port_dir;
            break;

        default: // Setting_Spindle_PWMPort:
            port = sp1_settings.port_pwm;
            break;
    }

    return port == IOPORT_UNASSIGNED ? -1.0f : (float)port;
}

FLASHMEM bool pwm_port_validate (xbar_t *properties, uint8_t port, void *data)
{
    return port == *(uint8_t *)data;
}

FLASHMEM static status_code_t set_port (setting_id_t id, float value)
{
    bool ok = true;
    uint8_t port = value < 0.0f ? IOPORT_UNASSIGNED : (uint8_t)value;

    switch(id) {

        case Setting_Spindle_OnPort:
            sp1_settings.port_on = port;
            break;

        case Setting_Spindle_DirPort:
            sp1_settings.port_dir = port;
            break;

        default: // Setting_Spindle_PWMPort:
            if((ok = port == sp1_settings.port_pwm ||
                      ioports_enumerate(Port_Analog, Port_Output, (pin_cap_t){ .claimable = On, .pwm = On }, pwm_port_validate, &port)))
                sp1_settings.port_pwm = port;
            break;
    }

    return ok ? Status_OK : Status_SettingValueOutOfRange;
}

FLASHMEM static bool has_pwm (const setting_detail_t *setting, uint_fast16_t offset)
{
    return spindle_cap.variable;
}

FLASHMEM static bool has_freq (const setting_detail_t *setting, uint_fast16_t offset)
{
    return spindle_cap.variable && !spindle_cap.clone;
}

FLASHMEM static bool has_ports (const setting_detail_t *setting, uint_fast16_t offset)
{
    return ports_ok;
}

static char spindle_options[] = PWM_SPINDLE_OPTIONS;

PROGMEM static const setting_detail_t spindle1_settings[] = {
    { Setting_Spindle_OnPort, Group_AuxPorts, "PWM2 spindle on port", NULL, Format_Decimal, "-#0", "0", max_dport, Setting_NonCoreFn, set_port, get_port, has_ports, { .reboot_required = On } },
    { Setting_Spindle_DirPort, Group_AuxPorts, "PWM2 spindle direction port", NULL, Format_Decimal, "-#0", "-1", max_dport, Setting_NonCoreFn, set_port, get_port, has_ports, { .reboot_required = On } },
    { Setting_SpindleInvertMask1, Group_Spindle, "PWM2 spindle signals invert", NULL, Format_Bitfield, spindle_signals, NULL, NULL, Setting_IsExtendedFn, set_spindle_invert, get_int, NULL, { .reboot_required = On } },
    { Setting_Spindle_PWMPort, Group_AuxPorts, "PWM2 spindle PWM port", NULL, Format_Decimal, "-#0", "0", max_aport, Setting_NonCoreFn, set_port, get_port, has_ports, { .reboot_required = On } },
    { Setting_SpindlePWMOptions1, Group_Spindle, "PWM2 spindle options", NULL, Format_XBitfield, spindle_options, NULL, NULL, Setting_IsExtendedFn, set_pwm_options, get_int, has_pwm },
    { Setting_RpmMax1, Group_Spindle, "PWM2 spindle max speed", "RPM", Format_Decimal, "#####0.000", NULL, NULL, Setting_IsLegacy, &sp1_settings.cfg.rpm_max, NULL, has_pwm },
    { Setting_RpmMin1, Group_Spindle, "PWM2 spindle min speed", "RPM", Format_Decimal, "#####0.000", NULL, NULL, Setting_IsLegacy, &sp1_settings.cfg.rpm_min, NULL, has_pwm },
    { Setting_PWMFreq1, Group_Spindle, "PWM2 spindle PWM frequency", "Hz", Format_Decimal, "#####0", NULL, NULL, Setting_IsExtended, &sp1_settings.cfg.pwm_freq, NULL, has_freq },
    { Setting_PWMOffValue1, Group_Spindle, "PWM2 spindle PWM off value", "percent", Format_Decimal, "##0.0", NULL, "100", Setting_IsExtended, &sp1_settings.cfg.pwm_off_value, NULL, has_pwm },
    { Setting_PWMMinValue1, Group_Spindle, "PWM2 spindle PWM min value", "percent", Format_Decimal, "##0.0", NULL, "100", Setting_IsExtended, &sp1_settings.cfg.pwm_min_value, NULL, has_pwm },
    { Setting_PWMMaxValue1, Group_Spindle, "PWM2 spindle PWM max value", "percent", Format_Decimal, "##0.0", NULL, "100", Setting_IsExtended, &sp1_settings.cfg.pwm_max_value, NULL, has_pwm }
#if xENABLE_SPINDLE_LINEARIZATION
     { Setting_LinearSpindle1Piece1, Group_Spindle, "PWM2 spindle linearisation, 1st point", NULL, Format_String, "x(39)", NULL, "39", Setting_IsExtendedFn, set_linear_piece, get_linear_piece, NULL },
  #if SPINDLE_NPWM_PIECES > 1
     { Setting_LinearSpindle1Piece2, Group_Spindle, "PWM2 spindle linearisation, 2nd point", NULL, Format_String, "x(39)", NULL, "39", Setting_IsExtendedFn, set_linear_piece, get_linear_piece, NULL },
  #endif
  #if SPINDLE_NPWM_PIECES > 2
     { Setting_LinearSpindle1Piece3, Group_Spindle, "PWM2 spindle linearisation, 3rd point", NULL, Format_String, "x(39)", NULL, "39", Setting_IsExtendedFn, set_linear_piece, get_linear_piece, NULL },
  #endif
  #if SPINDLE_NPWM_PIECES > 3
     { Setting_LinearSpindle1Piece4, Group_Spindle, "PWM2 spindle linearisation, 4th point", NULL, Format_String, "x(39)", NULL, "39", Setting_IsExtendedFn, set_linear_piece, get_linear_piece, NULL },
  #endif
#endif
};

PROGMEM static const setting_descr_t spindle1_settings_descr[] = {
    { Setting_Spindle_OnPort, "On/off aux port." },
    { Setting_Spindle_DirPort, "Direction aux port, set to -1 if not required." },
    { Setting_SpindleInvertMask1, "Inverts the spindle on, counterclockwise and PWM signals (active low)." },
    { Setting_Spindle_PWMPort, "Spindle analog aux port. Must be PWM capable!" },
    { Setting_SpindlePWMOptions1, "Enable controls PWM output availability.\\n"
                                  "When `RPM controls spindle enable signal` is checked and M3 or M4 is active S0 switches it off and S > 0 switches it on.\\n"
                                  "When 'Ramping enable' is checked spin up and spin down time is calculated from $394 and $539 respectively."
    },
    { Setting_RpmMax1, "Maximum spindle speed." },
    { Setting_RpmMin1, "Minimum spindle speed." },
    { Setting_PWMFreq1, "PWM frequency." },
    { Setting_PWMOffValue1, "PWM off value in percent (duty cycle)." },
    { Setting_PWMMinValue1, "PWM min value in percent (duty cycle)." },
    { Setting_PWMMaxValue1, "PWM max value in percent (duty cycle)." }
#if xENABLE_SPINDLE_LINEARIZATION
     { Setting_LinearSpindle1Piece1, "Comma separated list of values: RPM_MIN, RPM_LINE_A1, RPM_LINE_B1, set to blank to disable." },
  #if SPINDLE_NPWM_PIECES > 1
     { Setting_LinearSpindle1Piece2, "Comma separated list of values: RPM_POINT12, RPM_LINE_A2, RPM_LINE_B2, set to blank to disable." },
  #endif
  #if SPINDLE_NPWM_PIECES > 2
     { Setting_LinearSpindle1Piece3, "Comma separated list of values: RPM_POINT23, RPM_LINE_A3, RPM_LINE_B3, set to blank to disable." },
  #endif
  #if SPINDLE_NPWM_PIECES > 3
     { Setting_LinearSpindle1Piece4, "Comma separated list of values: RPM_POINT34, RPM_LINE_A4, RPM_LINE_B4, set to blank to disable." },
  #endif
#endif
};

FLASHMEM static void spindle1_settings_changed (settings_t *settings, settings_changed_flags_t changed)
{
    UNUSED(changed);

    if(on_spindle1_settings_changed)
        on_spindle1_settings_changed(&sp1_settings);
}

FLASHMEM static void onSettingsChanged (settings_t *settings, settings_changed_flags_t changed)
{
    on_settings_changed(settings, changed);

    if(changed.spindle)
        spindle1_settings_changed(settings, changed);
}

FLASHMEM static void spindle1_settings_save (void)
{
    hal.nvs.memcpy_to_nvs(nvs_address, (uint8_t *)&sp1_settings, sizeof(spindle1_pwm_settings_t), true);
}

FLASHMEM static void spindle1_settings_restore (void)
{
    PROGMEM static const spindle_pwm_settings_t defaults = {
        .rpm_max = DEFAULT_SPINDLE1_RPM_MAX,
        .rpm_min = DEFAULT_SPINDLE1_RPM_MIN,
        .flags.pwm_disable = false,
        .flags.enable_rpm_controlled = DEFAULT_PWM_SPINDLE1_ENABLE_OFF_WITH_ZERO_SPEED,
        .flags.laser_mode_disable = DEFAULT_PWM_SPINDLE1_DISABLE_LASER_MODE,
        .flags.pwm_ramped = DEFAULT_PWM_SPINDLE1_ENABLE_RAMP,
        .flags.ignore_delays = DEFAULT_PWM_SPINDLE1_IGNORE_DELAYS,
        .invert.on = DEFAULT_INVERT_SPINDLE1_ENABLE_PIN,
        .invert.ccw = DEFAULT_INVERT_SPINDLE1_CCW_PIN,
        .invert.pwm = DEFAULT_INVERT_SPINDLE1_PWM_PIN,
        .pwm_freq = DEFAULT_SPINDLE1_PWM_FREQ,
        .pwm_off_value = DEFAULT_SPINDLE1_PWM_OFF_VALUE,
        .pwm_min_value = DEFAULT_SPINDLE1_PWM_MIN_VALUE,
        .pwm_max_value = DEFAULT_SPINDLE1_PWM_MAX_VALUE,
        .at_speed_tolerance = DEFAULT_SPINDLE_AT_SPEED_TOLERANCE,
#if ENABLE_SPINDLE_LINEARIZATION
  #if SPINDLE_NPWM_PIECES > 0
        .pwm_piece[0] = { .rpm = DEFAULT_RPM_POINT01, .start = DEFAULT_RPM_LINE_A1, .end = DEFAULT_RPM_LINE_B1 },
  #endif
  #if SPINDLE_NPWM_PIECES > 1
        .pwm_piece[1] = { .rpm = DEFAULT_RPM_POINT12, .start = DEFAULT_RPM_LINE_A2, .end = DEFAULT_RPM_LINE_B2 },
  #endif
  #if SPINDLE_NPWM_PIECES > 2
        .pwm_piece[2] = { .rpm = DEFAULT_RPM_POINT23, .start = DEFAULT_RPM_LINE_A3, .end = DEFAULT_RPM_LINE_B3 },
  #endif
  #if SPINDLE_NPWM_PIECES > 3
        .pwm_piece[3] = { .rpm = DEFAULT_RPM_POINT34, .start = DEFAULT_RPM_LINE_A4, .end = DEFAULT_RPM_LINE_B4 },
  #endif
#else
  #if SPINDLE_NPWM_PIECES > 0
        .pwm_piece[0] = { .rpm = NAN, .start = 0.0f, .end = 0.0f },
  #endif
  #if SPINDLE_NPWM_PIECES > 1
        .pwm_piece[1] = { .rpm = NAN, .start = 0.0f, .end = 0.0f },
  #endif
  #if SPINDLE_NPWM_PIECES > 2
        .pwm_piece[2] = { .rpm = NAN, .start = 0.0f, .end = 0.0f },
  #endif
  #if SPINDLE_NPWM_PIECES > 3
        .pwm_piece[3] = { .rpm = NAN, .start = 0.0f, .end = 0.0f },
  #endif
#endif
    };

    memcpy(&sp1_settings.cfg, &defaults, sizeof(spindle_pwm_settings_t));

    sp1_settings.port_pwm = ioport_find_free(Port_Analog, Port_Output, (pin_cap_t){.claimable = On, .pwm = On }, NULL);
    sp1_settings.port_on = ioport_find_free(Port_Digital, Port_Output, (pin_cap_t){ .claimable = On }, NULL);
    sp1_settings.port_dir = sp1_settings.port_on != IOPORT_UNASSIGNED && sp1_settings.port_on > 0 ? sp1_settings.port_on - 1 : IOPORT_UNASSIGNED;

    hal.nvs.memcpy_to_nvs(nvs_address, (uint8_t *)&sp1_settings, sizeof(spindle1_pwm_settings_t), true);
}

FLASHMEM static void spindle1_settings_load (void)
{
    if((hal.nvs.memcpy_from_nvs((uint8_t *)&sp1_settings, nvs_address, sizeof(spindle1_pwm_settings_t), true) != NVS_TransferResult_OK))
        spindle1_settings_restore();

    sp1_settings.cfg.at_speed_tolerance = settings.spindle.at_speed_tolerance;

#if N_SPINDLE == 1
    sp1_settings.cfg.flags.ignore_delays = Off;
#endif
}

FLASHMEM spindle1_pwm_settings_t *spindle1_settings_add (bool claim_ports)
{
    uint8_t a_out = IOPORT_UNASSIGNED;

    if((ports_ok = claim_ports &&
                    ioports_available(Port_Digital, Port_Output) &&
                     (a_out = ioport_find_free(Port_Analog, Port_Output, (pin_cap_t){ .claimable = On, .pwm = On }, NULL)) != IOPORT_UNASSIGNED)) {

        strcpy(max_aport, uitoa(a_out));
        strcpy(max_dport, uitoa(ioport_find_free(Port_Digital, Port_Output, (pin_cap_t){ .claimable = On }, NULL)));
    }

    return nvs_address == 0 && (!claim_ports || ports_ok) && (nvs_address = nvs_alloc(sizeof(spindle1_pwm_settings_t))) ? &sp1_settings : NULL;
}

FLASHMEM void spindle1_settings_register (spindle_cap_t cap, spindle1_settings_changed_ptr on_changed)
{
    static setting_details_t spindle1_setting_details = {
        .is_core = true,
        .settings = spindle1_settings,
        .n_settings = sizeof(spindle1_settings) / sizeof(setting_detail_t),
        .descriptions = spindle1_settings_descr,
        .n_descriptions = sizeof(spindle1_settings_descr) / sizeof(setting_descr_t),
        .load = spindle1_settings_load,
        .restore = spindle1_settings_restore,
        .save = spindle1_settings_save,
        .on_changed = spindle1_settings_changed
    };

    if((on_spindle1_settings_changed = on_changed)) {
        on_settings_changed = grbl.on_settings_changed;
        grbl.on_settings_changed = onSettingsChanged;
    }

    settings_register(&spindle1_setting_details);

    spindle_cap = cap;

    spindle_state_t spindle_state = { .on = On };
    spindle_state.ccw = cap.direction;
    spindle_state.pwm = cap.pwm_invert;

    if(!cap.laser)
        setting_remove_elements(Setting_SpindlePWMOptions1, PWM_SPINDLE_OPTIONS_MASK ^ 0b0100, true);
    setting_remove_elements(Setting_SpindleInvertMask1, spindle_state.mask, true);
}

#endif // N_SPINDLE > 1