Schrittmotor Takt - Richtung ansteuerung

Hallo miteinander,

ich möchte einen Schrittmotor Ansteuern über die Serielle Schnittstelle.

Hardware:

  • Arduino Mega
  • Endstufen SK8060 bis 6 A
  • Netzteil -Schaltnetzgerät S500 72 V 7 A
  • Schrittmotoren 8,7 Nm 6 A

Ich habe alles angeschlossen und den ersten Code auch schon fertig.

zumindest dreht sich mein Motor (Links Rechts). doch nicht ganz so wie ich das möchte.

Ich habe einen Drehzahlmesser mit dem ich die Drehzahl prüfen kann.

Wenn ich den Motor drehen lasse dann hat er jedoch nicht die Drehzahl die ich eingestellt habe.
Das andere ist das die Motorsteuerung gegen meine Erwartungen nur auf eine Abfallende Flanke des Takt Signales Reagiert. somit stimmen meine Takte auch nicht. :frowning:

So langsam stoße ich an die Grenzen dessen was ich noch selbst verstehe und nachvollziehen kann, auf gut deutsch ich habe einen Knoten in der Leitung, und bräuchte eure Unterstützung.

In meinem Code habe ich eine kleine Serielle Auswertung eingebaut, so kann ich Befehle an den Arduino senden.

Befehl run;Achen;RPM;Anzahl Schritte
z.B. run;x;100;200

Würde bedeuten:
Achse: x
RPM: 100
Anzahl Schritte 200

Die Steuerung kann nur Halbschritte, der Moter macht 1,8° sprich 400 Schritte wären eine Umdrehung.

Doch das klappt nicht denn in meinem Code mache ich nur 400 mal einen Flankenwechsel (TTL 5V Signal), und die Steuerung reagiert nur auf abfallende Flanken :frowning: nicht wie von mir erwartet auf ansteigende und abfallende Flanken.

Und was ich auch nicht, versteh ist warum meine RPM nicht stimmt.

Könntet Ihr bitte euch den Code anschauen, und Ihn entsprechend auseinander nehmen, wo ich über alle Fehler mal wider drin habe, die zu diesen Symptomen führen, wäre echt cool.

Gruß Mücke

  #define ZEILENTRENNZEICHEN 10
     int  Baudrate = 9600;          // Geschwindigkeit, Serielle Schnittstelle 
     int  PUL_Y    = 51;            // Schritte 
     int  DIR_Y    = 52;            // HIGH = Im Uhrzeigersinn          // LOW = Gegen den Uhrzeigersinn
     int  ENA_Y    = 53;            // HIGH = Motor ON, MIT Haltemoment // LOW = Motor OFF, KEIN Haltemoment
     int  RPM;                      // RPM angabe Global !
     long AnzPulse;                 // Sobald in der Variable ein Wert geschrieben wird,
                                    // läuft der Motor los, bis die gewünschte Anzahl
                                    // der Pulse ausgegeben wurde.
void setup()
 {
    Serial.begin(Baudrate);      // Seriellen Monitor Installiren
    pinMode(ENA_Y, OUTPUT);      // setzt den Pin als Output (kommunikation zum Motor)
    pinMode(DIR_Y, OUTPUT);      // setzt den Pin als Output (kommunikation zum Motor)
    pinMode(PUL_Y, OUTPUT);      // setzt den Pin als Output (kommunikation zum Motor)

    digitalWrite(ENA_Y, LOW);    // Freigabe setzen -> Der motor haelt ab jetzt seine Position
 }

void loop()
 {
   Motoransteuerung(RPM);                 // Pflicht !! wenn Pulse ausgefrt werden sollen wird dies hier gemacht
   char* text=receiveBuffer();
   if(text != NULL){
    if (strncmp_P(text, PSTR("run"), 3)==0) { Befehl_run(text + 4); }
   } // if(text != NULL)
 } // void loop

