第1步：

我使用了很多單詞來描述我的方法，但是我也尊重每個人都會從另一個地方來處理這個問題。如果您有經驗，請多說些抱歉，但是，如果您不熟悉arduino，并且想以比當前使用accelstepper更快的速度運行步進電機，那么請問所有問題。

計劃：

Accelstepper使用非線性加速度曲線，以逐漸增加步進電機的步進率。它在stepper.run（）調用期間以非常抽象的方式執行此操作，這是一個（粗略的想法）函數，用于檢查您是否應進行新步驟，如果是，則步進驅動程序并計算下一次執行的時間步驟已到。您需要經常調用它，但是您可以在控制循環中執行其他操作。因此，例如，在這里您可能會看到：

同時（digitalRead（someSensor）== high）{

//做東西

//做更多東西

stepper.run（）;

}

只要“填充”時間不長，stepper.run（）就會非常頻繁地運行，并且步進操作。但是stepper.run（）并不是一個非常快速的函數，在某些時候它是限制因素！然后，此while循環會花費太長時間。

所以我的建議和方法是執行以下操作：

//starting from the non-moving position

while（condition）{

//do stuff

stepper.run（）;

if （stepper.Speed（）==maxAccelstepperSpeed）{

//Extrafast mode is a simple linear acceleration program. Not as nice as stepper.run（）， but much faster.

break; //let‘s get out of this while loop！

}

//extraFastMode（）偽代碼：

//calculate a starting stepdelay based on what speed you’re transitioning away from the accelstepper library.

The new method of stepping will just be：

“While（condition）{

”Do stuff/ check extra if statements

Take a step

wait manually with a delay

add to a counter

//if the counter hits a trigger number， and you‘re not at your final target speed，

then decrease your delay ［which increases your motor speed“

}//loop back to the top

這有意義嗎？下一步，讓我們深入研究同樣冗長的注釋代碼，如果有任何問題，請返回。

步驟2：哇，代碼！

我從我的項目中提取了一個完整的程序，并在保留大部分表單的同時將其剝離了下來。 “功能”模式。我可以說原始代碼有效，但是我只測試了新代碼可以編譯。

此代碼是否完美？否。

此代碼是執行此操作的最佳還是最快方法？否。

但這行得通嗎？是。我希望我已使其功能盡可能透明。

它最初是作為函數調用編寫的，在我的程序中可以使用幾個不同的馬達（調用accellstepper的不同實例），但在此示例中我將其簡化了一些。

建議：如果簽出附帶的.ino，則可以在您喜歡的文本編輯器中查看代碼。它的顯示效果會好得多，我不建議整體復制此代碼塊，因為它可能會稍微變形。

/*This document should end up as a short introduction to one particular method of

sidestepping Accelstepper’s somewhat low step-rate limit using default stepper.run（）

protocol. It is not the only and certainly not the best method. But it works.*/

//Extra note about the purpose： This lets you use the nice accelstepper acceleration

algorithm for the initial acceleration and then a much cruder linear ramp thereafter.

#include

const int stepPin=23;

const int directionPin=14;

/*Accelstepper SetMotorIdentifier（TYPE， STEP， DIRECTION） We are using type 1 because I‘m using a classic STEP/DIR stepper Driver.

Different types might ask for things other than step&direction ［see Accelsteppr documentation］*/

AccelStepper stepper（1，stepPin，directionPin）;

long actuatorDistance = 158400; //This varies depending on your purpose. I wanted to go 158，400 steps. That corresponded with 99 rotations of my 1.8 deg stepper motor with 1/8th microstepping.

int actuatorSpeed=3900; //This corresponded to 487.5 steps/second， or 2.47 revs/second， which for me corresponding to about 40 seconds for my actuator.

unsigned long actuatorTimeout =19000; //This might not be used in the tutorial， but it’s good to have a timeout threshold if you think your actuator might stall out and you want some backup timeout.

int actuatorAcceleration=8500; //This acceleration value was chosen by experimentation， and only corresponds to the initial actuatorSpeed trigger point - after that your linear acceleration takes over.

const byte programOverhead=26; //measured in mS.

//During the fast-stepping function you may want to check a few sensors （in my case， for an end-stop）。 The thing is you want your initial linear step-delay to be pretty close to whatever step rate the accelstepper actuatorSpeed was. For this to work， you need to know roughly how much time your control loop takes excluding the step delay. If your sketch is similar to mine in what it‘s checking， you can start with my numbers.

const byte minPulseWidth=3; //different drivers require different minimum step pulses to register a line change.。.The basic reprap drivers are 1-2mS， this is sort of an unnecessary variable I used for extra fluff， you can probably do without it.

//FINAL STEP RATE VALUE

byte stepDelayTarget=90-minPulseWidth-programOverhead; // This should never add up to 《0. Check manually.

//This number， here shown as 90， relates to your target final step max speed. 90 is in uS， so I went up to 1000，000/90 = 11，111.1.。 steps/second. That’s an improvement over the default max of 3900 steps/seconds and was rate limited in my application by the physical system. I don‘t know how high you can expect an arduino to go. I would guess around 30uS for the mega with my specific code （ergo 33，000 steps/s）

const int systemEndstop=24;

const int enablePin=53; //This is another extra variable I kept in the example code. You can ignore it， but it refers to a pin that is controlling the enable pin of my DRV8825 driver. Because it’s 53 you can see I wrote this probably for an arduino mega.

//Global variables as part of the program functions.

unsigned long timeStart; //We want to be able to reset timeStart in different parts of the program. It‘s a global variable redeclared by a number of functions. Be aware. Another ’extra variable‘ I kept in the example code.

void setup（）{ //Void setup runs once during initial boot of microprocessor， but not after.

stepper.setPinsInverted（false，false，true）; // setPinsInverted（bool Dir，bool Step，bool Enable） Bool enable is == true because my enable pin is OFF when HIGH and ON when LOW. This is opposite of the default， so we enable the invert function. I believe the default is set for an A4988 driver， and this use case is for the Pololu DRV8825 breakout.

//the following should be familiar if you’ve used the accelstepper program before.

stepper.setMaxSpeed（actuatorSpeed）;

stepper.setAcceleration（actuatorAcceleration）;

stepper.setEnablePin（enablePin）;

stepper.setMinPulseWidth（3）; //Remember the minPulseWidth variable from before？ This is the accelstepper version.

// declare pinmodes

pinMode（systemEndstop，INPUT）;

digitalWrite（systemEndstop，HIGH）; //This sets internal 20k pull-up resistor. It is usually necessary for a hall sensor to have a pull-up resistor， and in this case I was using a hall-sensor endstop.

} //end of void setup

void fastSteppingFunction（）{ //This function will be used later as the linear-ramp portion of the code.

//Ok！ StepDelay needs to be set so that it creates a stepping speed approximately equal to the stepping speed that accelstepper leaves off at. Much different， and you will have caused an instantaneous acceleration that the stepper motor will fail to keep up with.

byte stepDelay=（（1000000/actuatorSpeed）-minPulseWidth-programOverhead）;

//IMPORTANT NOTE： If your actuatorSpeed is less than 3900steps/s， you might want to change stepDelay to a uint_16t or otherwise ”uint.“ Bytes are less overhead to work with， but can‘t be 》255

//In my original code， I actually hard coded the stepDelay start at 250 instead of （100000/actuatorSpeed）。 The math for my values would put 1，000，000/actuatorSpeed at 256 steps/second， and for some reason I chose 250. But this math step allows for you to change your actuatorSpeed without needing to change the value here.

byte counter = 0;

//counter is used as a way to make a very quick conditional statement that overflows every 256 digits. There are other ways to implement the linear ramp. This is the way I chose. I thought it would be fast although it’s no longer clear to me why I chose exactly this method.

while（digitalRead（systemEndstop）==HIGH）{ //remember this is our ending condition. In my code we are not relying on our steps to be counted. You can count steps too， by setting your condition to be when a bigger counter reaches a certain number. Then you need to implement a counter that increments during each step.

digitalWrite（stepPin，HIGH）;

delayMicroseconds（minPulseWidth）;

digitalWrite（stepPin，LOW）;

delayMicroseconds（stepDelay）;

if （actuatorTimeout《（millis（）-timeStart））{ //Did you notice we said ”timeStart=millis（）“ at the start of actuation？ This is because I recommend your system has a timeout in case your motor stalls out and you never reach your endstop.

//make an error function and call it here.

//make a function to get back up to speed， assuming you want to do that after you resolve the error. Optional not included.

//recursively return to the fastSteppingFunction（）;

}

/*Next step is to increment the counter. This will run each time you repeat the loop.

My method is not very adjustable to changing the slope of the ramp， and if I were to rewrite

this code today I would probably choose something else. Consider this when implementing

your code.

*/

counter=counter+2; /*always manipulate this counter so that you understand when your

counter will reach the condition in the if statement below. In my case， it will reach the

the condition every 256/2 steps， i.e， every 128 steps. If I chose a number like ”3“ instead

of ”2“ I would have a problem because the counter would not reach 0 until a third overflow

of the byte counter， so I would be decreasing the slope of my linear ramp six times.

Meanwhile I can also decrease the slope by half by changing the number to 1. Or， I can double

the slope by saying 4. This lack of flexibility in changing the linear ramp slope is why

I suggest considering other methods to make a linear ramp. Try to implement your method with

minimum math. Ideally do not include multiplication in the loop， and especially not division.

*/

if （stepDelay》stepDelayTarget && counter==0）{ //So this condition is looking to see if you‘re reached your max speed target， and if you haven’t yet and the counter has reached its trigger point ［0］， then it decreases the delay.

stepDelay--; //Stepdelay-- is a fast way of saying ”stepdelay=stepdelay-1“， i.e， your decreasing the step delay. By decreasing the step delay， you are increasing the frequency of steps/ the speed of your motor.

}

}

}

}

