ich verstehs nich -> zeitverhalten accel stepper

MicroBahner:
Die Beschleunigung ergibt sich daraus, dass die Steplänge, als die Zeit zwischen 2 Steps von Schritt zu Schritt kleiner wird.

weil die endgeschwindigkeit noch nicht erreicht ist. die steplänge ist dann erst minimal wenn die endgeschwindigkeit erreicht ist, oder?

Genau!

wie setzen sich denn jetzt die 29ms für den einen schritt zusammen?

und wenn ich in dem sketch von my_xy_project post #14 run() durch runSpeed() ersetze, kommt größenteils 0 raus. ich dachte ich sehe jetzt
1 schritt 1ms
10x 1 schritt 10ms
1x 10 schritte 10ms

ffm65:
bei move(1) würde ich erwarten, dass er die beschleunigungsphase beginnt, die dann aber vorzeitig abbricht weil ja der nächste schritt schon ansteht.

Ne eben nicht. Das hast Du ja in Deiner for Variante erlebt. Wenn der Schritt noch nicht zu Ende war, hat er den nächsten ausgelassen.

DU musst dafür sorgen, das der nächste Schritt erst übergeben wird, wenn der vorherige beendet ist.
Das ist mein - tür auf - holz rein - tür zu Beispiel gewesen.
Die Lib übernimmt für Dich, wenn Du 10 holz mit einem Mal weg haben willst, die Aufgabe die Tür zu öffnen, alle Holz reinzuschmeissen und erst dann die Tür zu schliessen.
Der Start bis zum ersten Holz bleibt gleich - aber aufgrund der aktiven Bewegung braucht es bis zum nächsten Step (Holz) weniger Zeit.

Aber ich glaube Microbahner kann das besser erklären, was die LIb macht.

[edit]
HAA Die Forensoftware hat jetzt nach dem xten Versuch meinen Text doch noch zugelassen - ok, zu spät aber was solls[/edit]

Irgendwie 'verarscht' ihr die AccelStepper auch mit dem ständigen move(1) :wink: - so kann die nicht vernünftig arbeiten.

Man muss vielleicht erstmal ein bisschen die Intuition hinter AccelStepper bzw. Steppern allgemein verstehen.

Schrittmotore sind primär nicht einfach zum Drehen da, sondern zum Positionieren. Z.B. einen Schlitten per Spindel hin- und herbewegen und zu bestimmten Positionen fahren. Typischen Anwendungsbeispiel sind auch die 3D-Drucker, wo die Düse kontrolliert bewegt und positioniert werden muss.

Daran sind auch die wesentlichen Funktionen der AccelStepper ausgerichtet: Ich gebe ( mit 'moveTo(x)' ) eine Zielposition vor und AccelStepper rechnet anhand der momentanen Position und des Referenzpunktes ( das ist 'Position 0' ) aus, wieviele Steps es bis dahin sind. Mit Hilfe der run() Anweisung fährt der Stepper dann in die entsprechende Position in dem die erforderlichen Stepimpulse ausgegeben werden ( aber immer nur maximal einer pro run()-Aufruf ). Ein weiterer Parameter ist dann noch, wie schnell diese Pulse ausgegeben werden. Das hängt von 'maxSpeed' und der Acceleration ab. Der Aufruf von run() muss auf jeden Fall häufiger erfolgen, als es der maximalen Steprate entspricht. Ist beim Aufruf von run() die Zeit für den nächsten Stepimpuls noch nicht erreicht, macht es einfach nichts. Wird run() zu selten aufgerufen, stimmen Beschleunigung und max. Geschwindigkeit nicht. Der Zielpunkt wird aber trotzdem erreicht ( solange run() überhaut aufgerufen wird ).

