Moving three motors

[Freeejack]

I want to use the library with three stepper motors.
The movement of the three motors is smooth, silent, so this is ok.

But i want to move sometimes the motors from one saved place to a second place and back. This method do the job for me with near syncronized movement? Or need to search for another solution?

switch (InandOut) {
      case 0:  // Move to IN position / go to case 1
        InandOut = 1;
        inOutSpeed = 500;
        // Place the IN position into the Array
        gotoposition[0] = SInPoint[ActualInOut];
        gotoposition[1] = PInPoint[ActualInOut];
        gotoposition[2] = TInPoint[ActualInOut];
        slide_stepper->setSpeedInHz(inOutSpeed);
        pan_stepper->setSpeedInHz(inOutSpeed);
        tilt_stepper->setSpeedInHz(inOutSpeed);
        slide_stepper->moveTo(gotoposition[0]);
        pan_stepper->moveTo(gotoposition[1]);
        tilt_stepper->moveTo(gotoposition[2]);
        delay(500);
        break;

      case 1:  // Move to OUT position / go back to case 0
        InandOut = 0;
        inOutSpeed = 500;
        // Place the OUT position into the Array
        gotoposition[0] = SOutPoint[ActualInOut];
        gotoposition[1] = POutPoint[ActualInOut];
        gotoposition[2] = TOutPoint[ActualInOut];
        slide_stepper->setSpeedInHz(inOutSpeed);
        pan_stepper->setSpeedInHz(inOutSpeed);
        tilt_stepper->setSpeedInHz(inOutSpeed);
        slide_stepper->moveTo(gotoposition[0]);
        pan_stepper->moveTo(gotoposition[1]);
        tilt_stepper->moveTo(gotoposition[2]);
        delay(500);
        break;
    }

Previously i used Steppercontrol with accelstepper library for this, but i moved to your library and try to figure out how to move synced the three motors.

Thank you if you can show me the right way to do this!

[gin66]

Hello Freeejack,

just have seen your message.

If you like to use the convenience of acceleration/deceleration controlled by FastAccelStepper, then the high level interface of your solution is appropriate. But those moves are only synchronized by time.

If you would dive into the low level interface, then you can achieve synchronous
operation. In general I would not recommend to go that route for only go between two positions.

From your provided solution, I do see two possible improvements:

• put the three moveTo() within a critical code section with interrupts or task switch forbidden (this depends on your uC). Rationale: all steppers are controlled by a 4ms task. If this control interrupt/task is invoked between first and third moveTo, there is a 4ms delay between the stepper starts. Most likely not relevant in your application
• If the expectation is to have same stop time of the three motors too, then your code may need to adjust the max speed of the two steppers with less time to travel. This involves a bit of calculation and may get complicated, if the steppers do not reach the max. speed.

Hope this helps

[gin66]

Maybe this project (https://youtu.be/7TkybpSQULk) gives ideas for coordinated movement, too.

[Freeejack]

Thank you very very much for this info!
I don't want low level control, this project is a DIY work, all by me, so i want only simple things in the first place.

I can control the PTS mechanism with a RC transmitter, the signal from the radio receiver goes to the ESP32 dev board input and the ESP32 controls the three TMC2209 stepper drivers.
So this is it.

The motor control works better than i expected. Your library is a miracle compared my first try with an UNO and accelstepper lib.

I try to figure out the linked code to use parts of it in my project, only hard thing is the variables without any comment I don't quite understand all of them. I'm just an enthusiastic amateur, not a professional programmer. :-)

In the previous weeks, my newborn daughter was my main occupation. Unfortunately, I fell out of practice a bit and I have to get back into programming. I think my for my own part, it would be enough if the three stepper motors moved nicely together all the way between points A-B.

[Freeejack]

I have a strange situation and after a day of debugging doesn't find the cause of it.
I',m using three TMC2209 with fastaccelstepper library on ESP32. Now everything works, except i have a strange uncontrolled movement on the axes. I control the steppers with an RC controller, and if i have stop moving the input joysticks the steppers stopping and after a while the motors make movements (few random steps) back and forth. So not stopping the last position.
My uart is working because if i set the current or microsteps on the TMC2209s i see the result, but this error ruins everything for me.

I commented out the wifi and most of the code, but doesnt find the root of this.
Now i have a "test" code, with only needed parts, and the errors remain, tried vTask that suggested another forum, but the error remains.

Can you please help me with this situation?
Any help would be great.

Thank you very very much if you have some time to help me.

#include "FastAccelStepper.h"
#include <TMCStepper.h>
#include <HardwareSerial.h>

#define SLIDE_MOTOR_STEP_PIN 26
#define SLIDE_MOTOR_DIRECTION_PIN 27
#define PAN_MOTOR_STEP_PIN 22
#define PAN_MOTOR_DIRECTION_PIN 23
#define TILT_MOTOR_STEP_PIN 19
#define TILT_MOTOR_DIRECTION_PIN 21

#define SLIDE_MAX_SPEED 700
#define SLIDE_MAX_ACCELERATION 8000
#define PAN_MAX_SPEED 500
#define PAN_MAX_ACCELERATION 8000
#define TILT_MAX_SPEED 250
#define TILT_MAX_ACCELERATION 8000

#define RXD2 16
#define TXD2 17

#define SERIAL_PORT_2 Serial2  // TMC2208/TMC2224 HardwareSerial port - pins 16 & 17
#define DRIVER_S_ADDRESS 0b00  // TMC2209 Driver address according to MS1 and MS2
#define DRIVER_P_ADDRESS 0b01  // TMC2209 Driver address according to MS1 and MS2
#define DRIVER_T_ADDRESS 0b10  // TMC2209 Driver address according to MS1 and MS2
#define R_SENSE 0.11f          // E_SENSE for current calc, SilentStepStick series use 0.11

FastAccelStepperEngine engine = FastAccelStepperEngine();
FastAccelStepper *slide_stepper = NULL;
FastAccelStepper *pan_stepper = NULL;
FastAccelStepper *tilt_stepper = NULL;

TMC2209Stepper driver_s(&SERIAL_PORT_2, R_SENSE, DRIVER_S_ADDRESS);  // Create TMC driver
TMC2209Stepper driver_p(&SERIAL_PORT_2, R_SENSE, DRIVER_P_ADDRESS);  // Create TMC driver
TMC2209Stepper driver_t(&SERIAL_PORT_2, R_SENSE, DRIVER_T_ADDRESS);  // Create TMC driver

// RC Channel order and functions //
// CH1 Stepper 1 Axle S Slide (Only negative positions enabled, the ZERO is the limitswitch)
// CH2 Stepper 2 Axle P Pan
// CH3 Stepper 3 Axle T Tilt
// CH4 Speed Control for AutoMOve
// CH5 Set IN/OUT position if CH8 ENABLED, the In/Out block is selected in CH7 (1,2,3)
// CH6 Start / Stop / ReSet AUTO MOve according to CH7 setting (1,2,3), 3 sec long push resets all axles to ZERO
// CH7 Set IN/OUT SET (1,2,3)
// CH8 UP In/Out setting ENABLED, center nothing, LOW Move to In or OUT, selected by CH5 - CH8
// CH9 Reset board

//TMC2209 variables
int current = 1000;
int stall = 255;
int motor_microsteps = 4;
int motor_steps_per_rev = 200;

int SMS;  //Slide Stepper speed from pwm[0]
int PMS;  //Pan Stepper speed from pwm[1]
int TMS;  //Tilt Stepper speed from pwm[2]

//PWM values array
int pwm[9];

//remote control status
bool failSafe = true;
SumdRx *sumdDecoder;

TaskHandle_t Motor;
TaskHandle_t Speed;
TaskHandle_t Rcinput;