// *********************************************************************************************************
//                                        Motoransteuerung
// *********************************************************************************************************
   void Motoransteuerung(int _rpm)
   {
    static unsigned long _lastedge;                    // Kurzzeitgedächtnis 
    static boolean _Pulslevel = LOW;                   // Kurzzeitgedächtnis
    unsigned long _tp = 1000000 * 60 / 400 / _rpm;     // pulsdauer für high und lowpulse errechen.
    if (AnzPulse <= 0) return;                         // wenn keine Pulse auszugeben sind, abbrechen.
    if(micros() - _lastedge < _tp) return;             // wenn die Zeit für die nächste Flanke noch nicht erreicht ist, abbrechen.
    _lastedge = micros();                              // Startzeit des HIGH bzw. LOW Zeit merken
    _Pulslevel = !_Pulslevel;                          // _Pulslevel Zustand wechseln
    AnzPulse--;                                        // einen puls nach unten zählen 
    digitalWrite(PUL_Y, _Pulslevel);                   // Puls ausführen (zwei Pulse ist ein Tackt) 
   } // END Motoransteuerung
// ***********************************************************************************************
//                             Serielle Schnittstelle auslesen
// ***********************************************************************************************
  char* receiveBuffer() 
  {
    static char lineBuffer[35];                                    //  
    static byte counter = 0;                                       // 
    char c;                                                        // 
      if (Serial.available() == 0) return NULL;                    // 
      if (counter == 0) memset(lineBuffer, 0, sizeof(lineBuffer)); // 
    c = Serial.read();                                             // 
      if (c == ZEILENTRENNZEICHEN) {                               // 
        counter=0;                                                 // 
        return lineBuffer;                                         // 
      }                                                            // 
      else if (c>=40) {                                            // 
        lineBuffer[counter] = c;                                   // 
        if (counter < sizeof(lineBuffer) - 2) counter++;           // 
      }                                                            // 
    return NULL;                                                   // 
  } // END receiveBuffer
// ***********************************************************************************************
//                                   Befehl run
// ***********************************************************************************************
void  Befehl_run(char* str)
{
   String Achse = strtok(str, ";");                               // Achse auslesen 
          RPM   = atoi(strtok(NULL, ";"));                        // RPM Auslesen 
      AnzPulse  = atoi(strtok(NULL, ";"));                        // Anzahl Pulse auslesen 

    // parameter Pfüfen 
    if ((Achse == "x" or Achse == "y" or Achse == "z" or Achse == "a") 
     && (RPM >= 0)
     && (AnzPulse != 0))
     {
      if (AnzPulse < 0) {                                         // Wenn Anzahl Pulse Negativ ist dann 
        digitalWrite(DIR_Y, LOW);                                 // Drehrichtungspin setzen. (Gegen den Uhrzeigersinn)
        AnzPulse = abs(AnzPulse);                                 // Vorzeichen löschen 
      } else if (AnzPulse > 0) {                                  // Wenn Anzahl Pulse Positiv ist dann 
        digitalWrite(DIR_Y, HIGH);                                // Drehrichtungspin setzen. (Im Uhrzeigersinn)
      }
       Serial.println("######### DEBUG AUSGABE #########");
       Serial.print("Achse: "); Serial.println(Achse);
       Serial.print("RPM:   "); Serial.println(RPM);
       Serial.print("STEP:  "); Serial.println(AnzPulse);
       Serial.println("######### DEBUG ENDE ####''#####");
     } // parameter abfrage 
    else { 
      Serial.println ("NOK, Fehler: Parameter! ** run;Achse;RPM;STEP  **"); }
}

Was die Flanken etc. betrifft, da mußt Du Dich selbstredend an die Anforderungen Deines Controllers halten.

Die falsche Geschwindigkeit kommt möglicherweise von der Konstanten 1000000, die besser als 1000000L angegeben werden sollte, sonst schneidet sie der Compiler ggf. auf int Größe ab. Zusätzlich könnte es Probleme mit dem Hoch- und Runterfahren geben, weil der Schrittmotor mit anghängter Last nicht beliebig schnell beschleunigen kann - siehe AccelStepper Bibliothek.

DrDiettrich:
Die falsche Geschwindigkeit kommt möglicherweise von der Konstanten 1000000, die besser als 1000000L angegeben werden sollte, sonst schneidet sie der Compiler ggf. auf int Größe ab.

