Stepper 28BYJ-48 5V nur mit Arduino und Poti steuern

Hallo,
ich bin Anfänger und ärgere mich immer, wenn ich Zubehör brauche, dass ich gerade nicht zur Hand habe. Nun ist es mir gelungen ein kleines Programm für den oben genannter Steppermotor zu schreiben, den ich direkt an den Arduino anschließen kann. Auch das Poti könnte man, um zu sehen ob der Motor sich dreht, durch eine while-Schleife ersetzen. Ich habe nicht einmal ein externes Netzteil benötigt, da ich den Plus-Pol des Motors gar nicht anschließen muss. Vielleicht nützt es ja jemandem, der so wie ich, seine ersten Schritte macht 8). Im übrigen dreht der Motor, da Getriebeübersetzt, recht langsam. Also genau hinsehen, wenn das Poti nahe der Mitte steht.

//Demoprogramm für Stepper 28BYJ-48 5V DC

//Motorpin- Variablen
int motorPin1 = 8; // Blau   - 28BYJ48 pin 1
int motorPin2 = 9; // Pink oder Orange   - 28BYJ48 pin 2
int motorPin3 = 10; // Yellow - 28BYJ48 pin 3
int motorPin4 = 11; // Orange - 28BYJ48 pin 4
                    // Rot    - 28BYJ48 pin 5 (VCC) muss hier nicht angeschlossen werden. 

int LEDpin = 13; //Eingebaute Leuchtdiode auf dem Arduino soll leuchten, wenn der Motor steht

int motorSpeed = 0;     //Drehgeschwindigkeit
int potPin = A0; //Mittenabgriff eines Potis. Damit steuern man Drehrichtung und -Geschwindigkeit
int potValue = 0; //Variable um den Wert vom Eingang A0 zu speichern


//////////////////////////////////////////////////////////////////////////////
void setup() {
  //Alle Motorpins sind Ausgänge
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
  pinMode(LEDpin, OUTPUT); //LED auf dem Arduino
//  Serial.begin(9600);
}

//////////////////////////////////////////////////////////////////////////////
void loop(){

  potValue = analogRead(A0);     // Spannung am Poti umgerechnet auf Werte zwischen 1023 = ~5V und 0 = ~0V 
//  Serial.print("\nA0: "); Serial.print(potValue); Serial.print("\t\tmotorspeed: "); Serial.print(motorSpeed);   // \n = neue Zeile, \t = Tabulator
  if (potValue < 510){               // Falls Potiwert kleiner 510
    motorSpeed = (potValue/15+2);  //Das ist die Pause zwischen jedem Schritt. Kleiner 2 verkraftet der Motor nicht. Größer 35 ist quasi Stillstand
    clockwise();                     //drehen im Uhrzeigersinn
  }
  if(potValue > 560){                             //wenn der Wert größer als 560 ist
    motorSpeed = ((1024-potValue)/15+2); //wie oben, nur unter Berücksichtigung, dass die Werte jetzt größer 534 sind
    counterclockwise(); //drehen gegen den Uhrzeigersinn
  }
  //zwischen 510 und 560 steht der Motor
  if(potValue >509 && potValue <561){digitalWrite(LEDpin, HIGH);} //Als Kontrolle sollte die Staus-LED auf dem Arduinoboard angehen.
  else{digitalWrite(LEDpin, LOW);}
}

//////////////////////////////////////////////////////////////////////////////

void counterclockwise (){
  // 1      Durch das Umpolen der Spulen bewegt sich der Motor
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(motorSpeed); //Pause. Mindestens so lang das der Motor seinen Schritt beenden kann. Ggf. oben +2 in potValue/15+2  durch einen höheren Wert für beide Drehrichtungen ersetzen. Längere Pausen = langsamere Drehung
  // 2
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay (motorSpeed);
  // 3
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(motorSpeed);
  // 4
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(motorSpeed);
  // 5
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(motorSpeed);
  // 6
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
  delay (motorSpeed);
  // 7
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(motorSpeed);
  // 8
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(motorSpeed);
}