void moveActuatorForward（）{

//Hey！ You‘re about to start moving a motor. In a lot of cases that means you should make some safety check. The following commented if statement is a filler for that.

/*if （［insert errorCondition］）{

//stepper.disableOutputs（）;

//error（）;

}*/

stepper.enableOutputs（）; //This is redundant， in fact. It’s already been called.

stepper.move（actuatorDistance）; //You need to tell accelstepper how far you‘re going！

timeStart = millis（）; //I used a global variable in other parts of the code， maybe you want to use a local variable.

//Hey we’re finally starting！！

while（1）{ //Title： ”Basic Moving While Loop“

if （digitalRead（systemEndstop）==LOW）{ //checks if we hit the endstop before reaching the accelstepper max speed

//This never happened for my application， but maybe does for yours.

break; //break removes you from the while loop called ”Basic Moving While loop“

}

stepper.run（）; //this makes your initial acceleration completely abstract.

if（stepper.speed（） fastSteppingFunction（）;

break;

}

}

stepper.DisableOutputs（）;

//Hey we‘re done！

}

void loop（）{

//do stuff other than moving your motors， if you have other stuff to do.

stepper.disableOutputs（）; //I tend to add extra disableOutputs in case I made mistakes in the code， because my stepper motors were set to a high current that would eventually make those little motors overheat. For simple programs this isn’t a big deal， but once you start running around with more program states you want to be sure you don‘t let your motor overheat while you’re doing something else.

if （1）{ //Here I‘m just suggesting that you probably want to run the actuator based on some condition.

//Now this is a stripped version of the code. Let’s just look at it as a goal to ”actuate“ a linear actuator. There are two endstops for this device but we‘re only looking at moving the actuator from ”home“ to ”endstop“

stepper.enableOutputs（）;

stepper.setCurrentPosition（0）; //My physical system had a lot of friction， so I never decelerated my load. This meant that when I start the motor， accelstepper sometimes wants to ”slow down“ before it accelerates again. This is even if it was in fact not running. SetCurrentPosition（0） acts as a reset to the accelstepper code.

moveActuatorForward（）;

stepper.disableOutputs（）;

}

}

步驟3：PS，您注意到了嗎？

我的“線性斜坡”實際上不是線性斜坡。我每128步（大約每20mS）減少1uS步之間的延遲。最初，步進延遲為250mS，步進增加的速率為每32mS 1uS。到我的驅動結束時，每11.5mS的增加速率為1uS。這是一個非線性的斜坡，在接近終點時加速度增加。可能有很多很好的方法可以使此線性化，或更改執行速度增加的方法。但是我的執行器已經運行了好幾個月，所以我認為該方法已經足夠好了。

事實是，直到我編寫此可指導的代碼并梳理我的代碼之前，我才注意到它。

責任編輯：wv