Öm meinst du das ich hinter die Zahl ein L schreiben soll?
was bedeutet das?

DrDiettrich:
Zusätzlich könnte es Probleme mit dem Hoch- und Runterfahren geben, weil der Schrittmotor mit anghängter Last nicht beliebig schnell beschleunigen kann - siehe AccelStepper Bibliothek.

Oh man da habe ich noch nicht dran gedacht.

meinst du die AccelStepper Bibliothek
kennst du da auch ein Deutsche Version von?

[EDIT]
da die Steuerung immer nur auf eine von beiden Flanken reagiert, rechne ich die Schritte einfach mal 2 sobald diese über die Serielle Schnittstelle kommen. somit wäre das erste Problem gelöst.
Jetzt muss ich das mit der RPM noch hin bekommen.

ALT:

AnzPulse  = atoi(strtok(NULL, ";"));                        // Anzahl Pulse auslesen

NEU:

AnzPulse  = atoi(strtok(NULL, ";"))*2;                        // Anzahl Pulse auslesen

Schmökere doch mal in der Reference zu Integer Constants, und freunde Dich dabei auch mit Englisch an.

kennst du da auch ein Deutsche Version von?

Gibt es nicht!

Du musst dich schon mit dem Original befassen.
Die Bibliothek ist sehr gut, ich benutze sie seit 2 Jahren in meinen Stepper-Projekten.

Allerdings:
AccelStepper verarbeitet wegen der zahlreichen internen Kalkulationen (ramp up, ramp down etc.) maximal ca. 4000 Steps, was bei Anwendungen mit sehr hohem Speedbedarf ggf. nicht ausreicht. Andere Bibliotheken oder eine selbstgestrickte Ansteuerung erreicht höheren Speed, dann muss man i.d.R. aber auf den Komfort de AccelStepper mit den zahlreichen Einstellmöglichkeiten verzichten.

Wenn dich die Lautstärke deines Steppers nicht stört, kannst du aber im FullStep Modus bei 4000 steps/sec durchaus eine meist ausreichende Speed erzielen.

DrDiettrich:
Schmökere doch mal in der Reference zu Integer Constants, und freunde Dich dabei auch mit Englisch an.

OK, ich glaube ich habe verstanden was da passiert. Danke.

Integer Constants

U & L-Formatierer

Standardmäßig wird eine Integer-Konstante als int mit den damit verbundenen Einschränkungen in Werten behandelt. Um eine ganzzahlige Konstante mit einem anderen Datentyp anzugeben, folge folgendes:

a 'u' oder 'U', um die Konstante in ein unsigniertes Datenformat zu zwingen. Beispiel: 33u
a 'l' oder 'L', um die Konstante in ein langes Datenformat zu zwingen. Beispiel: 100000L
a 'ul' oder 'UL', um die Konstante in eine unsignierte lange Konstante zu zwingen. Beispiel: 32767ul

rpt007:
Gibt es nicht!

Du musst dich schon mit dem Original befassen.

das ist schade, dann muss der Übersätze ran halten.

rpt007:
Die Bibliothek ist sehr gut, ich benutze sie seit 2 Jahren in meinen Stepper-Projekten.

ich habe gestern Nacht noch angefangen mich dort einzulesen, bisher kommt noch nicht mal ein Gleis vom Bahnhof bei mir an. Da muss ich mich noch mehr mit beschäftigen.

Dennoch interessiert es mich warum aus meinem Code nicht die richtige Geschwindigkeit hervor geht.

Muecke:
Doch das klappt nicht denn in meinem Code mache ich nur 400 mal einen Flankenwechsel (TTL 5V Signal), und die Steuerung reagiert nur auf abfallende Flanken :frowning: nicht wie von mir erwartet auf ansteigende und abfallende Flanken.

Hallo Mücke,

alle Stepper-Treiber die ich kenne machen nur einen Schritt bei steigender oder fallender Flanke. Ich hatte noch keinen Treiber in der Hand der bei beiden Flanken einen Schritt macht.

Gruß, Jürgen

Hallo Jürgen,