//////////////////////////////////////////////////////////////////////////////
// Das Gleiche wie oben nur mit entgegengesetzter Drehung. Die Spulen werden in umgekehrter Reihenfolge auf HIGH und LOW gesetzt
void clockwise(){
  // 1
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delay(motorSpeed);
  // 2
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delay (motorSpeed);
  // 3
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delay(motorSpeed);
  // 4
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delay(motorSpeed);
  // 5
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delay(motorSpeed);
  // 6
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, HIGH);
  delay (motorSpeed);
  // 7
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delay(motorSpeed);
  // 8
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delay(motorSpeed);
}

Einen Schrittmotor direkt an den digitalen Ausgängen eines Arduinos zu betreiben ist keine gute Idee. Du wärst nicht der erste, dessen Mikrocontroller Rauchzeichen gibt. ;)

Du abverlangst von jedem Pin zwischen 100mA und 200mA, was weit über der Spezifikation ist und läßt dann auch noch die Schutzdioden für die Gegeninduktionsspannung weg. Sowit zur Gefährdung des Arduino. Dann noch zu Funktion. Du kannst keine Unipolarmotor mit 5 Anschüssen mittels H-Brücke ansteuern. Das funktioniert nicht richtig. Der Motor dreht nicht richtig rund.

Es gibt schon Gründe wieso die ganze Welt Treiber zur Ansteuerung von Schrittmotoren nimmt. Du brauchst einen ULN2803 oder 4 NPN Transistoren. Das sind Standartteile die man zuhause haben sollte.

Vielleicht nützt es ja jemandem, der so wie ich, seine ersten Schritte macht smiley-cool.

Das nutzt eigentlich nur den Arduino-Verkäufern und Produzenten.

Grüße Uwe

Na gut, vielleicht ist die Idee nicht wirklich gut. Aber andererseits hat mein Board nicht geraucht, der Motor hat sauber gedreht und ich habe das Prinzip verstanden. Aber danke für die Hinweise, die werden Anderen und auch mir sicher nützlich sein.

hi,

schau' nicht so traurig, hannes, jeder beitrag hier ist wichtig. man lernt daraus und ist froh, daß der arduino noch lebt...

gruß stefan

Er dreht sich vielleicht. Aber ob der sein richtiges Drehmoment hat ist was anderes.

Du hast einen Motor bei dem die Mittelanzapfung für beiden Spulen zusammengeführt ist. Den kann man nur unipolar ansteuern, da die zwei Spulen nicht voneinander isoliert sind!

Siehe hier: http://www.rn-wissen.de/index.php/Schrittmotoren#Motoren_mit_5_Anschl.C3.BCssen.3F

Wobei die Mittelanzapfung bei der Ansteuerung mit einem ULN oder Einzel-Transistoren auf Plus muss, da das ein Open Collector Treiber ist, der gegen Masse schaltet!

Deine Sequenz glaube ich auch nicht richtig ist. Hier ist der gleiche Motor mal mit einem Rasperry Pi: http://winkleink.blogspot.de/2013/04/raspberry-pi-unipolar-stepper-motors.html

Oder du bist da in irgendeinem Halbschritt Betrieb.

Hallo Stefan "Eisenbaer" Danke für deine aufmunternden Worte! "Es besteht die Gefahr, dass man aufgrund der Masse der Informationen zunehmend schlechter informiert ist" hat mal jemand gesagt und ich kann das nur unterstreichen. Manchmal sieht man den Wald vor lauter Bäumen nicht mehr und ich habe sogar übersehen, dass ich einen UL2803-Chip besitze :roll_eyes:. @Serenifly Ich finde es gut, dass sich die Leute hier um die Probleme anderer kümmern und ich bin dankbar für jede Antwort, auch wenn manches böhmische Dörfer bleiben. Du schreibst beispielsweise: "Den kann man nur unipolar ansteuern, da die zwei Spulen nicht voneinander isoliert sind! .... Wobei die Mittelanzapfung bei der Ansteuerung mit einem ULN oder Einzel-Transistoren auf Plus muss, da das ein Open Collector Treiber ist, der gegen Masse schaltet!" Ich Frage hier als Anfänger weil ich hoffe das mir Profis helfen, was Du sicher auch bist. Aber versuch doch mal auch so zu antworten, dass es ein Anfänger versteht. Versteh es bitte nicht falsch, aber deine Antwort dürfte gerne etwas "laienhafter" sein. Ich frage hier, weil ich des ständigen googelns überdrüssig bin. Um deine Antwort zu verstehen google ich nun schon wieder. Im übrigen hast Du wohl recht, dass ich mich hier in einem Halbschrittmodus befinde. Schöne Grüße Hannes