Auch der 'move(x)' Befehl ist al Poaitionieranweisung ausgelegt, nur das als Referenz für die Zielposition nicht der Referenzpunkt ( Position 0) verwendet wird, sondern die aktuelle Position. D.h. erst wird die absolute Zielposition berechnet, indem zur aktuellen Position die in der move(x)-Anweisung angegebenen Steps addiert werden, und dann wird wieder genauso verfahren, wie bei der absoluten Positionierung ( mit 'moveTo(x) ). Solange sich also an der aktuellen Position nichts ändert, kann ich eine move(x) Anweisung sooft aufrufen wie ich will, das Ergebnis ( die absolute Zielposition) ist immer dieselbe.

Damit Beschleunigung und Bremsen korrekt berechnet werden kann, muss die Lib den gesamten Weg zum Zielpunkt kennen. Wenn man nun als neuen Zielpunkt immer nur die nächste Stepposition angibt, und - sobald die erreicht wird - den Zielpunkt wieder eins weiterschiebt, kann die AccelStepper nicht wirklich funktionieren. Es wird immer der entsprechen maxSpeed und Acceleration berechnete längste Anfangsschritt ausgeführt, aber weder gibt es eine Beschleunigung, noch wird jemals maxSpeed erreicht.

Vielleicht noch ein Wort zu runSpeed, weil das auch angesprochen wurde und oftmals falsch eingesetzt wird.
runSpeed() und setSpeed(speed) sind zunächst mal Unterfunktionen von run(), die verwendet werden, um die entsprechend der Beschleunigung/Bremsen aktuell berechnete Geschwindigkeit vorzugeben, und dementsprechend einen Schritt auszuführen.
Man kann diese Funktionen auch dazu verwenden, den Motor mit konstanter Geschwindigkeit drehen zu lassen. Eine Zielposition wird dabei aber nicht beachtet ( der interne Positionszähler wird aber aktualisiert - die Lib weis also schon noch, wo der Motor gerade ist ).
Eine gemischte Verwendung der 'normalen' Positionsfunktionen ( set Acceleration, move, moveTo, run ... ) mit setSpeed und runSpeed führt aber zu unvorhergesehenen Ergebnissen, da die Positionsfunktionen diese eben auch aufrufen und die entsprechenden internen Werte (z.B. die 'speed' ) verändern.

Puhh - das war jetzt viel Text, und wahrscheinlich habe ich jetzt sämtliche Klarheiten beseitigt ....

P.S. Um die Abläufe zu visualisieren, habe ich das auch mal in einem Logikanalysator aufgenommen. Da sieht man genau wann was aufgerufen wird, das kann ich nachher auch nochmal posten ( wenn von Interesse ).

MicroBahner:
P.S. Um die Abläufe zu visualisieren, habe ich das auch mal in einem Logikanalysator aufgenommen. Da sieht man genau wann was aufgerufen wird, das kann ich nachher auch nochmal posten ( wenn von Interesse ).

Bin zwar nicht der TO, aber: Interesse! :slight_smile:

@MicroBahner: War das dieser Beitrag?

Gruß Tommy

Tommy56:
@MicroBahner: War das dieser Beitrag?

Nein, da ging es ja allgemein um die Ansteuerung von Steppern mit Stromtreibern.

Hier habe ich mal auf die Schnelle ein paar Visualisierungen für die Programm in diesem Thread gemacht, wo man die zeitliche Abfolge der 'run' und 'move' Aufrufe und die erzeugten Steps auf einer Zeitleiste sieht. Also speziell zum Verständnis der Funktionsweise der AccelStepper, die ja hier angefragt wurde. Die reinen seriellen Ausgaben zeigen da nur die halbe Wahrheit :wink:
Z.B. so etwas( Basis Sketch von my_xy_projekt in #10, aber mit hoher Beschleunigung, also praktisch ohen Rampe ):
1Zeile: run()-Aufruf
2.Zeile move(1)
4.Zeile loop-Durchläufe
5-Zeile Steppulse


Interessant dabei ist, dass die Steppulse schneller kommen als es maxSpeed entspricht.

Mit Beschleunigung sieht das dann so aus:


da rotiert der loop dann schon ziemlich lange, bis wieder ein Step erzeugt wird. Eine echte Beschleunigung gibt es aber wegen dem move(1) nicht ( wie ich ja oben ausgeführt habe ), das setzt sich einfach immer im gleichen Zeitraster fort.

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.