ich habe einen anderen Halbwegs Intelligenten Motor, warum auch immer hat er auf beide Flanken reagiert daher ist auch noch dieser Code Schnipsel.

hast du gesehen, du hast eine PN :wink:

Ich werde mich noch mal an die Berechnung setzen, denn das passt irgend wie nicht so richtig habe ich den Eindruck.

gruß Mücke

Meine Motorsteuerung reagiert immer auf die Flanke H (HIGH) zu L (LOW) mit einem Schritt.

Der Motor macht pro Schritt 1,8° die Steuerung kann jedoch keine Vollschritte sondern erst ab ½ Schritten arbeiten.

Somit benötige ich für eine Umdrehung 360/1,8 = 200 (Vollschritte) = 400 Halbschritte

1 Umdrehung = 400 Schritte

Das Signal ist ein TTL 5V Signal also ein Rechteck Signal. (wie im Bild)
Die Steuerung reagiert nur auf die Roten Flanken!.

Ich arbeite mit Mikrosekunde

RPM ist immer auf 1 Minute berechnet.
1 Min = 60 Sekunden
60 Sekunden = 1.000.000 Mikrosekunde

In meinem Code benötige ich immer die zeit zum wechseln der Flanke also das tp was 50% vom der Schrittzeit endspricht.

Werte ich die Bekomme zum Rechnen:

RPM = kommen per Serielle Schnittstelle
Schritte = kommen per Serielle Schnittstelle

Berechnungen:

1 Umdrehung = 200 Schritte = 400 tp

RPM * 400 tp = RPM_tp

RPM_tp = 1.000.000 Mikrosekunde
1 tp = (1tp * 1.000.000) / RPM_tp
RPM = 100

RPM_tp = 100 * 400 = 40.000

1.000.000 / 40.000
= 25 Mikrosekunde

Habe ich irgend wie einen Denkfehler?

Gruß Mücke

tp_Muecke.png
tp_Muecke.png

Ein Schrittmotor reagiert auf jede Änderung der Stromrichtung, aber das Treibermodul ändert seine Ausgangssignale immer nur bei einer Flanke.

Bei Halb- oder Mikrostepping kann der Motor gleichmäßiger laufen als bei ganzen Schritten, die Positionen können aber nicht immer richtig gehalten werden, und auch das Drehmoment wird geringer. Siehe Wikepedia...

So, ich habe mir die AccelStepper angeschaut, bisher bin ich sehr zufrieren, jetzt muss ich die gesamten Befehle noch heraus finden die ich benötige, für meinen Test habe ich mir ein Kleines Test Programm geschrien, und siehe an auch hier ist die Drehzahl zu niedrig, somit lag es nicht an meinen Schlecken Rechenkünsten sondern an etwas anderem, doch genau das muss ich nun raus finden an was es liegt, denn sonst stimmt später der gesamte Aufbau und die Berechnung nicht :slight_smile:

Eingestellt habe ich RPM 100 Heraus bekomme ich jedoch nur 74,8RPM. Woran kann das liegen?

Das andere ist, was ich noch nicht verstanden habe, wie kann ich AccelStepper sagen das mein Treiber mit 1/2 Schritten arbeitet?

Das ist mein Test Code:

#include <AccelStepper.h>
        // Definiere einen Stepper und die Stifte, die er verwenden wird
  AccelStepper mystepper(1, 51, 52); // (1, pinStep, pinDirection);
        // Unser Schrittmotor wird "mystepper" genannt.
        // Die erste Zahl steht für die Ansteuerung des Motors über einen Treiber mit takt-regelung
        // Die zweite Zahl ist die Pin Nummer für den "Schritt-Takt"
        // und die dritte Zahl die Pin Nummer für die Drehrichtung.