Scroll hier mal etwas runter zu den Bildern mit den verschiedenen Spulenanschlüssen: http://www.rn-wissen.de/index.php/Schrittmotoren#Schrittmotoransteuerung

Es geht dabei um den Unterschied von bipolaren und unipolaren Motoren. Du hast den Motor eher bipolar angesteuert. Also die Stromrichtung umgekehrt. Dazu braucht man aber entweder einen Motor mit 4 Anschlüssen - die sind nur bipolar - oder 6, bzw. 8 Anschlüsse. Letzere kann man dann bipolar und unipolar ansteuern, je nachdem was man mit der Mittelanzapfung macht.

Unipolar heißt, dass man die Mittelanzapfung an Plus oder Masse legt (Plus beim ULN) und je nachdem was dann an den Enden der Spulen anliegt fließt mal Strom in die eine oder andere Richtung. Das ist von der Ansteuerung her einfacher, aber da immer nur die Hälfte der Spule unter Strom steht, haben die Motoren auch weniger Kraft.

Nimm einfach das obere, mittlere Bild: http://www.rn-wissen.de/index.php/Bild:Schrittmotorprinzip3.gif

Denk dir den Mittleren Anschluss an Plus. Und die anderen Anschlüsse der jeweiligen Spule an Plus/Masse oder Masse/Plus. Und dann visualisiere wie der Strom fließt.

Hier ist das Datenblatt des Motors: http://robocraft.ru/files/datasheet/28BYJ-48.pdf Laut dem gehören Anschlüsse 1+3 zu einer Spule und 2+4 zu anderen.

In der Tabelle auf Rasperry Pi Link ist glaube ich auch ein Fehler. Die letzte Zeile sollte 0110 sein. So steht es auch im Code! Wenn man dass dann auf das Anschluss-Diagramm umsetzt, siehst du dass immer eine Halbe Spule unter Strom steht. Das heißt, die Anschlüsse einer Spule haben immer unterschiedliches Potential.

Du hast übrigens einen Motor mit Getriebe. Da sollte eigentlich Vollschritt reichen, wenn es nur auf die Anzahl der Positionen ankommt.

"Open Collector" heißt, dass der Ausgang des Transistors offen hängt und der Emitter fest auf Masse liegt. Man schließt dann ein Ende seiner Last an den Ausgang an und das andere Ende (hier die Mittelanzapfung, bzw. Pin 5) an der Versorgungsspannung. Der Transistor schaltet dann die Versorgungsspannung einfach gegen Masse: http://en.wikipedia.org/wiki/File:OpencollectorV3.png http://de.wikipedia.org/wiki/Open_Collector

Deshalb hat der ULN keinen Plus-Anschluss, sondern nur Masse. Auch nicht vergessen, die integrierten Freilaufdioden auf Plus zu hängen! Pin 10 beim ULN2803.

Hallo Serenifly, ich danke dir für deine Mühe und ich danke dir auch dafür, dass Du mich nicht einfach verteufelt hast. Jetzt habe ich das mit Bi- und Unipolar schon einmal verstanden. Und den Rest werde ich mir auch noch klar machen. Es ist halt wirklich viel Stoff, den man sich reinziehen muss. Man wünscht sich einfache Erklärungen, aber manches ist halt einfach nicht einfach. Hoffe Du bleibst im Forum aktiv und hilfst mir und Anderen gerne weiter. Schöne Grüße Hannes