Schrittmotor 28BYJ48 am Arduino

Seit einiger Zeit werden bei Ebay kleine Getriebe-Schrittmotoren vom Typ 28BYJ48 mitsamt einem ULN2003 Treibermodul aus China für unter drei Euro angeboten. Ohne zusätzliche Versandkosten! Keine Ahnung, wie sich das rechnet. Das gleiche Paket aus Schrittmotor und Treibermodul gibt es aber auch bei inländischen Anbietern für unter fünf Euro. (Zum Beispiel hier über Amazon).

28BYJ48, ULN2003, Arduino

28BYJ48, ULN2003, Arduino

Getriebe Übersetzung

Diese keinen Schrittmotoren werden offenbar eigentlich eingesetzt, um Steuerungsklappen in Klimaanlagen hin und her zu bewegen. Den Herstellern war es also egal, welche Übersetzung das Getriebe ganz genau hat. Zumindest bei meinem Modell stimmt die angegebene Übersetzung von 1:64 nicht genau. Es hat ebenfalls die hier berechnete Übersetzung von 1:63,68395. Das bedeutet, dass nicht 4096 Steps pro Umdrehung nötig sind, sondern nur 4075,772… Steps. Für viele Anwendungen ist das wohl egal, aber wenn der Motor fortlaufend in eine Richtung drehen soll (z.B. als Sekundenzeiger einer Uhr), muss dieser Umstand berücksichtigt werden.

Anschluss an den Arduino

ULN2003

ULN2003

Ich habe hier die digitalen Pins 8, 9, 10,11 des Arduino zum Anschluss des Motor-Treibers verwendet. Für die ersten Versuche reichte die Versorgung aus dem USB-Port. Für ernstzunehmende Anwendungen ist natürlich eine externe Quelle nötig.

Der Jumper auf dem Schrittmotor-Treiber (rechts neben dem VCC-Pin) muss gesteckt bleiben. Wenn ich es richtig verstehe, dann kann man durch entfernen dieses Jumpers die Stromversorgung zum Motor unterbrechen.

Betrieb am Arduino

Ich habe gar nicht versucht die Arduino Stepper-Library zu verwenden. Offenbar gab (gibt?) es mit der bei diesem Motor Probleme. Außerdem wollte ich genauer verstehen, wie man mit so einem Schrittmotor umgeht.Prinzipiell habe ich bei meinen Versuchen auf die Lösung von Benutzer celem im Arduino Forum aufgebaut.

Laut Datenblatt soll der Motor in folgender Sequenz angesteuert werden:

In 1 In 2 In 3 In 4
0 0 0 1
0 0 1 1
0 0 1 0
0 1 1 0
0 1 0 0
1 1 0 0
1 0 0 0
1 0 0 1

Ein einfacher Sketch zum Testen sieht zum Beispiel so aus:

const int motorPin1 = 8;  // Blue   - In 1
const int motorPin2 = 9;  // Pink   - In 2
const int motorPin3 = 10; // Yellow - In 3
const int motorPin4 = 11; // Orange - In 4
                          // Red    - pin 5 (VCC)

unsigned int lowSpeed  = 10000; // Notabene: nicht über 16000
unsigned int highSpeed =  1000;

void setup() {
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop()
{ unsigned long n = millis() / 3000; // 3 Sekunden

  switch(n % 8)
  { case 0: stop();               break;
    case 1: rechtsrum(lowSpeed);  break;
    case 2: stop();               break;
    case 3: linksrum(lowSpeed);   break;
    case 4: stop();               break;
    case 5: rechtsrum(highSpeed); break;
    case 6: stop();               break;
    case 7: linksrum(highSpeed);  break;
  }
}

void rechtsrum(unsigned int motorSpeed)
{ // 1
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 2
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 3
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 4
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 5
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delayMicroseconds(motorSpeed);

  // 6
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);

  // 7
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);

  // 8
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delayMicroseconds(motorSpeed);
}