void setup()
{
        // Ändern Sie diese, um Ihrem Stepper zu entsprechen, wenn Sie wünschen
  mystepper.setMaxSpeed(500);         
        // Stellt die Höchstgeschwindigkeit ein. Die Voreinstellung ist sehr langsam, 
        // also muss diese konfiguriert werden. Wenn sie durch Einstellen der Position 
        // gesteuert wird, beschleunigt der Stepper, sich bei dieser Höchstgeschwindigkeit 
        // zu bewegen, und verlangsamt, wenn er das Ziel erreicht.
        
  mystepper.setAcceleration(200000000);   // Beschleunigung in Schritten pro Sekunde pro Sekunde.
  mystepper.moveTo(1600);                 // Bewegen den Motor auf eine absolute Position.
       // 400 Stepps endspricht einer Umdrehung
} // void setup

void loop()
{
   mystepper.run();
} // void loop

gruß Mücke

Zuerst fällt die seltsame Konstante bei setAcceleration() auf, was für ein Datentyp soll das sein? Bist Du sicher, daß Dein Stepper so eine irrwitzige Beschleunigung wirklich kann? Oder soll das die Anzahl Schritte sein, die der Motor ausführen soll?

Wenn der Controller Halbschritte macht, gibst Du einfach die doppelte Schrittzahl für eine volle Umdrehung an.

Aus Deinem Code geht nicht hervor, wie Du damit eine Drehzahl messen möchtest. Ich würde die maximale Steprate (setMaxSpeed) auf den gewünschten Wert setzen.

Bei einer kontinuierliche Bewegung dürfte es Probleme mit der Position geben, da gibt es sicher irgendwann einen Überlauf. Für so eine untypische Betriebsart ist die AccelStepper Bibliothek vermutlich nicht ausgelegt. Dafür würde ich eher tone() verwenden, oder einen Timer zur Erzeugung der richtigen Steprate benutzen, um das Step Signal zu erzeugen. Wenn diese Frequenz stimmt, dann bleibt als Fehlerquelle nur noch der Schrittmotor übrig, der Schritte verschlabbert. Vielleicht ist der zu langsam für die gewünschte Drehzahl?

der wert in setAcceleration ist die Beschleunigung die im Code hinterlegt ist.
der Wert ist bei mir so hoch das ich keine Anfahrt oder abfahrt Rampe bekomme, Der Motor liegt noch neben mir auf dem Tisch, also der Motor liegt da nicht ich ;-).

Angenommen die LIB würde eine Rampe fahren dann würde das die RPM ja verfälschen!

Wenn der Controller Halbschritte macht, gibst Du einfach die doppelte Schrittzahl für eine volle Umdrehung an.

Das ist mir schon klar, das mache ich auch. für die Richtige RPM muss die LIB aber doch auch wissen mit wie vielen schritten eine Umdrehung gemacht wird, denn wenn ich davon ausgehe das mein Motor mit 57 Schritten eine Umdrehung macht dann ist dich der Abstand zwischen jeder Flanke (TTL Signal) ein andere als wenn die LIB davon ausgeht das für eine Umdrehung 200 Schritte gemacht werden müssen. Daher die Frage wie und wo stelle ich das ein? mit wie vielen Schritten eine Umdrehung gemacht wird.?

Aus Deinem Code geht nicht hervor, wie Du damit eine Drehzahl messen möchtest. Ich würde die maximale Steprate (setMaxSpeed) auf den gewünschten Wert setzen.

Die Drehzahl messe ich nicht im Code, sondern direkt am Motor mit so einem Drehzahlmesser.

Bei einer kontinuierliche Bewegung dürfte es Probleme mit der Position geben, da gibt es sicher irgendwann einen Überlauf.

Da komme ich gerade nicht mit, der Motor macht 1600 Schritte wenn die gemacht sind bleibt der Motor stehen.

Abgearbeitet werden die mit dem Befehl
mystepper.run();

mit dem Befehl
mystepper.moveTo(1600);
sage ich das der Motor 1.600 Schritte machen soll, die werden von ...run() dann runter gezählt.

Dafür würde ich eher tone() verwenden

es sollen später mal 4 Motoren in eine CNC Anlage betrieben werden, jedoch stehe ich noch ganz am Anfang, und muss mich erst langsam heran arbeiten.

