Is it just me? Multistepper speed slow.

[cbradburne]

Hi,
I have a 3 axis camera slider (pan tilt slide) using a Teensy3.2 with TeensyStep.

I have observed that when moving all 3 axis together the speed of all 3 axis is a lot lower than it should be.
Obviously I understand that they are all bound by the slowest motor so they have a synchronised finish. I've modified the example sketch so you can test it too.

The speed of the last 2 tests is significantly slower than it could be. Especially the last test, all 3 axis never reach their max speed.

I hope it's something I'm doing wrong!!

Thanks for reading,
Colin

#include "TeensyStep.h"
Stepper motor_1(19, 18);   // STEP pin, DIR pin
Stepper motor_2(17, 16);
Stepper motor_3(15, 14);
StepControl controller;
void setup()
{
  motor_1
    .setMaxSpeed(700)           // steps/s
    .setAcceleration(5000);     // steps/s^2 
  motor_2
    .setMaxSpeed(700)           // steps/s
    .setAcceleration(5000);     // steps/s^2 
  motor_3
    .setMaxSpeed(5000)          // steps/s
    .setAcceleration(5000);     // steps/s^2     
}
void loop() 
{  
  constexpr int spr = 16*200;   // 3200 steps per revolution
  for(int i = 0; i < 3; i++)
  {
    motor_3.setTargetRel(3*spr);
    controller.move(motor_3);  

    motor_3.setTargetRel(-(3*spr));
    controller.move(motor_3);  
  }
  delay(500);
  motor_1.setTargetAbs(1*spr);
  motor_2.setTargetRel(spr/2);
  controller.move(motor_1, motor_2);

  motor_2.setTargetRel(300);
  motor_3.setTargetRel(-(5*spr));
  controller.move(motor_2, motor_3);

  motor_1.setTargetAbs(0);
  motor_2.setTargetAbs(0);
  motor_3.setTargetAbs(0);
  controller.move(motor_1, motor_2, motor_3);
  delay(1000);
}

[luni64]

I don't know how familiar you are with Bresenham's algorithm so I'll expand a bit:

• For a given movement the algorithm first finds the "lead-motor", this is the motor which will do most steps and which will be accelerated to its max speed. Since all other motors are doing less steps, Bresenham's algorithm only needs to decide at each step of the lead motor if one of the "slave motors" needs to do a step or not.
• Thus, the speed profile of the lead motor automatically defines the speed of all slave motors. In principle one could calculate the max speed of the lead motor as the largest speed which ensures none of the motors will get faster than the given v_max.
• Instead of doing that calculation, TeensyStep simply uses the slowest speed of all motors as the speed of the lead motor. This ensures that none of the slave motors will be driven above their v_max. This method is very simple but of course not optimized. In your example that leads to v_max = 700Hz whenever one of the slower motors is involved in the movement. -> Suboptimal but it is as it is.