void linksrum(unsigned int motorSpeed)
{ // 1
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delayMicroseconds(motorSpeed);

  // 2
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delayMicroseconds(motorSpeed);

  // 3
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delayMicroseconds(motorSpeed);

  // 4
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delayMicroseconds(motorSpeed);

  // 5
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delayMicroseconds(motorSpeed);

  // 6
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
  delayMicroseconds(motorSpeed);

  // 7
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delayMicroseconds(motorSpeed);

  // 8
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delayMicroseconds(motorSpeed);
}

void stop()
{ digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
}

Werbung:

Weblinks:


22 comments to Schrittmotor 28BYJ48 am Arduino

  • Hallo Stefan, Deine Definition der Sequenz als Array macht die Sache viel übersichtlicher. Ich hatte auch schon daran gedacht, die Sequenz gleich als Bitmuster abzulegen und in einem Schritt an den Ausgang zu übertragen. Da muss man aber sehr aufpassen, dass man nicht an Pin 0 und 1 herum fummelt, weil die für die serielle Kommunikation zuständig sind.

    Inzwischen habe ich meinen Motor zu einer Äquatoriale Montierung verarbeitet. Da hat er schwer zu arbeiten und bleibt bei ungünstiger Lage auch mal stehen. Werde mir wohl mal einen stärkeren Motor anschaffen müssen.

    • Gunther

      Hallo Heiner,
      super Beschreibung! Hat mir sehr geholfen.Vielen Dank dafür!
      Hier meine Kurzversion eines Testprogs mit Assembler :-)
      /* Schrittmotor Anschluss:
      * IN1 an Pin 0
      * IN2 an Pin 1
      * IN3 an Pin 2
      * IN4 an Pin 3
      * Servomotor läuft vorwärts
      */

      void setup()
      {
      DDRD=255;//Alle Pins des PORTD(Pin 0-7 des Arduinos) werden Ausgang
      PORTD=0;// Pin 0-7 werden auf Null gesetzt

      }

      void loop()
      {

      PORTD=1;// Ansteuerung des Motors, Schritt 1,2,3 usw.
      delay(2);
      PORTD=3;
      delay(2);
      PORTD=2;
      delay(2);
      PORTD=6;
      delay(2);
      PORTD=4;
      delay(2);
      PORTD=12;
      delay(2);
      PORTD=8;
      delay(2);
      PORTD=9;
      delay(2);

      }

  • Stefan

    hallo heiner,

    hier noch eine überarbeitete Version, bei welcher die Auflösung noch viel höher ist, da man die einzelnen “Schritte” ansteuern kann.

    Ich werde als nächstes einen Bipolar Schrittmotor mit einem L293D ansteuern und noch eine programmierte Stromabsenkung einabuen. Du kannst den Code oben löschen, da er noch Fehler enthält…

    Hast Du Bilder von deinem Projekt?

    Mfg

    Stefan

    //Schrittmotorsteuerung für 28BYJ-48 5VDC mit ULN2003A

    #define NrOfMotorOutputs 4 //Anzahl der Ausgänge zur Ansteuerung des Motors
    #define NrOfPatternsOneStep 8 //Anzahl der Muster zur Ansteuerung eines Schritts

    //Variabeln für Drehrichtung definieren
    const byte MotorOff = 0;
    const byte DirMotorRight = 1;
    const byte DirMotorLeft = 2;

    unsigned int ActStepNr = 0; //Aktueller Schritt

    //Schrittmuster definieren
    byte StepPattern[NrOfPatternsOneStep][NrOfMotorOutputs] =
    {
    { 0, 0, 0, 1 },
    { 0, 0, 1, 1 },
    { 0, 0, 1, 0 },
    { 0, 1, 1, 0 },
    { 0, 1, 0, 0 },
    { 1, 1, 0, 0 },
    { 1, 0, 0, 0 },
    { 1, 0, 0, 1 },
    } ;

    //Motor Pins für Ausgänge 1-4 definieren
    byte MotorOutputPin[NrOfMotorOutputs] = {10,11,12,13};

    void setup()
    {
    //Alle Pins als Ausgänge setzen und auf LOW schalten
    for (byte i=0; i < NrOfMotorOutputs; i++)
    {
    pinMode((MotorOutputPin[i]), OUTPUT);
    digitalWrite(MotorOutputPin[i], LOW);
    }
    }

    // the loop routine runs over and over again forever:

    void loop()
    {

    //Beispielprogramm zur Ansteuerung
    MotorMove(DirMotorRight,1, 2048); // MotorMove(Drehrichtung, MotorSpeed, Anzahl Schritte)
    delay(1000);
    MotorMove(DirMotorLeft,1, 2084);
    MotorMove(MotorOff,0, 0); //Motor stromlos Pin 1-4 = LOW
    delay(1000);

    }

    /////////////// Funktion für Motoransteuerung Anfang //////////////////
    void MotorMove(byte MotorDir, unsigned int MotorSpeed, unsigned int StepsToGo)
    {

    //Motor Stop alle Ausgänge auf LOW schalten
    if (MotorDir == MotorOff)
    {
    for (byte i=0; i < NrOfMotorOutputs; i++)
    {
    digitalWrite(MotorOutputPin[i], LOW);
    }
    }

    //Motor Rechtsdrehung
    else if (MotorDir == DirMotorRight)
    {
    for (int i=0; i < StepsToGo; i++)
    {
    ActStepNr++;
    if (ActStepNr == NrOfPatternsOneStep) ActStepNr = 0;
    for (byte j=0; j < NrOfMotorOutputs; j++)
    {
    digitalWrite(MotorOutputPin[j], StepPattern[ActStepNr][j]);
    }
    delay(MotorSpeed); //Verweilzeit um die Geschwindigkeit zu beeinflussen, für schnellere Ansteuereung ev. delayMicroseconds
    }
    }

    //Motor Linksdrehung
    else if (MotorDir == DirMotorLeft)
    {
    for (int i=0; i < StepsToGo; i++)
    {
    if (ActStepNr == 0) ActStepNr = NrOfPatternsOneStep-1;
    else ActStepNr–;
    for (byte j=0; j < NrOfMotorOutputs; j++)
    {
    digitalWrite(MotorOutputPin[j], StepPattern[ActStepNr][j]);
    }
    delay(MotorSpeed);
    }
    }
    }
    /////////////// Funktion für Motoransteuerung Ende //////////////////

  • John

    Geil,
    endlich läuft mein Motor vorwärts und rückwärts.
    Laut dieser Information ” http://rn-wissen.de/wiki/index.php/Schrittmotoren ” kann der Motor keine Halbschritte.
    Hab nen ganzen Tag zugebracht wegen einem Motor für 1,34€ aus China.
    ich beabsichtige ein Thermometer mit analoger Anzeige zu bauen.
    Bin Rentner und hab den ganzen Tag Zeit.

  • Rico

    Hallo Heiner

    Ich habe direkt mal Stefans Code ausprobiert und er läuft. Als Spannungsversorgung habe ich eine 9V Blockbatterie angeschlossen. Irgendwie hab ich mir den Motor aber etwas kraftvoller vorgestellt. Ist er wirklich gerade mal ausreichend um etwa einen kleinen Zeiger zu bewegen oder habe ich etwas falsch angeschlossen?

  • Andreas

    Hallo.

    Ein super Beitrag. Der Code ist klasse, funktioniert super. Vielen Dank!

  • Martin

    Danke an Alle,

    hat mir viel Zeit erspart! Habe den Motor von Pollin. Mit Platine S-SPSM-5V. Der macht 4096 Schritte pro U. Ich kann mit
    delayMicroseconds(MotorSpeed); bis 850 runter, schneller mag er nicht, und dann bleibt machmal hängen. Mit 900 ist er recht Stabil.
    Bei Stefan’s Code ist fast am Ende ein kleiner Fehler:
    else ActStepNr–; ich habe es in ActStepNr-=1; geändert. Dann läuft es.
    Der Motor ist nicht sehr stark, kommt auch davon das er durchdreht, wenn zu viel Last dran hängt.

  • Hier kurz ein Hinweis auf ein Projekt von Vulcaman bei instructables.com. Er hat es tatsächlich geschafft mit vier 28byj-48 Steppermotoren einen funktionierenden 3D-Drucker zu bauen. Die Gesamtkosten beliefen sich auf ca. 60 Euro.
    Hier der Link: Cherry- 60€ 3D-Printer

  • Cyp

    Hallo,
    habe so einen Motor geöffnet und die Zähnezahlen des Getriebes abgezählt. Der Motor selbst hat 64 Steps/Rev, das Getriebe hat ein Untersetzungsverhältnis von 8910 : 567424 = 63,68395062.. Dadurch kommt der Motor insgesamt auf 4075,7728395 Schritte je Umdrehung und nicht wie öfters behauptet 4096.

  • Maxi

    Danke, du hast mir endlich einfach aber genau erklärt wie ich meinen Stepper verwenden muss #anfänger

  • Tom

    Hallo noch eine Sache im Code ist ein Zahlendreher
    ungefähr Zeile 45 einmal hast du 2048 und anders rum dann 2084 geschrieben
    dreht sich bei mir auch nur in eine Richtung
    mal schauen wo noch ein Fehler ist

    • Ich habe den Code von Stefan nicht noch mal ausprobiert, aber ich denke das müsste trotz dieses Zahlendrehers funktionieren. Die 2048 beziehen sich soweit ich es sehe auf die Anzahl Steps. Für diesen Test ist es aber eher unerheblich, ob der Motor 2048 oder 2084 Steps dreht.

  • Sven

    Hallo,
    vielen Dank für die super Beschreibung!
    Ich habe eine andere Frage: der Motor dreht sich ja relativ “langsam”. Falls ich einen schnelleren brauche, zum Beispiel um ein kleines Auto oder sonstiges anzutreiben, welche Art Motor würde sich hierfür anbieten?

    Vielen Dank und viele Grüße
    Sven

    • Wenn die maximale Geschwindigkeit von Schrittmotoren nicht ausreicht würde ich einen stärkeren Motor mit einer passenden Übersetzung/Getriebe wählen.
      Für Autos etc. sind aber vermutlich normale Elektromotoren (falls nötig kombiniert mit einem Encoder) besser geeignet.

  • Helmut

    Hallo, Leute,
    was mache ich denn falsch???
    Als ahnungsloser Anfänger habe ich JEDEN der oben angegebenen Codes direkt kopiert und eingegeben, und JEDES MAL FOLGT EINE FEHLERMELDUNG – ist doch zum Verzweifeln!!!
    Was kann ich denn mit solchen Fehlermeldungen anfangen??
    StepMotor_28BYJ_48.ino:87:1: error: stray ‘\’ in program
    StepMotor_28BYJ_48.ino: In function ‘void MotorMove(byte, unsigned int, unsigned int)’:
    StepMotor_28BYJ_48.ino:69:19: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    StepMotor_28BYJ_48.ino:84:19: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    StepMotor_28BYJ_48.ino:87:16: error: expected ‘;’ before ‘u2013’
    StepMotor_28BYJ_48.ino:87:21: warning: statement has no effect [-Wunused-value]

    Sowas lese ich dann .. wieso schreiben so Viele hier, dass der code funktioniert, und bei mir ist Alles falsch??
    Kann mit jemand helfen / brauchbare Tipps geben?
    Grüße
    Helmut

  • Ich vermute, dass Du Copy/Paste verwendet hast. Da in den Sourcen nirgends ein Backslash (\) auftaucht gehe ich mal davon aus, dass beim Kopieren irgendwo automatisch einer eingefügt wurde. Das passiert, wenn eine Zeile zu lang war und getrennt werden musste. Abhilfe: einfach die beiden Zeilen wieder zusammen führen (dabei den Backshlash löschen).

  • eve

    Hallo Heiner,

    ich bin ziemlicher Arduino-Anfänger und habe keine Ahnung von Elektrotechnik. Mit Hilfe Deiner Beschreibung hier habe ich es aber trotzdem geschafft in kurzer Zeit meinen Schrittmotor am Arduino zum Laufen zu bringen. Dafür einfach mal ein dickes DANKE!

    Ich habe natürlich auch gleich etwas mit dem Sketch rumgespielt und dabei festgestellt, dass highSpeed = 1000 wohl schon ziemlich die Grenze ist. Setzte ich den Wert noch weiter runter, dann geht es vielleicht einmal, aber danach dreht sich der Motor nicht mehr wenn er das Signal für highSpeed bekommt. Woran erkennt man, was denn die Grenzen der möglichen Geschwindigkeit sind?

    Viele Grüße
    eve

  • Jens

    Hallo zusammen,

    vielen Dank für die Erklärung. Lief alles sofort.
    Darf ich mal fragen, was der Motor bei euch an Strom zieht?
    Bei mir sind es mit 5VDC ca. 195mA während der Drehung und 280mA wenn dieser steht. Warum ist das so viel?

  • posti

    Hi

    Habe heute auch den ganzen Tag mit einem Arduino und zwei dieser Motoren verbracht.
    Ob meine Getriebeübersetzung auch so ’schräg’ ist, müsste ich Mal antesten – geplant ist ein Endlos-Antrieb eines Planeten-Getriebes, wo es schon ’schön’ wäre, wenn beide Motoren auch nach zig Umdrehungen wieder auf Null ‘einrasten’.

    Wenn Wer will, hier mein Code (bestenfalls Beta)
    ***********************************

    //timer interrupts
    //by Amanda Ghassaei
    //June 2012
    //https://www.instructables.com/id/Arduino-Timer-Interrupts/

    /*
    * This program is free software; you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation; either version 3 of the License, or
    * (at your option) any later version.
    *
    */

    //timer setup for timer0, timer1, and timer2.
    //For arduino uno or any board with ATMEL 328/168.. diecimila, duemilanove, lilypad, nano, mini…

    //this code will enable all three arduino timer interrupts.
    //timer0 will interrupt at 2kHz
    //timer1 will interrupt at 1Hz
    //timer2 will interrupt at 8kHz

    //storage variables
    static long lowest=1000; //Mindestwartezeit (in µs) bis zum nächsten Schritt, bis 700 kaum Hänger
    boolean toggle0 = 0; //für LED an Pin13
    int StepPinA1=6;
    int StepPinA2=7;
    int StepPinA3=8;
    int StepPinA4=9;

    int StepPinB1=2;
    int StepPinB2=3;
    int StepPinB3=4;
    int StepPinB4=5;

    int schrittA=0; //aktueller Schrittwert
    long SchritteA=-4096; //Schritte zu fahren
    int unendlichA=1; //Richtung für Unendlich-Fahrt 1 oder -1
    unsigned long WartezeitA=1000; //alle x µs (bei 2kHz wird alls 500µs INT generiert)
    unsigned long lasttimeA;//=millis(); //wann wurde der letzte Schritt gemacht? (unsigned)

    int schrittB=0; //aktueller Schrittwert
    long SchritteB=12311; //Schritte zu fahren
    int unendlichB=-1; //Richtung für Unendlich-Fahrt 1 oder -1
    unsigned long WartezeitB=25000; //alle x µs (bei 2kHz wird alls 500µs INT generiert)
    unsigned long lasttimeB;//=millis(); //wann wurde der letzte Schritt gemacht? (unsigned)

    unsigned long temp=0; //temporäre Variable
    unsigned int target=0; //aktueller Motor (für Den Daten übergeben werden)

    void setup(){
    Serial.begin(9600); // Used to type in characters
    Serial.println(“Hidiho”);
    //set pins as outputs
    pinMode(8, OUTPUT);
    pinMode(13, OUTPUT);
    pinMode(StepPinA1, OUTPUT);
    pinMode(StepPinA2, OUTPUT);
    pinMode(StepPinA3, OUTPUT);
    pinMode(StepPinA4, OUTPUT);

    pinMode(StepPinB1, OUTPUT);
    pinMode(StepPinB2, OUTPUT);
    pinMode(StepPinB3, OUTPUT);
    pinMode(StepPinB4, OUTPUT);

    cli();//stop interrupts

    /*
    //set timer0 interrupt at 2kHz
    TCCR0A = 0;// set entire TCCR2A register to 0
    TCCR0B = 0;// same for TCCR2B
    TCNT0 = 0;//initialize counter value to 0
    // set compare match register for 2khz increments
    OCR0A = 124;// = (16*10^6) / (2000*64) – 1 (must be <256)
    // turn on CTC mode
    TCCR0A |= (1 << WGM01);
    // Set CS01 and CS00 bits for 64 prescaler
    TCCR0B |= (1 << CS01) | (1 << CS00);
    // enable timer compare interrupt
    TIMSK0 |= (1 << OCIE0A);
    */

    //set timer2 interrupt at 8kHz
    TCCR2A = 0;// set entire TCCR2A register to 0
    TCCR2B = 0;// same for TCCR2B
    TCNT2 = 0;//initialize counter value to 0
    // set compare match register for 8khz increments
    // OCR2A = 249;// = (16*10^6) / (8000*8) – 1 (must be <256)
    OCR2A = 124;// = (16*10^6) / (16000*8) – 1 (must be <256)
    // turn on CTC mode
    TCCR2A |= (1 << WGM21);
    // Set CS21 bit for 8 prescaler, CS20bit for 1 prescaler
    // TCCR2B |= (1 << CS21);
    TCCR2B |= (1 << CS21);
    // enable timer compare interrupt
    TIMSK2 |= (1 < WartezeitA)
    {
    //Wartezeit ist vergangen, wir machen einen Schritt
    lasttimeA=lasttimeA+WartezeitA;
    /*
    if (WartezeitA>lowest)
    {
    WartezeitA=WartezeitA-1;
    if (WartezeitA%100==0)
    {
    Serial.println(WartezeitA);
    }
    }
    */
    if (SchritteA>0 || (SchritteA==0 && unendlichA>0))
    {
    //wenn Schritt>0 angegeben sind oder keine Schritte, aber Unendlich >0 ist
    schrittA=schrittA+1;
    if (schrittA==8)
    { schrittA=0;
    }

    if (SchritteA>0)
    {
    SchritteA-=1;
    }
    }else if (SchritteA<0 || (SchritteA==0 && unendlichA<0)) {
    //wenn Schritt<0 angegeben sind oder keine Schritte, aber Unendlich <0 ist
    schrittA=schrittA-1;
    if (schrittA<0)
    {
    schrittA=7;
    }
    if (SchritteA WartezeitB)
    {
    //Wartezeit ist vergangen, wir machen einen Schritt
    lasttimeB=lasttimeB+WartezeitB;
    /*
    if (WartezeitB>lowest)
    {
    WartezeitB=WartezeitB-1;
    if (WartezeitB%100==0)
    {
    Serial.println(WartezeitB);
    }
    }
    */
    if (SchritteB>0 || (SchritteB==0 && unendlichB>0))
    {
    //wenn Schritt>0 angegeben sind oder keine Schritte, aber Unendlich >0 ist
    schrittB=schrittB+1;
    if (schrittB==8)
    { schrittB=0;
    }
    if (SchritteB>0)
    {
    SchritteB-=1;
    }

    }else if (SchritteB<0 || (SchritteB==0 && unendlichB<0)) {
    //wenn Schritt<0 angegeben sind oder keine Schritte, aber Unendlich <0 ist
    schrittB=schrittB-1;
    if (schrittB<0)
    {
    schrittB=7;
    }
    if (SchritteB Target 1, -100 Schritte (CCW), kein Endloslauf”);
    Serial.println(“0T300S50000G1-E –> Target 0, 100 Schritte CW, Wartezeit 50000us, Endloslauf CCW”);
    Serial.print(“TGSE –> Target =0, Geschwindigkeit=0 (->”);
    Serial.print (lowest);
    Serial.println(“), Schritte=0, Endlos=0″);
    Serial.print(“Aktuelles Target:”);
    Serial.println(target);
    Serial.print(“Aktueller Wert:”);
    Serial.println(temp);

    break;
    }
    }

    }

    /*
    Seriel Aufgaben übergeben
    S -1000 Schritte 1000 links (0 rechts, werden runtergezählt)
    E -1 Endlos links (-1 0 1)
    M 1 Motor 1 (0 … x)
    G 900 Geschwindigkeit 900 µs zwischen Steps (>=lowerst)
    R 10 RPM (wird in G umgerechnet)
    ? 0 Gebe Werte von Motor 0 aus
    V 0 Vollschritt AUS (0=Halbschritt), 1=Vollschritt eine aktive Phase (2-4-6-8), 2=Vollschritt zwei aktive Phasen (1-3-5-7)

    M0S100 -> Motor 0 macht 100 Schritte in aktueller Geschwindigkeit
    */
    ***********************************

    Die zwei Stepper sind an 3-4-5-6 und 7-8-9-10 angeschlossen.
    Beide Stepper können per Seriellem-Terminal (bei mir unter Linux minicom) Befehle erteilt werden.
    Vollschritt und ‘Umdrehungen per Minute’ werden noch nicht unterstützt und auch sonst ist der Code recht … äh … irgendwie entstanden, funktioniert aber irgendwie :)

    Die Eingabe im Terminal ist sehr gewöhnungsbedürftig, da man
    - zuerst den Wert eingeben muß (0…9)
    - für negative Werte JETZT ein -
    - das Ziel für den Wert, z.B. ‘G’ für die Geschwindigkeit oder S für die Schritte
    Auch ist eine Endlosfahrt möglich, mit 1-E geht’s, wenn keine Schritte mehr abzuarbeiten sind, für ‘Immer und Ewig’ in Richtung CCW.

    Das ist das erste wirkliche Arduino-Projekt, zuvor habe ich die Kommunikation eines Arduino zu einem I2C-Display mitgeschnitten, um Dieses per Assembler anzusteuern.

    Schauen wir Mal, man soll ja auch Arduino-Programme auf entsprechend große AVR brennen können – Da will ich hin :) .

    Nun noch viel Spaß mit meinem Konstrukt.

    MfG
    posti

  • posti

    Hi

    Sorry, oben ist mir der Fehler unterlaufen, daß die Stepper an anderen Pins angeschlossen sind – steht ja auch so im Code, sind also 2-3-4-5 und 6-7-8-9.
    Weiter ist die Formatierung etwas abhanden gekommen, sollte der Funktion zwar nicht schaden, der Übersicht aber wohl schon – ‘tschuldigung dafür.

    Auch verwende ich im Terminal NICHT M für den anzusteuernden Motor, sondern T für ‘Target’.

    Angedacht ist weiter, die ‘Motordaten’ in ein Array einzupacken und so ‘beliebig viele Motoren’ parallel ansteuern zu können – wenn’s die Pin-Anzahl des µC zulässt.

    MfG²
    posti

Leave a Reply

 

 

 

You can use these HTML tags

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>