Da in der CNC Anlage später Berechnungen laufen, welcher Pfad gefahren wird, muss die Drehzahl stimmen, denn wenn das nicht der Fall ist, dann stimmt später das zusammen spiel der Motoren zum Pfad nicht. und ein Kreis wird nicht rund oder zu klein oder zu groß.

Hi Muecke,
Ist es in der Accelstepper nicht so, dass wenn Acceleration auf 0 gesetzt wird, der Motor ohne Rampe gefahren wird? Schau nochmals in die Doku der Lib. Ausserdem gibt es auch Funktionen, die die Rampen so oder so ausser acht lassen. steht auch in der Doku.

LG Stefan

Hallo Stefan,

Deltaflyer:
Ist es in der Accelstepper nicht so, dass wenn Acceleration auf 0 gesetzt wird, der Motor ohne Rampe gefahren wird?

Wo hast du das gelesen? hast du einen Link? denn ich habe das noch nicht gefunden.

Deltaflyer:
Schau nochmals in die Doku der Lib.

ich habe die Seite hier: www.airspayce.com
die finde ich etwas unpraktisch gemacht.

Deltaflyer:
Ausserdem gibt es auch Funktionen, die die Rampen so oder so ausser acht lassen. steht auch in der Doku.

Das kann gut sein, leider habe ich die noch nicht gefunden :frowning:
bin über Tipps immer dankbar :wink:

Aktuell versuche ich eine Script zu bauen das wie folgt arbeitet.

  1. Seriellen Monitor: CR
    dann Motor 1 von 3, 1600 Schritte machen

  2. Wenn der Motor 1 Schritte macht und Sensor 1 auslöst muss der Motor Stehen bleiben, und die noch Offenen Schritte sollen im Seriellen Monitor ausgegeben werden, um zu sehen wo er steht.

Wenn ich jedoch das Prog laufen lasse, dann nimmt er nur das erst mal die 1600 Schritte das zweite mal dann nicht mehr. :frowning: noch wies ich nicht warum. das bin ich noch am suchen.

das ist mein Test CODE:

#include <AccelStepper.h>
     int  Baudrate = 9600;          // Geschwindigkeit, Serielle Schnittstelle
     int  PUL_Y    = 51;            // Schritte
     int  DIR_Y    = 52;            // HIGH = Im Uhrzeigersinn          // LOW = Gegen den Uhrzeigersinn
     int  ENA_Y    = 53;            // LOW = Motor ON, MIT Haltemoment  // HIGH = Motor OFF, KEIN Haltemoment

  AccelStepper Achse_Y(1, PUL_Y, DIR_Y);     // (1, PUL, DIR);

void setup()
{
    Serial.begin(Baudrate);         // Seriellen Monitor Installiren
         pinMode(ENA_Y, OUTPUT);    // setzt den Pin als Output (kommunikation zum Motor)
    digitalWrite(ENA_Y, LOW);       // Freigabe setzen -> Der motor haelt ab jetzt seine Position
    Achse_Y.setAcceleration(20000); // Beschleunigung in Schritten pro Sekunde pro Sekunde.
} // void setup

void loop()
{
 if (Serial.read() == 13) {                                   // Wenn CR gedrckt wird wird ausgefrt
    Achse_Y.setMaxSpeed(500); // endspricht  87,5 rpm         // RPM sätzen
    Achse_Y.moveTo(1600);                                     // 400 Stepps endspricht einer Umdrehung

  }
   Achse_Y.run();
} // void loop

Gruß Mücke

[EDIT]
sind das alle Befehle die die LIB kennt?
AccelStepper Class Reference

Mit moveTo() läuft der Motor beim ersten Aufruf zur angegebenen Position, danach bleibt er dort, wenn er keine neue Position bekommt.

DrDiettrich:
Mit moveTo() läuft der Motor beim ersten Aufruf zur angegebenen Position, danach bleibt er dort, wenn er keine neue Position bekommt.

Genau das ist doch das was ich möchte.