void setup() {

  pinMode(SLIDE_MOTOR_DIRECTION_PIN, OUTPUT);
  pinMode(SLIDE_MOTOR_STEP_PIN, OUTPUT);
  pinMode(PAN_MOTOR_DIRECTION_PIN, OUTPUT);
  pinMode(PAN_MOTOR_STEP_PIN, OUTPUT);
  pinMode(TILT_MOTOR_DIRECTION_PIN, OUTPUT);
  pinMode(TILT_MOTOR_STEP_PIN, OUTPUT);

  // // INTITIALIZE SERIAL0 ITERFACE
  // Serial.begin(115200);
  // delay(500);
  // Serial.println(F("---------------------------------------------------"));
  // Serial.println(F("UART0 serial output interface intitialized @ 115200"));

  Serial1.begin(115200, SERIAL_8N1, 33, -1);

  // INITIALIZE SERIAL2 UART FOR TMC2209
  SERIAL_PORT_2.begin(115200);  // INITIALIZE UART TMC2209, SERIAL_8N1, 16, 17
  Serial.println(F("UART2 interface for TMC2209 intitialized   @ 115200"));
  Serial.println(F("---------------------------------------------------"));

  //Attach SUMD decoder to the serial port
  sumdDecoder = new SumdRx();
  delay(1000);

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_s.begin();
  driver_s.pdn_disable(true);      // Use PDN/UART pin for communication
  driver_s.toff(3);                // [1..15] enable driver_s in software
  driver_s.blank_time(24);         // [16, 24, 36, 54]
  driver_s.I_scale_analog(false);  // Use internal voltage reference
  driver_s.rms_current(current);   // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  driver_s.mstep_reg_select(true);
  driver_s.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  driver_s.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_s.semin(15);                     // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_s.semax(15);                     // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  driver_s.iholddelay(3);                 // 0 - 15 smooth current drop
  driver_s.intpol(true);                  // interpolate to 256 microsteps
  driver_s.SGTHRS(stall);
  driver_s.pwm_autoscale(true);    // Needed for stealthChop
  driver_s.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  driver_s.internal_Rsense(false);
  driver_s.TCOOLTHRS(0);
  driver_s.TPWMTHRS(0);
  //************************************************************************************************************************//

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_p.begin();
  driver_p.pdn_disable(true);      // Use PDN/UART pin for communication
  driver_p.toff(3);                // [1..15] enable driver_p in software
  driver_p.blank_time(24);         // [16, 24, 36, 54]
  driver_p.I_scale_analog(false);  // Use internal voltage reference
  driver_p.rms_current(current);   // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  driver_p.mstep_reg_select(true);
  driver_p.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  driver_p.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_p.semin(15);                     // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_p.semax(15);                     // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  driver_p.iholddelay(3);                 // 0 - 15 smooth current drop
  driver_p.intpol(true);                  // interpolate to 256 microsteps
  driver_p.SGTHRS(stall);
  driver_p.pwm_autoscale(true);    // Needed for stealthChop
  driver_p.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  driver_p.internal_Rsense(false);
  driver_p.TCOOLTHRS(0);
  driver_p.TPWMTHRS(0);
  //************************************************************************************************************************//

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_t.begin();
  driver_t.pdn_disable(true);      // Use PDN/UART pin for communication
  driver_t.toff(3);                // [1..15] enable driver_t in software
  driver_t.blank_time(24);         // [16, 24, 36, 54]
  driver_t.I_scale_analog(false);  // Use internal voltage reference
  driver_t.rms_current(current);   // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  driver_t.mstep_reg_select(true);
  driver_t.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  driver_t.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_t.semin(15);                     // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_t.semax(15);                     // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  driver_t.iholddelay(3);                 // 0 - 15 smooth current drop
  driver_t.intpol(true);                  // interpolate to 256 microsteps
  driver_t.SGTHRS(stall);
  driver_t.pwm_autoscale(true);    // Needed for stealthChop
  driver_t.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  driver_t.internal_Rsense(false);
  driver_t.TCOOLTHRS(0);
  driver_t.TPWMTHRS(0);
  //************************************************************************************************************************//

  engine.init();
  pan_stepper = engine.stepperConnectToPin(PAN_MOTOR_STEP_PIN);
  tilt_stepper = engine.stepperConnectToPin(TILT_MOTOR_STEP_PIN);
  slide_stepper = engine.stepperConnectToPin(SLIDE_MOTOR_STEP_PIN);
  if (pan_stepper) {
    pan_stepper->setDirectionPin(PAN_MOTOR_DIRECTION_PIN);
    pan_stepper->setAutoEnable(true);

    pan_stepper->setSpeedInHz(0);                        // steps/s
    pan_stepper->setAcceleration(PAN_MAX_ACCELERATION);  // steps/s²
  }

  if (tilt_stepper) {
    tilt_stepper->setDirectionPin(TILT_MOTOR_DIRECTION_PIN);
    tilt_stepper->setAutoEnable(true);

    tilt_stepper->setSpeedInHz(0);                         // steps/s
    tilt_stepper->setAcceleration(TILT_MAX_ACCELERATION);  // steps/s²
  }
  if (slide_stepper) {
    slide_stepper->setDirectionPin(SLIDE_MOTOR_DIRECTION_PIN);
    slide_stepper->setAutoEnable(true);

    slide_stepper->setSpeedInHz(0);                          // steps/s
    slide_stepper->setAcceleration(SLIDE_MAX_ACCELERATION);  // steps/s²
  }

  pan_stepper->setCurrentPosition(0);
  tilt_stepper->setCurrentPosition(0);
  slide_stepper->setCurrentPosition(0);

  xTaskCreatePinnedToCore(MotorTask, "Motor", 5000, NULL, 5, &Motor, 0);
  xTaskCreatePinnedToCore(SpeedTask, "Speed", 5000, NULL, 3, &Speed, 1);
  xTaskCreatePinnedToCore(InputTask, "Rcinput", 5000, NULL, 2, &Rcinput, 1);
}

void loop() {
  vTaskDelete(NULL);
}

//CHECK FOR SERIAL INPUT---------------------------------------
void InputTask(void *) {

  for (;;) {
    GetData();                         //read SUMD from Serial RX
    pwm[0] = sumdDecoder->channel[0];  // Get pwm[0]
    pwm[1] = sumdDecoder->channel[1];
    pwm[2] = sumdDecoder->channel[2];
    vTaskDelay(5);
  }
}

//MOTOR--------------------------------------------------------
void MotorTask(void *) {

  for (;;) {
    CheckCH1();
    CheckCH2();
    //CheckCH3();
    vTaskDelay(1);
  }
}

//SPEED--------------------------------------------------------
void SpeedTask(void *) {

  for (;;) {
    SMS = abs(map(pwm[0], 1000, 2000, -SLIDE_MAX_SPEED, SLIDE_MAX_SPEED));  // MAP speed from PWM
    PMS = abs(map(pwm[1], 1000, 2000, -PAN_MAX_SPEED, PAN_MAX_SPEED));      // Increase speed as moving
    TMS = abs(map(pwm[2], 1000, 2000, -TILT_MAX_SPEED, TILT_MAX_SPEED));    // Increase speed as moving
    vTaskDelay(5);
  }
}

void CheckCH1() {
  if (pwm[0] > 1510) {
    if (slide_stepper->getCurrentPosition() >= -200) {
      slide_stepper->stopMove();
    } else {
      slide_stepper->setSpeedInHz(SMS);
      slide_stepper->moveTo(-200);
    }
  } else if (pwm[0] < 1490) {
    if (slide_stepper->getCurrentPosition() <= -5000) {
      slide_stepper->stopMove();
    } else {
      slide_stepper->setSpeedInHz(SMS);
      slide_stepper->moveTo(-5000);
    }
  } else {
    slide_stepper->stopMove();
  }
}

void CheckCH2() {
  if (pwm[1] > 1520) {
    if (pan_stepper->getCurrentPosition() >= 200) {
      pan_stepper->stopMove();
    } else {
      pan_stepper->setSpeedInHz(PMS);
      pan_stepper->moveTo(200);
    }
  } else if (pwm[1] < 1480) {
    if (pan_stepper->getCurrentPosition() <= -200) {
      pan_stepper->stopMove();
    } else {
      pan_stepper->setSpeedInHz(PMS);
      pan_stepper->moveTo(-200);
    }
  } else {
    pan_stepper->stopMove();
  }
}

void CheckCH3() {
  if (pwm[2] > 1520) {
    if (tilt_stepper->getCurrentPosition() >= 200) {
      tilt_stepper->stopMove();
    } else {
      tilt_stepper->setSpeedInHz(TMS);
      tilt_stepper->moveTo(200);
    }
  } else if (pwm[2] < 1480) {
    if (tilt_stepper->getCurrentPosition() <= -200) {
      tilt_stepper->stopMove();
    } else {
      tilt_stepper->setSpeedInHz(TMS);
      tilt_stepper->moveTo(-200);
    }
  } else {
    tilt_stepper->stopMove();
  }
}