In case you want to improve that (shouldn't be too difficult), you'll find the relevant code here:

TeensyStep/src/StepControlBase.h

Line 94 in 57e532f

// Calculate acceleration parameters --------------------------------

As you see in the linked code, targetSpeed is defined as the minimal value of all motors. All you need to do is to calculate a more optimal speed and assign it to target speed. I'm definitely willing to pull a corresponding change into the library if it works as expected.

Especially the last test, all 3 axis never reach their max speed.

As explained above the lead motor is supposed to run at 700Hz (smallest v_max) which it actually does:

Hope that helps

[cbradburne]

Great explanation! Thank you.

I am a little familiar with Bresenham's algorithm, and that's why I didn't understand why the motor doing the most steps never reached v_max. Now you've explained how TeensyStep uses the slowest speed for all motors, it all makes sense now.

I'll have a look at StepControlBase and see if I can figure something out.

Thanks again!

[cbradburne]

Ok, I've made it work within the Arduino code itself as I'm not sure how to implement it into the StepControlBase.h file.
I've adapted the code from the MultiStepper library, specifically this part:

void MultiStepper::moveTo(long absolute[])
{
    // First find the stepper that will take the longest time to move
    float longestTime = 0.0;

    uint8_t i;
    for (i = 0; i < _num_steppers; i++)
    {
        long thisDistance = absolute[i] - _steppers[i]->currentPosition();
        float thisTime = abs(thisDistance) / _steppers[i]->maxSpeed();

        if (thisTime > longestTime)
            longestTime = thisTime;
    }

    if (longestTime > 0.0)
    {
        // Now work out a new max speed for each stepper so they will all
        // arrived at the same time of longestTime
        for (i = 0; i < _num_steppers; i++)
        {
            long thisDistance = absolute[i] - _steppers[i]->currentPosition();
            float thisSpeed = thisDistance / longestTime;
            _steppers[i]->moveTo(absolute[i]); // New target position (resets speed)
            _steppers[i]->setSpeed(thisSpeed); // New speed
        }
    }
}

This is what my working code looks like, it ain't pretty but you'll get the idea:

void moveToIndex(int index)
{
    float thisDistance = 0.0;
    float thisTime = 0.0;
    float longestTime = 0.0;
    float fastestSpeed = 0.0;
    float thisSpeed = 0.0;

    thisDistance = keyframe_array[index].panStepCount - stepper_pan.getPosition();
    thisTime = abs(thisDistance) / keyframe_array[index].panSpeed;
    if (thisTime > longestTime)
        longestTime = thisTime;

    thisDistance = keyframe_array[index].tiltStepCount - stepper_tilt.getPosition();
    thisTime = abs(thisDistance) / keyframe_array[index].tiltSpeed;
    if (thisTime > longestTime)
        longestTime = thisTime;

    thisDistance = keyframe_array[index].sliderStepCount - stepper_slider.getPosition();
    thisTime = abs(thisDistance) / keyframe_array[index].sliderSpeed;
    if (thisTime > longestTime)
        longestTime = thisTime;

    if (longestTime > 0.0)
    {
        thisDistance = keyframe_array[index].panStepCount - stepper_pan.getPosition();
        thisSpeed = abs(thisDistance / longestTime);
        if (thisSpeed > fastestSpeed)
            fastestSpeed = thisSpeed;

        thisDistance = keyframe_array[index].tiltStepCount - stepper_tilt.getPosition();
        thisSpeed = abs(thisDistance / longestTime);
        if (thisSpeed > fastestSpeed)
            fastestSpeed = thisSpeed;

        thisDistance = keyframe_array[index].sliderStepCount - stepper_slider.getPosition();
        thisSpeed = abs(thisDistance / longestTime);
        if (thisSpeed > fastestSpeed)
            fastestSpeed = thisSpeed;
    }

    stepper_pan.setMaxSpeed(fastestSpeed);
    stepper_tilt.setMaxSpeed(fastestSpeed);
    stepper_slider.setMaxSpeed(fastestSpeed);

    stepper_pan.setTargetAbs(keyframe_array[index].panStepCount);
    stepper_tilt.setTargetAbs(keyframe_array[index].tiltStepCount);
    stepper_slider.setTargetAbs(keyframe_array[index].sliderStepCount);

    multi_stepper.move(stepper_pan, stepper_tilt, stepper_slider);

    stepper_pan.setMaxSpeed(panDegreesToSteps(pan_set_speed));
    stepper_tilt.setMaxSpeed(tiltDegreesToSteps(tilt_set_speed));
    stepper_slider.setMaxSpeed(sliderMillimetresToSteps(slider_set_speed));
}

I'll keep going and try to incorporate it in to your code but I'm sure someone way more clever than I could sort it in no time.
In the mean time, I thought I'd post the above code if anyone is looking for the same results.

Thanks again for your help.

[luni64]

I had some thoughts on this as well and pushed a trial on the development branch. This version calculates the speed of the lead motor such that it ensures none of the slave motors will run too fast.

Here a spreadsheet for testing the algorithm. vTargetAlgorithm.xlsx

In the example shown below, it reduces vMax of the lead motor from the configured speed 10000stp/s to 1125stp/s which is the max speed to avoid running m2 too fast.

I didn't do much testing and won't have time for it for a few days. Maybe you can give the code in the development branch a try. Experience shows that combinations of directions and positive/negative targets often lead to unexpected errors. So, doing some corresponding tests would be helpful.

Here the code I added to the controller to implement the algorithm (not yet optimized). I just saw that relDist should be called f_cor to be consistent with the spread sheet.

float x = 0;
float leadSpeed = std::abs(this->leadMotor->vMax);
for (int i = 0; i < N; i++)
{
   float relDist = this->motorList[i]->A / (float)this->leadMotor->A * leadSpeed / std::abs(this->motorList[i]->vMax);
   if (relDist > x) x = relDist;
}
targetSpeed = leadSpeed / x;

[cbradburne]

That's amazing! I hope to test it out in within a couple of days and I'll report back.
Thank you for spending time on this.

[cbradburne]

All my tests so far are working out great!
Thanks again for this :)

[luni64]

Thanks for testing. I'll pull it into the master branch tomorrow.

[ramboerik]

Hi @luni64 !

I stumbled across this issue and thought that this is not only applicable for the speed but also for pullIn/pullOut and acceleration?

[luni64]

Hm seems logical but I need to wrap my head around this, didn't do much with the library lately. Probably the same or a similar algorithm will work for those. If you want to give it I try I can certainly pull it in.

[ramboerik]

Yes of course, I gave it a try here: ramboerik@d9a8a3e and it should work in a similar way for all parameters. I will however need more time to test it out 😃