beim CR Drücken soll der Motor 1600 Schritte laufen, das macht er auch.
wenn der Motor dann stehen geblieben ist, und ich dann noch mal CR Drücke läuft er nicht erneut 1600 Schritte :-(.

oder muss ich mir den Befehl so vorstellen? das die LIB ein Art Koordinaten System hat,
sprich Sie wies das die schon von 0 bis 1600 gelaufen ist und aktuell bei 1600 Steht, wenn ich dann 2000 angebe würde die LIB noch weitere 400 Schritte laufen?

Wenn der Motor bei 1600 Schritten stehen tut und ich 300 angebe dann läuft der Motor 1300 Schritte rückwärts?

Wenn das so ist dann habe ich den Befehl falsch verstanden, und muss weiter suchen.

gruß Mücke

[EDIT]

habe jetzt ein Test gemacht.
Nach jedem CR Rechne ich zu den bisherigen Schritten 200 Schritte dazu, sprich die Schritte werden Mehr. Und siehe an, es werden tatsächlich nur die Schritte die drauf gezählt wurden ausgeführt.

Das ist der Code meines Test.

  #include <AccelStepper.h>
     int  Baudrate = 9600;          // Geschwindigkeit, Serielle Schnittstelle
     int  PUL_Y    = 51;            // Schritte
     int  DIR_Y    = 52;            // HIGH = Im Uhrzeigersinn          // LOW = Gegen den Uhrzeigersinn
     int  ENA_Y    = 53;            // LOW = Motor ON, MIT Haltemoment  // HIGH = Motor OFF, KEIN Haltemoment
     int Steps     = 200;
     
  AccelStepper Achse_Y(1, PUL_Y, DIR_Y);     // (1, PUL, DIR);

void setup()
{
    Serial.begin(Baudrate);         // Seriellen Monitor Installiren
         pinMode(ENA_Y, OUTPUT);    // setzt den Pin als Output (kommunikation zum Motor)
    digitalWrite(ENA_Y, LOW);       // Freigabe setzen -> Der motor haelt ab jetzt seine Position
    Achse_Y.setAcceleration(20000); // Beschleunigung in Schritten pro Sekunde pro Sekunde.
} // void setup

void loop()
{
 if (Serial.read() == 13) {                                   // Wenn CR gedrckt wird wird ausgefrt
    Achse_Y.setMaxSpeed(500); // endspricht  87,5 rpm         // RPM sätzen
    
    Achse_Y.moveTo(Steps);                                        // 400 Stepps endspricht einer Umdrehung
    Steps = Steps + 100; 
  }
   Achse_Y.run();
} // void loop

Mein zweiter Test denn ich gemacht habe, ist das ich die Schritte so lasse wie sie bleiben nur das ich anstelle moveTo jetzt move verwende, und Siehe an, da werden tatsächlich die Schritte wider gemacht.

Das ist der Code dafür:

  #include <AccelStepper.h>
     int  Baudrate = 9600;          // Geschwindigkeit, Serielle Schnittstelle
     int  PUL_Y    = 51;            // Schritte
     int  DIR_Y    = 52;            // HIGH = Im Uhrzeigersinn          // LOW = Gegen den Uhrzeigersinn
     int  ENA_Y    = 53;            // LOW = Motor ON, MIT Haltemoment  // HIGH = Motor OFF, KEIN Haltemoment
     int Steps     = 200;
     
  AccelStepper Achse_Y(1, PUL_Y, DIR_Y);     // (1, PUL, DIR);

void setup()
{
    Serial.begin(Baudrate);         // Seriellen Monitor Installiren
         pinMode(ENA_Y, OUTPUT);    // setzt den Pin als Output (kommunikation zum Motor)
    digitalWrite(ENA_Y, LOW);       // Freigabe setzen -> Der motor haelt ab jetzt seine Position
    Achse_Y.setAcceleration(20000); // Beschleunigung in Schritten pro Sekunde pro Sekunde.
} // void setup

void loop()
{
 if (Serial.read() == 13) {                                   // Wenn CR gedrckt wird wird ausgefrt
    Achse_Y.setMaxSpeed(500); // endspricht  87,5 rpm         // RPM sätzen
    Achse_Y.move(Steps);                                        // 400 Stepps endspricht einer Umdrehung
  }
   Achse_Y.run();
} // void loop

Das ist der Unterschied zwischen move() und moveTo().