void GetData() {
  uint8_t index;
  //process sumd input, due to lead time from previous decoding, buffer may overflow and being corrupted -> reset
  sumdDecoder->reset();
  while (Serial1.available() > 0) sumdDecoder->add(Serial1.read());

  //display failsafe status on console
  if (failSafe && !sumdDecoder->failSafe()) {
    failSafe = false;
    //println("Reception OK");
  } else if (!failSafe && sumdDecoder->failSafe()) {
    failSafe = true;
    //println("Reception Lost");
  }
  //  if (!sumdDecoder->failSafe()) {
  //    for (index = 0; index < sumdDecoder->channelRx; index++) { //display channel status
  //      print(sumdDecoder->channel[index]);
  //      print(" ");
  //    }
  //    println();
  //  }
  delay(25);
}```

[Freeejack]

Thanks again!

My late night test results today (unfortunately, I don't have much time these days, but I think I tried everything you suggested in a row, the third of them brought the strangest result, which made me think.)

• disconnected and grounded the step pins from the esp32 to TMC drivers one after another -> nothing happens, random moves with the linked test code.
• disconnected one TMCs motor power from the power supply, (the another two TMC drivers are connected!) and with all wires (STEP, DIR, UART, Logic Power (3,3V)) connected -> few very small moves for 1-2 secs at the start then stop and stable motors
• disconnected one TMCs logic power from the power supply (the another two TMC drivers are connected!) and with all wires (STEP, DIR, UART, Logic Power (3,3V)) connected -> no movement at all on any axis, the motors hold their position, and if I want to move the axes, the motors hold their position firmly.

For the last two tests, it doesn't matter which stepper motor I switch off the motor's power supply or the logic supply voltage. The situation is the same! They react exactly the same!

The ESP32 is powered from a 5V supply, if this matter, the 5V voltage comes to the ESP32 from the power supply, then all the power is output from the ESP32, the 3.3V is also to all the TMC2209.
If I understand correctly, the ESP32 sends out a 3.3V signal on the output pins and for UART communication the voltage must be the same as the logic supply voltage of the TMC2209, so I use 3.3V for this purpose. I read this somewhere when I was looking for the correct wiring and setup between ESP32 -> TMC2209.

In short, as I see the situation, two controllers work flawlessly, but three do not. It's incomprehensible to me for now. Of course, I should also do a test by using the radio remote control to see if it's perfect with the control or not, I'll try to arrange that tomorrow as well!

#include <HardwareSerial.h>

// #define SLIDE_MOTOR_STEP_PIN 26
// #define SLIDE_MOTOR_DIRECTION_PIN 27
// #define PAN_MOTOR_STEP_PIN 22
// #define PAN_MOTOR_DIRECTION_PIN 23
// #define TILT_MOTOR_STEP_PIN 19
// #define TILT_MOTOR_DIRECTION_PIN 21

#define SLIDE_MAX_SPEED 700
#define SLIDE_MAX_ACCELERATION 8000
#define PAN_MAX_SPEED 500
#define PAN_MAX_ACCELERATION 8000
#define TILT_MAX_SPEED 250
#define TILT_MAX_ACCELERATION 8000

#define RXD2 16
#define TXD2 17

#define SERIAL_PORT_2 Serial2  // TMC2208/TMC2224 HardwareSerial port - pins 16 & 17
#define DRIVER_S_ADDRESS 0b00  // TMC2209 Driver address according to MS1 and MS2
#define DRIVER_P_ADDRESS 0b01  // TMC2209 Driver address according to MS1 and MS2
#define DRIVER_T_ADDRESS 0b10  // TMC2209 Driver address according to MS1 and MS2
#define R_SENSE 0.11f          // E_SENSE for current calc, SilentStepStick series use 0.11

TMC2209Stepper driver_s(&SERIAL_PORT_2, R_SENSE, DRIVER_S_ADDRESS);  // Create TMC driver
TMC2209Stepper driver_p(&SERIAL_PORT_2, R_SENSE, DRIVER_P_ADDRESS);  // Create TMC driver
TMC2209Stepper driver_t(&SERIAL_PORT_2, R_SENSE, DRIVER_T_ADDRESS);  // Create TMC driver

// RC Channel order and functions //
// CH1 Stepper 1 Axle S Slide (Only negative positions enabled, the ZERO is the limitswitch)
// CH2 Stepper 2 Axle P Pan
// CH3 Stepper 3 Axle T Tilt
// CH4 Speed Control for AutoMOve
// CH5 Set IN/OUT position if CH8 ENABLED, the In/Out block is selected in CH7 (1,2,3)
// CH6 Start / Stop / ReSet AUTO MOve according to CH7 setting (1,2,3), 3 sec long push resets all axles to ZERO
// CH7 Set IN/OUT SET (1,2,3)
// CH8 UP In/Out setting ENABLED, center nothing, LOW Move to In or OUT, selected by CH5 - CH8
// CH9 Reset board

//TMC2209 variables
int current = 1000;
int stall = 255;
int motor_microsteps = 4;
int motor_steps_per_rev = 200;

void setup() {

  // pinMode(SLIDE_MOTOR_DIRECTION_PIN, OUTPUT);
  // pinMode(SLIDE_MOTOR_STEP_PIN, OUTPUT);
  // pinMode(PAN_MOTOR_DIRECTION_PIN, OUTPUT);
  // pinMode(PAN_MOTOR_STEP_PIN, OUTPUT);
  // pinMode(TILT_MOTOR_DIRECTION_PIN, OUTPUT);
  // pinMode(TILT_MOTOR_STEP_PIN, OUTPUT);

  Serial1.begin(115200, SERIAL_8N1, 33, -1);

  // INITIALIZE SERIAL2 UART FOR TMC2209
  SERIAL_PORT_2.begin(115200);  // INITIALIZE UART TMC2209, SERIAL_8N1, 16, 17
  Serial.println(F("UART2 interface for TMC2209 intitialized   @ 115200"));
  Serial.println(F("---------------------------------------------------"));

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_s.begin();
  driver_s.pdn_disable(true);      // Use PDN/UART pin for communication
  driver_s.toff(3);                // [1..15] enable driver_s in software
  driver_s.blank_time(24);         // [16, 24, 36, 54]
  driver_s.I_scale_analog(false);  // Use internal voltage reference
  driver_s.rms_current(current);   // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  driver_s.mstep_reg_select(true);
  driver_s.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  driver_s.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_s.semin(15);                     // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_s.semax(15);                     // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  driver_s.iholddelay(3);                 // 0 - 15 smooth current drop
  driver_s.intpol(true);                  // interpolate to 256 microsteps
  driver_s.SGTHRS(stall);
  driver_s.pwm_autoscale(true);    // Needed for stealthChop
  driver_s.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  driver_s.internal_Rsense(false);
  driver_s.TCOOLTHRS(0);
  driver_s.TPWMTHRS(0);
  //************************************************************************************************************************//

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_p.begin();
  driver_p.pdn_disable(true);      // Use PDN/UART pin for communication
  driver_p.toff(3);                // [1..15] enable driver_p in software
  driver_p.blank_time(24);         // [16, 24, 36, 54]
  driver_p.I_scale_analog(false);  // Use internal voltage reference
  driver_p.rms_current(current);   // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  driver_p.mstep_reg_select(true);
  driver_p.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  driver_p.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_p.semin(15);                     // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_p.semax(15);                     // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  driver_p.iholddelay(3);                 // 0 - 15 smooth current drop
  driver_p.intpol(true);                  // interpolate to 256 microsteps
  driver_p.SGTHRS(stall);
  driver_p.pwm_autoscale(true);    // Needed for stealthChop
  driver_p.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  driver_p.internal_Rsense(false);
  driver_p.TCOOLTHRS(0);
  driver_p.TPWMTHRS(0);
  //************************************************************************************************************************//

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_t.begin();
  driver_t.pdn_disable(true);      // Use PDN/UART pin for communication
  driver_t.toff(3);                // [1..15] enable driver_t in software
  driver_t.blank_time(24);         // [16, 24, 36, 54]
  driver_t.I_scale_analog(false);  // Use internal voltage reference
  driver_t.rms_current(current);   // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  driver_t.mstep_reg_select(true);
  driver_t.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  driver_t.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_t.semin(15);                     // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_t.semax(15);                     // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  driver_t.iholddelay(3);                 // 0 - 15 smooth current drop
  driver_t.intpol(true);                  // interpolate to 256 microsteps
  driver_t.SGTHRS(stall);
  driver_t.pwm_autoscale(true);    // Needed for stealthChop
  driver_t.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  driver_t.internal_Rsense(false);
  driver_t.TCOOLTHRS(0);
  driver_t.TPWMTHRS(0);
  //************************************************************************************************************************//

}

void loop() {
  vTaskDelete(NULL);
}

[gin66]

So you power the three TMC2209 from the esp32 board ? Perhaps the current draw or current spikes of three TMC2209 is just too much for the esp32 board's 3.3V regulator.

[Freeejack]

This is my last test code and the results:

• removed the STEP/DIR/ENABLE wires from the TMCs -> no movement
• added the STEP/DIR/ENABLE wire to one TMC -> no movement
• added the STEP/DIR/ENABLE wire to two TMCs -> no movement
• added three STEP/DIR/ENABLE wire to three TMCs -> random weird moves on all axes

So you think i need to send the logic voltage from an external power source not from the esp32? This is the last thing i didn't tried.
The three TMCs motor power is connected in serial if this matter.

I try to add a schematic, it's bot the best but if it helps you see everything on it

#include <TMCStepper.h>
#include <HardwareSerial.h>

#define SLIDE_MOTOR_STEP_PIN 26
#define SLIDE_MOTOR_DIRECTION_PIN 27
#define PAN_MOTOR_STEP_PIN 22
#define PAN_MOTOR_DIRECTION_PIN 23
#define TILT_MOTOR_STEP_PIN 19
#define TILT_MOTOR_DIRECTION_PIN 21

#define SLIDE_MAX_SPEED 700
#define SLIDE_MAX_ACCELERATION 8000
#define PAN_MAX_SPEED 500
#define PAN_MAX_ACCELERATION 8000
#define TILT_MAX_SPEED 250
#define TILT_MAX_ACCELERATION 8000

#define RXD2 16
#define TXD2 17

#define SERIAL_PORT_2 Serial2  // TMC2208/TMC2224 HardwareSerial port - pins 16 & 17
#define DRIVER_S_ADDRESS 0b00  // TMC2209 Driver address according to MS1 and MS2
#define DRIVER_P_ADDRESS 0b01  // TMC2209 Driver address according to MS1 and MS2
#define DRIVER_T_ADDRESS 0b10  // TMC2209 Driver address according to MS1 and MS2
#define R_SENSE 0.11f          // E_SENSE for current calc, SilentStepStick series use 0.11

TMC2209Stepper driver_s(&SERIAL_PORT_2, R_SENSE, DRIVER_S_ADDRESS);  // Create TMC driver
TMC2209Stepper driver_p(&SERIAL_PORT_2, R_SENSE, DRIVER_P_ADDRESS);  // Create TMC driver
TMC2209Stepper driver_t(&SERIAL_PORT_2, R_SENSE, DRIVER_T_ADDRESS);  // Create TMC driver

// RC Channel order and functions //
// CH1 Stepper 1 Axle S Slide (Only negative positions enabled, the ZERO is the limitswitch)
// CH2 Stepper 2 Axle P Pan
// CH3 Stepper 3 Axle T Tilt
// CH4 Speed Control for AutoMOve
// CH5 Set IN/OUT position if CH8 ENABLED, the In/Out block is selected in CH7 (1,2,3)
// CH6 Start / Stop / ReSet AUTO MOve according to CH7 setting (1,2,3), 3 sec long push resets all axles to ZERO
// CH7 Set IN/OUT SET (1,2,3)
// CH8 UP In/Out setting ENABLED, center nothing, LOW Move to In or OUT, selected by CH5 - CH8
// CH9 Reset board

//TMC2209 variables
int current = 1000;
int stall = 255;
int motor_microsteps = 4;
int motor_steps_per_rev = 200;

void setup() {

  pinMode(SLIDE_MOTOR_DIRECTION_PIN, OUTPUT);
  pinMode(SLIDE_MOTOR_STEP_PIN, OUTPUT);
  pinMode(PAN_MOTOR_DIRECTION_PIN, OUTPUT);
  pinMode(PAN_MOTOR_STEP_PIN, OUTPUT);
  pinMode(TILT_MOTOR_DIRECTION_PIN, OUTPUT);
  pinMode(TILT_MOTOR_STEP_PIN, OUTPUT);

  Serial1.begin(115200, SERIAL_8N1, 33, -1);

  // INITIALIZE SERIAL2 UART FOR TMC2209
  SERIAL_PORT_2.begin(115200);  // INITIALIZE UART TMC2209, SERIAL_8N1, 16, 17
  Serial.println(F("UART2 interface for TMC2209 intitialized   @ 115200"));
  Serial.println(F("---------------------------------------------------"));

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_s.begin();
  driver_s.pdn_disable(true);      // Use PDN/UART pin for communication
  driver_s.toff(3);                // [1..15] enable driver_s in software
  driver_s.blank_time(24);         // [16, 24, 36, 54]
  driver_s.I_scale_analog(false);  // Use internal voltage reference
  driver_s.rms_current(current);   // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  driver_s.mstep_reg_select(true);
  driver_s.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  driver_s.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_s.semin(15);                     // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_s.semax(15);                     // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  driver_s.iholddelay(3);                 // 0 - 15 smooth current drop
  driver_s.intpol(true);                  // interpolate to 256 microsteps
  driver_s.SGTHRS(stall);
  driver_s.pwm_autoscale(true);    // Needed for stealthChop
  driver_s.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  driver_s.internal_Rsense(false);
  driver_s.TCOOLTHRS(0);
  driver_s.TPWMTHRS(0);
  //************************************************************************************************************************//

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_p.begin();
  driver_p.pdn_disable(true);      // Use PDN/UART pin for communication
  driver_p.toff(3);                // [1..15] enable driver_p in software
  driver_p.blank_time(24);         // [16, 24, 36, 54]
  driver_p.I_scale_analog(false);  // Use internal voltage reference
  driver_p.rms_current(current);   // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  driver_p.mstep_reg_select(true);
  driver_p.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  driver_p.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_p.semin(15);                     // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_p.semax(15);                     // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  driver_p.iholddelay(3);                 // 0 - 15 smooth current drop
  driver_p.intpol(true);                  // interpolate to 256 microsteps
  driver_p.SGTHRS(stall);
  driver_p.pwm_autoscale(true);    // Needed for stealthChop
  driver_p.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  driver_p.internal_Rsense(false);
  driver_p.TCOOLTHRS(0);
  driver_p.TPWMTHRS(0);
  //************************************************************************************************************************//

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_t.begin();
  driver_t.pdn_disable(true);      // Use PDN/UART pin for communication
  driver_t.toff(3);                // [1..15] enable driver_t in software
  driver_t.blank_time(24);         // [16, 24, 36, 54]
  driver_t.I_scale_analog(false);  // Use internal voltage reference
  driver_t.rms_current(current);   // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  driver_t.mstep_reg_select(true);
  driver_t.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  driver_t.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_t.semin(15);                     // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_t.semax(15);                     // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  driver_t.iholddelay(3);                 // 0 - 15 smooth current drop
  driver_t.intpol(true);                  // interpolate to 256 microsteps
  driver_t.SGTHRS(stall);
  driver_t.pwm_autoscale(true);    // Needed for stealthChop
  driver_t.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  driver_t.internal_Rsense(false);
  driver_t.TCOOLTHRS(0);
  driver_t.TPWMTHRS(0);
  //************************************************************************************************************************//

}

void loop() {
  vTaskDelete(NULL);
}

[gin66]

Thanks for sharing. The GNC connections are interesting, but could be ok as you are using modules and not ICs.
Still I find it surprising, that the 28V GND has no connection to your logic GND. But again, the TMC2209 module may include that connection, which is not obvious from the circuit diagram.

Reading the data sheet, the TMC2209 can be supplied by 5V, too. So you could connect it to the 5V power supply of the esp32. In addition a capacitor at the TMC2209 power inputs could help. Please check (https://learn.watterott.com/silentstepstick/pinconfig/)

[Freeejack]

UPDATE: You are the MAN!

I think you pointed the real error of my design!
For a last resort i tried to connect the motor GND to my TMC adapter board's logic GND for every motor. And the result is really good!!! The error is almost gone!
I need to make correct cable for this and test. I have now only a few loose dupont connectors laying here, but the erratic movements is very very rare now! I hope this was the root of the problem... 😊

Only problem is still here that the center position is a little shifted on my pan axis. I move it back and forth and after a few movements it's shift a little. But before i search for the root of this i need to make a good GND wire connection to every TMC board! I have switched on the system like five minutes and the motors stand still, with RC switched on, WIFI switched on etc. So i am grateful for this idea you gave me today!!!

I think maybe the boards damaged when i upload the code. Plug USB to esp32 upload the code disconnect then test. But... if i upload i don't switch on the motor power. And if i understand good that you have linked the tmc need the motor power or it will be damaged...

Strange that if i use my whole code with wifi and everything the motors only moves a very little and the program is usable motors working etc. so if i see this the boards are working and dot damaged.

Before my TMC story began i tried my another motor controllers with the esp32 that accepts 5V logic input but that doesn't worked because the esp32 only sends out 3V on the gpios. This is why i moved to the TMCs and my whole design started from scratch...

[Freeejack]

Hi @gin66!

Imagine, after several weeks of reading and testing, I managed to find out what the problem was. The error was in the TMC settings. It looks like it's working now. Today I tested live for about two hours and the results are encouraging. I still have a few minor problems, these are likely programming errors. I will try to find out their reasons.

1. when I try to set a low speed for the automatic movement, the movement jumps rather than runs smoothly. If I increase the speed a bit, it's perfect and smooth. (As I guess it could be a bug within the program, but I was too tired to figure it out yet)

2. And the other is that if I bring everything to the middle position, and then the motors move back and forth with automatic movement a couple of times, then when I go back to the starting zero position, it is located in a completely different place. (I think this is also a fault of my program, but if you have an idea, I would be happy to receive it)

3. I noticed that, since the set and real stepper speed can now be followed on the screen, the real one is not even close to the set one. I think this could be remedied by increasing the acceleration value.

If you don't mind, I'll attach my current code, just in case you spot something in it that is very bad and I haven't noticed so far.
90% flawless and manageable and runs wonderfully, slows down, accelerates, etc...

#include "src/FastAccelStepper.h"
#include <TMCStepper.h>
#include <HardwareSerial.h>

#include <WiFi.h>
#include <WebServer.h>
#include <WebSocketsServer.h>
#include <ArduinoSort.h>

#define SLIDE_MOTOR_STEP_PIN 26
#define SLIDE_MOTOR_DIRECTION_PIN 27
#define PAN_MOTOR_STEP_PIN 22
#define PAN_MOTOR_DIRECTION_PIN 23
#define TILT_MOTOR_STEP_PIN 19
#define TILT_MOTOR_DIRECTION_PIN 21

#define SLIDE_MAX_SPEED 42000
#define SLIDE_MAX_ACCELERATION 10000
#define PAN_MAX_SPEED 15000
#define PAN_MAX_ACCELERATION 10000
#define TILT_MAX_SPEED 7500
#define TILT_MAX_ACCELERATION 10000

#define RXD2 16
#define TXD2 17

#define SERIAL_PORT_2 Serial2  // TMC2208/TMC2224 HardwareSerial port - pins 16 & 17
#define DRIVER_S_ADDRESS 0b00  // TMC2209 Driver address according to MS1 and MS2
#define DRIVER_P_ADDRESS 0b01  // TMC2209 Driver address according to MS1 and MS2
#define DRIVER_T_ADDRESS 0b10  // TMC2209 Driver address according to MS1 and MS2
#define R_SENSE 0.11f          // E_SENSE for current calc, SilentStepStick series use 0.11

TMC2209Stepper driver_s(&SERIAL_PORT_2, R_SENSE, DRIVER_S_ADDRESS);  // Create TMC driver
TMC2209Stepper driver_p(&SERIAL_PORT_2, R_SENSE, DRIVER_P_ADDRESS);  // Create TMC driver
TMC2209Stepper driver_t(&SERIAL_PORT_2, R_SENSE, DRIVER_T_ADDRESS);  // Create TMC driver

FastAccelStepperEngine engine = FastAccelStepperEngine();
FastAccelStepper *slide_stepper = NULL;
FastAccelStepper *pan_stepper = NULL;
FastAccelStepper *tilt_stepper = NULL;

// //*Web things***********************************//
//-----------------------------------------------
const char *ssid = "ESP32Slider";       // Your WiFi AP SSID
const char *password = "testpassword";  // Your WiFi Password
//-----------------------------------------------
WebServer server(80);
WebSocketsServer webSocket = WebSocketsServer(81);
String JSONtxt;
//-----------------------------------------------
#include "webpage.h"
#include "src/functions.h"
// //**********************************************//

const int ReedSensor = 35;  //REED switch port
int ReedState;              // 0 close - 1 open switch

// RC Channel order and functions //
// CH1 Stepper 1 Axle S Slide (Only negative positions enabled, the ZERO is the limitswitch)
// CH2 Stepper 2 Axle P Pan
// CH3 Stepper 3 Axle T Tilt
// CH4 Speed Control for AutoMOve
// CH5 Set IN/OUT position if CH8 ENABLED, the In/Out block is selected in CH7 (1,2,3)
// CH6 Start / Stop / ReSet AUTO MOve according to CH7 setting (1,2,3), 3 sec long push resets all axles to ZERO
// CH7 Set IN/OUT SET (1,2,3)
// CH8 UP In/Out setting ENABLED, center nothing, LOW Move to In or OUT, selected by CH5 - CH8
// CH9 Reset board

//TMC2209 variables
int current = 1000;
int stall = 255;
int motor_microsteps = 64;
int motor_steps_per_rev = 200;
int msread;
int mpread;
int mtread;

//Position variables
int ActualInOut = 1;
int InandOut = 0;  //IN-OUT points active or not
boolean SetInOut = false;
long SInPoint[4];          //Slide IN
long PInPoint[4];          //Pan IN
long TInPoint[4];          //Tilt IN
long SOutPoint[4];         //Slide OUT
long POutPoint[4];         //Pan OUT
long TOutPoint[4];         //Tilt OUT
boolean InSet[4];          //IN point is stored
boolean OutSet[4];         //OUT point is stored
boolean automove = false;  //automove is ACTIVE or not
long gotoposition[3];      // An array to store the In or Out position for each stepper motor
long SSteps;               //Slide Stepper actual steps
long PSteps;               //Pan Stepper actual steps
long TSteps;               //Tilt Stepper actual steps
int SMS;                   //Slide Stepper speed from pwm[0]
int PMS;                   //Pan Stepper speed from pwm[1]
int TMS;                   //Tilt Stepper speed from pwm[2]
int SlideSPD;              //Slide Stepper actual speed
int PanSPD;                //Pan Stepper actual speed
int TiltSPD;               //Tilt Stepper actual speed

//*** Speed calculation variables ***
long pan_steps_to_move = 0;
long tilt_steps_to_move = 0;
long slide_steps_to_move = 0;
bool pan_is_moving = true;
bool tilt_is_moving = true;
bool slide_is_moving = true;
long steps_to_move[3] = { 0, 0, 0 };
double pan_time_motion_complete = 0;
double tilt_time_motion_complete = 0;
double slide_time_motion_complete = 0;
int pan_speed_motion_complete = 0;
int tilt_speed_motion_complete = 0;
int slide_speed_motion_complete = 0;
//*** Speed calculation end

//Variables for Homing
long initial_homing = 1;  // Used to Home Stepper at startup

//Speed variables
float inOutSpeed = 0;

//PWM values array
int pwm[9];

//RC read timing variables
unsigned long startMillis;
unsigned long currentMillis;
const unsigned long period = 1000;  //the value is a number of milliseconds

//HardwareSerial SerialPort(1);  // use UART1

//remote control status
bool failSafe = true;
SumdRx *sumdDecoder;

TaskHandle_t Display;
TaskHandle_t Rcinput;
TaskHandle_t Speed;
TaskHandle_t Motor;

void setup() {

  pinMode(SLIDE_MOTOR_DIRECTION_PIN, OUTPUT);
  pinMode(SLIDE_MOTOR_STEP_PIN, OUTPUT);
  pinMode(PAN_MOTOR_DIRECTION_PIN, OUTPUT);
  pinMode(PAN_MOTOR_STEP_PIN, OUTPUT);
  pinMode(TILT_MOTOR_DIRECTION_PIN, OUTPUT);
  pinMode(TILT_MOTOR_STEP_PIN, OUTPUT);

  // INTITIALIZE SERIAL0 ITERFACE
  Serial.begin(115200);
  Serial.println(F("---------------------------------------------------"));
  Serial.println(F("UART0 serial output interface intitialized @ 115200"));

  //*********************************************************************//
  //Server is accessible at 192.168.4.1/webserial URL.
  WiFi.softAP(ssid, password);
  IPAddress IP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(IP);
  server.on("/", handleRoot);
  server.begin();
  webSocket.begin();
  webSocket.onEvent(webSocketEvent);
  //*********************************************************************//

  Serial1.begin(115200, SERIAL_8N1, 33, -1);

  // INITIALIZE SERIAL2 UART FOR TMC2209
  SERIAL_PORT_2.begin(115200);  // INITIALIZE UART TMC2209, SERIAL_8N1, 16, 17
  Serial.println(F("UART2 interface for TMC2209 intitialized   @ 115200"));
  Serial.println(F("---------------------------------------------------"));

  //Attach SUMD decoder to the serial port
  sumdDecoder = new SumdRx();

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_s.pdn_disable(true);  // Use PDN/UART pin for communication
  driver_s.begin();
  driver_s.toff(3);                    // [1..15] enable driver_s in software
  driver_s.blank_time(24);             // [16, 24, 36, 54]
  driver_s.I_scale_analog(true);       // Use internal voltage reference
  driver_s.rms_current(current, 1.0);  // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  //driver_s.mstep_reg_select(true);
  driver_s.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  //driver_s.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_s.semin(0);  // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_s.semax(2);  // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  //driver_s.iholddelay(15);  // 0 - 15 smooth current drop
  //driver_s.intpol(true);    // interpolate to 256 microsteps
  //driver_s.SGTHRS(stall);
  //driver_s.pwm_autoscale(true);    // Needed for stealthChop
  driver_s.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  //driver_s.internal_Rsense(false);
  //driver_s.TCOOLTHRS(0);
  driver_s.TPWMTHRS(0);
  //driver_s.shaft(true);  // Set the shaft direction clockwise.
  //************************************************************************************************************************//

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_p.pdn_disable(true);  // Use PDN/UART pin for communication
  driver_p.begin();
  driver_p.toff(3);                    // [1..15] enable driver_p in software
  driver_p.blank_time(24);             // [16, 24, 36, 54]
  driver_p.I_scale_analog(true);       // Use internal voltage reference
  driver_p.rms_current(current, 1.0);  // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  //driver_p.mstep_reg_select(true);
  driver_p.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  //driver_p.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_p.semin(0);  // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_p.semax(2);  // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  //driver_p.iholddelay(15);  // 0 - 15 smooth current drop
  //driver_p.intpol(true);    // interpolate to 256 microsteps
  //driver_p.SGTHRS(stall);
  driver_p.pwm_autoscale(true);    // Needed for stealthChop
  driver_p.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  //driver_p.internal_Rsense(false);
  //driver_p.TCOOLTHRS(0);
  driver_p.TPWMTHRS(0);
  //driver_p.shaft(true);  // Set the shaft direction clockwise.
  //************************************************************************************************************************//

  //************************************************************************************************************************//
  //TMCSTEPPER SETTINGS
  driver_t.pdn_disable(true);  // Use PDN/UART pin for communication
  driver_t.begin();
  driver_t.toff(3);                    // [1..15] enable driver_t in software
  driver_t.blank_time(24);             // [16, 24, 36, 54]
  driver_t.I_scale_analog(true);       // Use internal voltage reference
  driver_t.rms_current(current, 1.0);  // motor RMS current (mA) "rms_current will by default set ihold to 50% of irun but you can set your own ratio with additional second argument; rms_current(1000, 0.3)."
  //driver_t.mstep_reg_select(true);
  driver_t.microsteps(motor_microsteps);  //note that MicroPlyer will interpolate to 256
  //driver_t.seimin(1);                     // minimum current for smart current control 0: 1/2 of IRUN 1: 1/4 of IRUN
  driver_t.semin(0);  // [0... 15] If the StallGuard4 result falls below SEMIN*32, the motor current becomes increased to reduce motor load angle.
  driver_t.semax(2);  // [0... 15]  If the StallGuard4 result is equal to or above (SEMIN+SEMAX+1)*32, the motor current becomes decreased to save energy.
  //driver_t.iholddelay(15);  // 0 - 15 smooth current drop
  //driver_t.intpol(true);    // interpolate to 256 microsteps
  //driver_t.SGTHRS(stall);
  driver_t.pwm_autoscale(true);    // Needed for stealthChop
  driver_t.en_spreadCycle(false);  // false = StealthChop / true = SpreadCycle, Spreadcycle can have higher RPM but is louder
  //driver_t.internal_Rsense(false);
  //driver_t.TCOOLTHRS(0);
  driver_t.TPWMTHRS(0);
  //driver_t.shaft(true);  // Set the shaft direction clockwise.
  //************************************************************************************************************************//

  delay(5000);

  engine.init(1);
  pan_stepper = engine.stepperConnectToPin(PAN_MOTOR_STEP_PIN);
  tilt_stepper = engine.stepperConnectToPin(TILT_MOTOR_STEP_PIN);
  slide_stepper = engine.stepperConnectToPin(SLIDE_MOTOR_STEP_PIN);
  if (pan_stepper) {
    pan_stepper->setDirectionPin(PAN_MOTOR_DIRECTION_PIN);
    pan_stepper->setAutoEnable(true);

    pan_stepper->setSpeedInHz(0);                        // steps/s
    pan_stepper->setAcceleration(PAN_MAX_ACCELERATION);  // steps/s²
    pan_stepper->applySpeedAcceleration();
  }
  if (tilt_stepper) {
    tilt_stepper->setDirectionPin(TILT_MOTOR_DIRECTION_PIN);
    tilt_stepper->setAutoEnable(true);

    tilt_stepper->setSpeedInHz(0);                         // steps/s
    tilt_stepper->setAcceleration(TILT_MAX_ACCELERATION);  // steps/s²
    tilt_stepper->applySpeedAcceleration();
  }
  if (slide_stepper) {
    slide_stepper->setDirectionPin(SLIDE_MOTOR_DIRECTION_PIN);
    slide_stepper->setAutoEnable(true);

    slide_stepper->setSpeedInHz(0);                          // steps/s
    slide_stepper->setAcceleration(SLIDE_MAX_ACCELERATION);  // steps/s²
    slide_stepper->applySpeedAcceleration();
  }

  for (int i = 0; i < 5; i++) {  //SET all IN and OUT points to zero
    InSet[i] = false;
    OutSet[i] = false;
  }

  //pinMode(ReedSensor, INPUT_PULLUP);
  /*

      // Move the slider to the initial position - homing
      // Start Homing procedure of Stepper Motor at startup
      println("Stepper is Homing . . .");
      ReedState = digitalRead(ReedSensor);
      print("LiMiT SW: ");
      println(ReedState);

      delay(5000);

      while (digitalRead(ReedSensor)) {  // Make the Stepper move CCW until the switch is activated
        stepper1.moveTo(initial_homing); // Set the position to move to
        initial_homing++;                // Decrease by 1 for next move if needed
        stepper1.run();                  // Start moving the stepper
        delay(5);
      }

      stepper1.setCurrentPosition(0);    // Set the current position as zero for now
      stepper1.setMaxSpeed(100.0);       // Set Max Speed of Stepper (Slower to get better accuracy)
      initial_homing = -1;

      ReedState = digitalRead(ReedSensor);
      print("LiMiT SW: ");
      println(ReedState);

      while (!digitalRead(ReedSensor)) { // Make the Stepper move CW until the switch is deactivated
        stepper1.moveTo(-2000);
        stepper1.run();
        initial_homing--;
        delay(5);
      }
    stepper1.setCurrentPosition(0);
    println("Homing Completed");
    println("");
    stepper1.setMaxSpeed(max_speed); // Set Max Speed of Stepper (Slower to get better accuracy)*/
  startMillis = millis();  //initial start time
  pan_stepper->setCurrentPosition(0);
  tilt_stepper->setCurrentPosition(0);
  slide_stepper->setCurrentPosition(0);

  xTaskCreatePinnedToCore(DisplayTask, "Display", 5000, NULL, 1, &Display, 0);
  xTaskCreatePinnedToCore(InputTask, "Rcinput", 5000, NULL, 4, &Rcinput, 0);
  xTaskCreatePinnedToCore(SpeedTask, "Speed", 5000, NULL, 2, &Speed, 0);
  xTaskCreatePinnedToCore(MotorTask, "Motor", 5000, NULL, 5, &Motor, 1);
}

//***********************************************************************
void read_ms() {
  msread = driver_s.microsteps();
  mpread = driver_p.microsteps();
  mtread = driver_t.microsteps();
}
//***********************************************************************

//WiFi task for display---------------------------------------
void DisplayTask(void *) {
  for (;;) {
    webSocket.loop();
    server.handleClient();
    //-----------------------------------------------
    static unsigned long l = 0;
    unsigned long t = millis();
    if ((t - l) > 500) {
      //-----------------------------------------------
      String pwm0valString = String(pwm[0]);
      String pwm1valString = String(pwm[1]);
      String pwm2valString = String(pwm[2]);
      String pwm3valString = String(pwm[3]);
      String pwm4valString = String(pwm[4]);
      String pwm5valString = String(pwm[5]);
      String pwm6valString = String(pwm[6]);
      String pwm7valString = String(pwm[7]);
      String pwm8valString = String(pwm[8]);
      String amString = "N/A";
      if (automove > 0) {
        amString = "Active";
      } else {
        amString = "Inactive";
      }
      String slidespdvalString = String(SMS);
      String panspdvalString = String(PMS);
      String tiltspdvalString = String(TMS);
      String sliderealspdvalString = String(SlideSPD);
      String panrealspdvalString = String(PanSPD);
      String tiltrealspdvalString = String(TiltSPD);
      String slideposvalString = String(slide_stepper->getCurrentPosition());
      String panposvalString = String(pan_stepper->getCurrentPosition());
      String tiltposvalString = String(tilt_stepper->getCurrentPosition());
      String failsafeString = "N/A";
      if (failSafe < 1) {
        failsafeString = "RC OK";
      } else {
        failsafeString = "RC Lost";
      }
      String bankString = String(ActualInOut);
      String sinString = String(SInPoint[ActualInOut]);
      String soutString = String(SOutPoint[ActualInOut]);
      String pinString = String(PInPoint[ActualInOut]);
      String poutString = String(POutPoint[ActualInOut]);
      String tinString = String(TInPoint[ActualInOut]);
      String toutString = String(TOutPoint[ActualInOut]);
      //-----------------------------------------------
      JSONtxt = "{\"pwm0\":\"" + pwm0valString + "\",";
      JSONtxt += "\"pwm1\":\"" + pwm1valString + "\",";
      JSONtxt += "\"pwm2\":\"" + pwm2valString + "\",";
      JSONtxt += "\"pwm3\":\"" + pwm3valString + "\",";
      JSONtxt += "\"pwm4\":\"" + pwm4valString + "\",";
      JSONtxt += "\"pwm5\":\"" + pwm5valString + "\",";
      JSONtxt += "\"pwm6\":\"" + pwm6valString + "\",";
      JSONtxt += "\"pwm7\":\"" + pwm7valString + "\",";
      JSONtxt += "\"pwm8\":\"" + pwm8valString + "\",";
      JSONtxt += "\"automoveactive\":\"" + amString + "\",";
      JSONtxt += "\"slidespd\":\"" + slidespdvalString + "\",";
      JSONtxt += "\"panspd\":\"" + panspdvalString + "\",";
      JSONtxt += "\"tiltspd\":\"" + tiltspdvalString + "\",";
      JSONtxt += "\"sliderealspd\":\"" + sliderealspdvalString + "\",";
      JSONtxt += "\"panrealspd\":\"" + panrealspdvalString + "\",";
      JSONtxt += "\"tiltrealspd\":\"" + tiltrealspdvalString + "\",";
      JSONtxt += "\"slidepos\":\"" + slideposvalString + "\",";
      JSONtxt += "\"panpos\":\"" + panposvalString + "\",";
      JSONtxt += "\"tiltpos\":\"" + tiltposvalString + "\",";
      JSONtxt += "\"failsafe\":\"" + failsafeString + "\",";
      JSONtxt += "\"bank\":\"" + bankString + "\",";
      JSONtxt += "\"sin\":\"" + sinString + "\",";
      JSONtxt += "\"sout\":\"" + soutString + "\",";
      JSONtxt += "\"pin\":\"" + pinString + "\",";
      JSONtxt += "\"pout\":\"" + poutString + "\",";
      JSONtxt += "\"tin\":\"" + tinString + "\",";
      JSONtxt += "\"tout\":\"" + toutString + "\"}";
      webSocket.broadcastTXT(JSONtxt);
    }
    vTaskDelay(50);
  }
}

//CHECK FOR ACTUAL SPEED---------------------------------
void SpeedTask(void *) {

  for (;;) {
    SlideSPD = slide_stepper->getCurrentSpeedInMilliHz() / 1000;
    PanSPD = pan_stepper->getCurrentSpeedInMilliHz() / 1000;
    TiltSPD = tilt_stepper->getCurrentSpeedInMilliHz() / 1000;
    vTaskDelay(1);
  }
}

void loop() {
  if (!failSafe) {
    CheckCH4();
    CheckCH5();
    CheckCH6();
    CheckCH7();
    CheckCH8();
    CheckCH9();
  }
  currentMillis = millis();                   //get the current "time" (actually the number of milliseconds since the program started)
  if (currentMillis - startMillis >= period)  //test whether the period has elapsed
  {
    startMillis = currentMillis;  //IMPORTANT to save the start time
  }
}

//MOTOR--------------------------------------------------------
void MotorTask(void *) {
  for (;;) {
    if (!failSafe) {
      SSteps = slide_stepper->getCurrentPosition();
      PSteps = pan_stepper->getCurrentPosition();
      TSteps = tilt_stepper->getCurrentPosition();

      if (pwm[0] > 1510) {
        slide_is_moving = true;
        SMS = map(pwm[0], 1510, 2000, 0, SLIDE_MAX_SPEED);  // MAP Slide Moving Speed from PWM
        slide_stepper->setSpeedInHz(SMS);
        slide_stepper->moveTo(-200);
      } else if (pwm[0] < 1490) {
        slide_is_moving = true;
        SMS = map(pwm[0], 1490, 1000, 0, SLIDE_MAX_SPEED);  // MAP Slide Moving Speed from PWM
        slide_stepper->setSpeedInHz(SMS);
        slide_stepper->moveTo(-100000);
      } else {
        SMS = 0;
        slide_stepper->setSpeedInHz(SMS);
        slide_stepper->applySpeedAcceleration();
        slide_stepper->stopMove();
        slide_is_moving = false;
      }
      //******************************************************************************************
      if (pwm[1] > 1510) {
        pan_is_moving = true;
        PMS = map(pwm[1], 1510, 2000, 0, PAN_MAX_SPEED);  // MAP Pan Moving Speed from PWM
        pan_stepper->setSpeedInHz(PMS);
        pan_stepper->moveTo(10000);
      } else if (pwm[1] < 1490) {
        pan_is_moving = true;
        PMS = map(pwm[1], 1490, 1000, 0, PAN_MAX_SPEED);  // MAP Pan Moving Speed from PWM
        pan_stepper->setSpeedInHz(PMS);
        pan_stepper->moveTo(-10000);
      } else {
        PMS = 0;
        pan_stepper->setSpeedInHz(PMS);
        pan_stepper->applySpeedAcceleration();
        pan_stepper->stopMove();
        pan_is_moving = false;
      }
      //******************************************************************************************
      if (pwm[2] > 1510) {
        tilt_is_moving = true;
        TMS = map(pwm[2], 1510, 2000, 0, TILT_MAX_SPEED);  // MAP Tilt Moving Speed from PWM
        tilt_stepper->setSpeedInHz(TMS);
        tilt_stepper->moveTo(4000);
      } else if (pwm[2] < 1490) {
        tilt_is_moving = true;
        TMS = map(pwm[2], 1490, 1000, 0, TILT_MAX_SPEED);  // MAP Tilt Moving Speed from PWM
        tilt_stepper->setSpeedInHz(TMS);
        tilt_stepper->moveTo(-4000);
      } else {
        TMS = 0;
        tilt_stepper->setSpeedInHz(TMS);
        tilt_stepper->applySpeedAcceleration();
        tilt_stepper->stopMove();
        tilt_is_moving = false;
      }
    } else {
      pan_stepper->stopMove();
      tilt_stepper->stopMove();
      slide_stepper->stopMove();
    }
    vTaskDelay(1);
  }
}

void CheckCH4() {
  inOutSpeed = map(pwm[3], 1000, 2000, 1, 1000);  // Automove set speed potmeter
}

void CheckCH5() {
  if (pwm[4] < 1490 && SetInOut == true) {                        // Set IN position
    SInPoint[ActualInOut] = slide_stepper->getCurrentPosition();  // Set the IN position for steppers
    PInPoint[ActualInOut] = pan_stepper->getCurrentPosition();
    TInPoint[ActualInOut] = tilt_stepper->getCurrentPosition();
    InSet[ActualInOut] = true;
  } else if (pwm[4] > 1510 && SetInOut == true) {                  // Set OUT position
    SOutPoint[ActualInOut] = slide_stepper->getCurrentPosition();  // Set the OUT Points for steppers
    POutPoint[ActualInOut] = pan_stepper->getCurrentPosition();
    TOutPoint[ActualInOut] = tilt_stepper->getCurrentPosition();
    OutSet[ActualInOut] = true;
    InandOut = 0;
  }
}

void CheckCH6() {
  if (pwm[5] > 1510 && OutSet[ActualInOut] == true) {  //Move the Slide/Pan/Tilt motors to In and Out position
    automove = true;
    pan_stepper->setAcceleration(PAN_MAX_ACCELERATION / 2);  // steps/s²
    pan_stepper->applySpeedAcceleration();
    tilt_stepper->setAcceleration(TILT_MAX_ACCELERATION / 2);  // steps/s²
    tilt_stepper->applySpeedAcceleration();
    slide_stepper->setAcceleration(SLIDE_MAX_ACCELERATION / 2);  // steps/s²
    slide_stepper->applySpeedAcceleration();
    switch (InandOut) {
      case 0:  // Move to IN position / go to case 1
        // Place the IN position into the Array
        gotoposition[0] = SInPoint[ActualInOut];
        gotoposition[1] = PInPoint[ActualInOut];
        gotoposition[2] = TInPoint[ActualInOut];
        CalcMoves();
        if (slide_stepper->getCurrentPosition() != gotoposition[0]) {
          slide_stepper->moveTo(gotoposition[0]);
        }
        if (pan_stepper->getCurrentPosition() != gotoposition[1]) {
          pan_stepper->moveTo(gotoposition[1]);
        }
        if (tilt_stepper->getCurrentPosition() != gotoposition[2]) {
          tilt_stepper->moveTo(gotoposition[2]);
        }
        if (!(pan_stepper->isRunning()) && !(tilt_stepper->isRunning()) && !(slide_stepper->isRunning())) {
          delay(500);
          InandOut = 1;
        }
        break;

      case 1:  // Move to OUT position / go back to case 0
        // Place the OUT position into the Array
        gotoposition[0] = SOutPoint[ActualInOut];
        gotoposition[1] = POutPoint[ActualInOut];
        gotoposition[2] = TOutPoint[ActualInOut];
        CalcMoves();
        if (slide_stepper->getCurrentPosition() != gotoposition[0]) {
          slide_stepper->moveTo(gotoposition[0]);
        }
        if (pan_stepper->getCurrentPosition() != gotoposition[1]) {
          pan_stepper->moveTo(gotoposition[1]);
        }
        if (tilt_stepper->getCurrentPosition() != gotoposition[2]) {
          tilt_stepper->moveTo(gotoposition[2]);
        }
        if (!(pan_stepper->isRunning()) && !(tilt_stepper->isRunning()) && !(slide_stepper->isRunning())) {
          InandOut = 0;
          delay(500);
        }
        break;
    }
  } else if (pwm[5] < 1490 && pwm[7] > 1510) {  // If we hold RC 6 longer then half second, reset the in and out positions
    delay(500);
    if (pwm[5] < 1490) {           //Exit from autoMOve / reset In-Out positions
      SInPoint[ActualInOut] = 0;   //Slide
      PInPoint[ActualInOut] = 0;   //Pan
      TInPoint[ActualInOut] = 0;   //Tilt
      SOutPoint[ActualInOut] = 0;  //Slide
      POutPoint[ActualInOut] = 0;  //Pan
      TOutPoint[ActualInOut] = 0;  //Tilt
      InSet[ActualInOut] = false;
      OutSet[ActualInOut] = false;
    }
    // } else if (pwm[5] < 1490 && pwm[7] < 1490) {  // If we hold RC 6 longer then three second, reset to ZERO point
    //   if (pwm[5] < 1490) {                        //Reset to ZERO all axles
    //     gotoposition[0] = 0;
    //     gotoposition[1] = 0;
    //     gotoposition[2] = 0;
    //     pan_stepper->setSpeedInHz(inOutSpeed);
    //     tilt_stepper->setSpeedInHz(inOutSpeed);
    //     slide_stepper->setSpeedInHz(inOutSpeed);
    //     if (slide_stepper->getCurrentPosition() != gotoposition[0]) {
    //       slide_stepper->moveTo(gotoposition[0], true);
    //     }
    //     if (pan_stepper->getCurrentPosition() != gotoposition[1]) {
    //       pan_stepper->moveTo(gotoposition[1], true);
    //     }
    //     if (tilt_stepper->getCurrentPosition() != gotoposition[2]) {
    //       tilt_stepper->moveTo(gotoposition[2], true);
    //     }
    //   }
  } else if (pwm[5] > 1490 && pwm[5] < 1510) {
    automove = false;
    pan_stepper->setAcceleration(PAN_MAX_ACCELERATION);  // steps/s²
    pan_stepper->applySpeedAcceleration();
    tilt_stepper->setAcceleration(TILT_MAX_ACCELERATION);  // steps/s²
    tilt_stepper->applySpeedAcceleration();
    slide_stepper->setAcceleration(SLIDE_MAX_ACCELERATION);  // steps/s²
    slide_stepper->applySpeedAcceleration();
  }
}

//***************************************************************************************
void set_Speed(char _pts) {
  switch (_pts) {
    case 'p':
      {
        pan_time_motion_complete = double(steps_to_move[2]) / double(PAN_MAX_SPEED);
        pan_speed_motion_complete = PAN_MAX_SPEED;
        tilt_speed_motion_complete = abs(tilt_steps_to_move) / pan_time_motion_complete;
        slide_speed_motion_complete = abs(slide_steps_to_move) / pan_time_motion_complete;
        break;
      }
    case 't':
      {
        tilt_time_motion_complete = double(steps_to_move[2]) / double(TILT_MAX_SPEED);
        tilt_speed_motion_complete = TILT_MAX_SPEED;
        pan_speed_motion_complete = abs(pan_steps_to_move) / tilt_time_motion_complete;
        slide_speed_motion_complete = abs(slide_steps_to_move) / tilt_time_motion_complete;
        break;
      }
    case 's':
      {
        slide_time_motion_complete = double(steps_to_move[2]) / double(SLIDE_MAX_SPEED);
        slide_speed_motion_complete = SLIDE_MAX_SPEED;
        pan_speed_motion_complete = abs(pan_steps_to_move) / slide_time_motion_complete;
        tilt_speed_motion_complete = abs(tilt_steps_to_move) / slide_time_motion_complete;
        break;
      }
  }
}

void CalcMoves() {
  pan_steps_to_move = PInPoint[ActualInOut] - POutPoint[ActualInOut];
  tilt_steps_to_move = TInPoint[ActualInOut] - TOutPoint[ActualInOut];
  slide_steps_to_move = SInPoint[ActualInOut] - SOutPoint[ActualInOut];

  steps_to_move[0] = abs(pan_steps_to_move);
  steps_to_move[1] = abs(tilt_steps_to_move);
  steps_to_move[2] = abs(slide_steps_to_move);

  sortArray(steps_to_move, 3);

  if (steps_to_move[2] == abs(pan_steps_to_move)) {
    //Serial.println("most steps 2 move on pan axis");
    set_Speed('p');
  }
  if (steps_to_move[2] == abs(tilt_steps_to_move)) {
    //Serial.println("most steps 2 move on tilt axis");
    set_Speed('t');
  }
  if (steps_to_move[2] == abs(slide_steps_to_move)) {
    //Serial.println("most steps 2 move on slide axis");
    set_Speed('s');
  }
  inOutSpeed = inOutSpeed / 1000;
  pan_stepper->setSpeedInHz(pan_speed_motion_complete * inOutSpeed);
  tilt_stepper->setSpeedInHz(tilt_speed_motion_complete * inOutSpeed);
  slide_stepper->setSpeedInHz(slide_speed_motion_complete * inOutSpeed);
}
//***************************************************************************************

void CheckCH7() {
  if (pwm[6] > 1510) {  // Set 1st InOut position
    ActualInOut = 1;
  } else if (pwm[6] > 1490 && pwm[6] < 1510) {  // Set 2nd InOut position
    ActualInOut = 2;
  } else if (pwm[6] < 1490) {  // Set 3rd InOut position
    ActualInOut = 3;
  }
}

void CheckCH8() {
  if (pwm[7] < 1490 && pwm[5] == 1500) {  // Activate the MoveToIn or MoveToOut sequence
    switch (ActualInOut) {
      case 1:
        if (pwm[4] < 1490) {
          inOutSpeed = pwm[3];  // Auto speed potentiometer
          // Place the 1st IN position into the Array
          gotoposition[0] = SInPoint[ActualInOut];
          gotoposition[1] = PInPoint[ActualInOut];
          gotoposition[2] = TInPoint[ActualInOut];
          CalcMoves();
          if (slide_stepper->getCurrentPosition() != gotoposition[0]) {
            slide_stepper->moveTo(gotoposition[0]);
          }
          if (pan_stepper->getCurrentPosition() != gotoposition[1]) {
            pan_stepper->moveTo(gotoposition[1]);
          }
          if (tilt_stepper->getCurrentPosition() != gotoposition[2]) {
            tilt_stepper->moveTo(gotoposition[2]);
          }
          if (!(pan_stepper->isRunning()) && !(tilt_stepper->isRunning()) && !(slide_stepper->isRunning())) {
            delay(500);
          }
        } else if (pwm[4] > 1490) {
          inOutSpeed = pwm[3];
          // Place the 1st OUT position into the Array
          gotoposition[0] = SOutPoint[ActualInOut];
          gotoposition[1] = POutPoint[ActualInOut];
          gotoposition[2] = TOutPoint[ActualInOut];
          CalcMoves();
          if (slide_stepper->getCurrentPosition() != gotoposition[0]) {
            slide_stepper->moveTo(gotoposition[0]);
          }
          if (pan_stepper->getCurrentPosition() != gotoposition[1]) {
            pan_stepper->moveTo(gotoposition[1]);
          }
          if (tilt_stepper->getCurrentPosition() != gotoposition[2]) {
            tilt_stepper->moveTo(gotoposition[2]);
          }
          if (!(pan_stepper->isRunning()) && !(tilt_stepper->isRunning()) && !(slide_stepper->isRunning())) {
            delay(500);
          }
        }
        break;
      case 2:
        if (pwm[4] < 1490) {
          inOutSpeed = pwm[3];  // Auto speed potentiometer
          // Place the 2nd IN position into the Array
          gotoposition[0] = SInPoint[ActualInOut];
          gotoposition[1] = PInPoint[ActualInOut];
          gotoposition[2] = TInPoint[ActualInOut];
          CalcMoves();
          if (slide_stepper->getCurrentPosition() != gotoposition[0]) {
            slide_stepper->moveTo(gotoposition[0]);
          }
          if (pan_stepper->getCurrentPosition() != gotoposition[1]) {
            pan_stepper->moveTo(gotoposition[1]);
          }
          if (tilt_stepper->getCurrentPosition() != gotoposition[2]) {
            tilt_stepper->moveTo(gotoposition[2]);
          }
          if (!(pan_stepper->isRunning()) && !(tilt_stepper->isRunning()) && !(slide_stepper->isRunning())) {
            delay(500);
          }
        } else if (pwm[4] > 1490) {
          inOutSpeed = pwm[3];
          // Place the 2nd OUT position into the Array
          gotoposition[0] = SOutPoint[ActualInOut];
          gotoposition[1] = POutPoint[ActualInOut];
          gotoposition[2] = TOutPoint[ActualInOut];
          CalcMoves();
          if (slide_stepper->getCurrentPosition() != gotoposition[0]) {
            slide_stepper->moveTo(gotoposition[0]);
          }
          if (pan_stepper->getCurrentPosition() != gotoposition[1]) {
            pan_stepper->moveTo(gotoposition[1]);
          }
          if (tilt_stepper->getCurrentPosition() != gotoposition[2]) {
            tilt_stepper->moveTo(gotoposition[2]);
          }
          if (!(pan_stepper->isRunning()) && !(tilt_stepper->isRunning()) && !(slide_stepper->isRunning())) {
            delay(500);
          }
        }
        break;
      case 3:
        if (pwm[4] < 1490) {
          inOutSpeed = pwm[3];  // Auto speed potentiometer
          // Place the 3rd IN position into the Array
          gotoposition[0] = SInPoint[ActualInOut];
          gotoposition[1] = PInPoint[ActualInOut];
          gotoposition[2] = TInPoint[ActualInOut];
          CalcMoves();
          if (slide_stepper->getCurrentPosition() != gotoposition[0]) {
            slide_stepper->moveTo(gotoposition[0]);
          }
          if (pan_stepper->getCurrentPosition() != gotoposition[1]) {
            pan_stepper->moveTo(gotoposition[1]);
          }
          if (tilt_stepper->getCurrentPosition() != gotoposition[2]) {
            tilt_stepper->moveTo(gotoposition[2]);
          }
          if (!(pan_stepper->isRunning()) && !(tilt_stepper->isRunning()) && !(slide_stepper->isRunning())) {
            delay(500);
          }
        } else if (pwm[4] > 1490) {
          inOutSpeed = pwm[3];
          // Place the 3rd OUT position into the Array
          gotoposition[0] = SOutPoint[ActualInOut];
          gotoposition[1] = POutPoint[ActualInOut];
          gotoposition[2] = TOutPoint[ActualInOut];
          CalcMoves();
          if (slide_stepper->getCurrentPosition() != gotoposition[0]) {
            slide_stepper->moveTo(gotoposition[0]);
          }
          if (pan_stepper->getCurrentPosition() != gotoposition[1]) {
            pan_stepper->moveTo(gotoposition[1]);
          }
          if (tilt_stepper->getCurrentPosition() != gotoposition[2]) {
            tilt_stepper->moveTo(gotoposition[2]);
          }
          if (!(pan_stepper->isRunning()) && !(tilt_stepper->isRunning()) && !(slide_stepper->isRunning())) {
            delay(500);
          }
        }
        break;
    }
  } else if (pwm[7] > 1510) {
    SetInOut = true;
  } else if (pwm[7] > 1490 && pwm[7] < 1510) {
    SetInOut = false;
  }
}

void CheckCH9() {
  if (pwm[8] > 1900) {
    pan_stepper->setCurrentPosition(0);
    tilt_stepper->setCurrentPosition(0);
    slide_stepper->setCurrentPosition(0);
  }
}

//CHECK FOR SERIAL INPUT---------------------------------------
void InputTask(void *) {

  for (;;) {
    uint8_t index;
    //process sumd input, due to lead time from previous decoding, buffer may overflow and being corrupted -> reset
    sumdDecoder->reset();
    while (Serial1.available() > 0) sumdDecoder->add(Serial1.read());

    //display failsafe status on console
    if (failSafe && !sumdDecoder->failSafe()) {
      failSafe = false;
      //println("Reception OK");
    } else if (!failSafe && sumdDecoder->failSafe()) {
      failSafe = true;
      //println("Reception Lost");
    }

    pwm[0] = sumdDecoder->channel[0];
    pwm[1] = sumdDecoder->channel[1];
    pwm[2] = sumdDecoder->channel[2];
    pwm[3] = sumdDecoder->channel[3];
    pwm[4] = sumdDecoder->channel[4];
    pwm[5] = sumdDecoder->channel[5];
    pwm[6] = sumdDecoder->channel[6];
    pwm[7] = sumdDecoder->channel[7];
    pwm[8] = sumdDecoder->channel[8];
    vTaskDelay(25);
  }
}```

[gin66]

Congratulations to have identified the root cause.

In regards to the jumps, perhaps it is related to auto enable. The readme states:
Few comments to auto enable/disable:

• If the motor is operated with micro stepping, then the disable/enable will cause the stepper to jump to/from the closest full step position

[Freeejack]

Oh, I did not think about it. I use 64 micro steps, then I will try without auto enable. The enable pins of the motor controllers are connected to GND anyway. I don't know if this has any significance. In the current state, my next task is to be able to reliably switch between positions so that the initial zero points remain in place. :-)

This is especially important for the slide movement, so that the entire device does not fall off the rail if one of its ends goes too far. I also thought that some kind of sensor might help with this, but the accuracy of the steps is just as important.

Maybe if you allow me to ask a question, do you have any idea what kind of sensor I should use so that I can bring the motors to zero position?

[gin66]

if you do not use the enable pins, then the autoenable on/off does not make a difference.

End point detection is typically done either by switch or light barrier

[Freeejack]

Thank you very much. Then I have to keep looking for what causes the zero point to move after a few movements...

[Freeejack]

[gin66]

Could you please check, if this info is of help.