Callback function after stepper movement is completed

[rqi14]

Hi. Many thanks for sharing this awesome project! As an amateur to hardware programming, I can't imagine how my projects can be done without your fantastic library.

My project involves controlling a slider to the desired place from a PC client. The Move() and MoveTo() functions are very helpful achieving this. However, currently the PC client does not know whether it is finished, unless querying the steppers in a loop. I am wondering if there is already a way to insert a callback function to the engine so that it will be executed to let the pc know the movement has finished. I know there is already a blocking option in the movement. My program invovles controlling multiple stepper motors so blocking is hard to deal with.

[gin66]

No, there is no such way and it would be a new feature. Definitely easier, than the callback for the enable pin, which is actually a callback at beginning and end of the movement.

[gin66]

The main problem is, that a callback is running in scope of the cyclic stepper task (or for avr in scope of an interrupt service routine, for which interrupts have been enabled - so kind of multitasking light). This means, any callback ideally does not restart the motor or does any time consuming work. Consequently, it is difficult to get this right from application side.

For avr devices, I think polling in the loop makes sense. For esp32 it would be a mechanism of choice, but actually a separate task with medium priority, which is polling and mostly sleeping for milliseconds, can accomplish the same and that task can check for many motors and do the time consuming work, too.

If anyone can offer a PR, I will look at it. But I doubt, that I will work on this.

[DaveAuld]

I was looking for this as well, but came up with a suitable workaround (is a dev project, so may change), but basically I wrapped the stepper into a motor control class and run an ESP32 periodic timer, this checks the state of the library isRunning(), if it changes it then triggers all the registered call backs on the class.

e.g.
for a class MotorControl, in the motorControl.h

#include <vector>
#include "esp_timer.h"

void init();
void moveTo(int position, bool blocking);

// Stepper 
    FastAccelStepperEngine _engine = FastAccelStepperEngine();
    FastAccelStepper *_stepper = NULL;

// Peridocic timer
    esp_timer_handle_t _positionUpdateTimer;
    static IRAM_ATTR void onPositionUpdateTimerCallback(void * arg);

// Register the callback function for when the motor stops
        void registerOnMotorStoppedCallback(std::function<void()> callback); // Set the callback function for when the motor stops

 // Callbacks store
 std::vector<std::function<void()>> _onMotorStoppedCallbacks; // Pointer to the callback function for when the motor stops

for the MotorControl.cpp

#include <algorithm>
#include "esp_timer.h"

void MotorControl::init() 
{
   // Stepper Initialise
    _engine.init();
    _stepper = _engine.stepperConnectToPin(MOTOR_STEP_PIN);

    if (_stepper) {
        _stepper->setDirectionPin(MOTOR_DIRECTION_PIN);
        _stepper->setEnablePin(MOTOR_ENABLE_PIN); 
        _stepper->setAutoEnable(true);

// Periodic Timer
    esp_timer_create_args_t positionUpdateTimerArgs = {
        .callback = &MotorControl::onPositionUpdateTimerCallback,
        .arg = this,
        .dispatch_method = ESP_TIMER_TASK,
        .name = "positionUpdateTimer"
    };

    esp_timer_create(&positionUpdateTimerArgs, &_positionUpdateTimer);

}

void MotorControl::registerOnMotorStoppedCallback(std::function<void()> callback) {
    _onMotorStoppedCallbacks.push_back(callback); // Store the callback function
}

// Function to call from other classes to start movement
void MotorControl::moveTo(int position, bool blocking)
{
    if (_stepper) {
        _stepper->moveTo(position, blocking);  
        Serial.println("Moving to position: " + String(position)); // Debugging message

        // Start the position update timer if the stepper is running
        if (esp_timer_is_active(_positionUpdateTimer) == false) {
                esp_timer_start_periodic(_positionUpdateTimer, 1 * 1000 * 1000); // 1 second in microseconds
        }
    }
}

// Call back handler
void MotorControl::onPositionUpdateTimerCallback(void * arg)
{
    MotorControl* motorControl = static_cast<MotorControl*>(arg);

    FastAccelStepper* _stepper = motorControl->_stepper;

    if (_stepper) {
        bool isMoving = _stepper->isRunning(); // Check if the stepper is still running
        Serial.println("Stepper is running: " + String(isMoving)); // Debugging message
       
      if (!isMoving) {
            Serial.println("Stepper has stopped."); // Debugging message
            if (esp_timer_is_active(_positionUpdateTimer) == false) {
            esp_timer_stop(motorControl->_positionUpdateTimer); // Stop the timer if the stepper is not running
}

            // invoke all registered callbacks
            for (const auto& callback : motorControl->_onMotorStoppedCallbacks) {
                if (callback) {
                    callback(); // Call the callback function
                };
            }
        }        
    }
}

In the other classes you want a call back from you can register the with the method you want to call on callback;

#include "motorControl.h"
motorControl.registerOnMotorStoppedCallback(onMotorStopped); // Register the callback function for when the motor stops

void onMotorStopped(){
  Serial.println("Motor Stopped Callback Triggered.");
}