Programm zur Ansteuerung von Schrittmotor 28BYJ-48 5V Arduino

[Stefan G. (silentforce)]

Hallo zusammen,

ich habe soeben ein Programm zur Ansteuerung von dem oben genannten 
Schrittmotor geschrieben und möcht es mit euch teilen. Ev. werde ich es 
später noch ausbauen und z.B. Startrampen einbauen usw...

Für Tips und konstruktive Kritik bin ich sehr dankbar.....

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


//Befehle für Drehrichtung definieren
byte MotorStop    =   0; //wird automatisch am Ende nach Ausführung der Schritte aufgerufen
byte MotorRechts   =  1; //Definition von Rechts und Linksdrehung, bei Bedarf vertauschen
byte MotorLinks    =  2;

//Schrittabfolge definieren 1 Muster ergibt einen Schritt Vorwärts
byte StepValues[][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 },       
                        } ; 

//Motor Pins für Ausgänge 1-4 definieren  (auf ->> Eingänge ULN2003A)
byte Motor_Ausgaenge[] = {10, 11, 12, 13};
 

// the setup routine runs once when you press reset:

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

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

void loop() {
  
  //Beispielprogramm zur Ansteuerung
  delay(1000);
  MotorMove(MotorRechts, 1000, 256); // MotorMove(Drehrichtung, Speed, Anzahl Schritte)
  delay(1000);
  MotorMove(MotorLinks, 1000, 256);
  MotorMove(MotorLinks, 2000, 256);
  MotorMove(MotorLinks, 3000, 256);
  MotorMove(MotorLinks, 5000, 256);
  delay(1000);

}



/////////////// Funktion für Motoransteuerung Anfang //////////////////

//MotorMove(byte Direction, int Speed, int Steps)
//Werte für Direction --> MotorRechts, MotorLinks, MotorStop (Motor Stop wird bei Rechts und Linksdrehung am Schluss aufgerufen)
//Werte für Speed --> kleinster Wert c.a. 1000 (Verweilzeit in Mikrosekunden) je kleiner desto schneller
//Werte für Anzahl Steps --> beliebig im Rahmen der int Variable

void MotorMove(byte Direction, int Speed, int Steps){ 
  
  //Motor Stop alle Ausgänge auf LOW schalten
  if (Direction == 0){  
    for (byte i=0; i <= 3; i++){
      digitalWrite(Motor_Ausgaenge[i], LOW);
    }      
         
  }
  
  //Motor Rechtsdrehung
  if (Direction == 1){  
    for (int i=0; i <= Steps; i++){     //Schleife für Anzahl Schritte
      for (int j=0; j <= 7; j++){       //Schleife für Anzahl Ansteuerungsmuster pro Schritt
          for (int k=0; k <= 3; k++){   //Schleife um alle Ausgänge zu setzen
            digitalWrite(Motor_Ausgaenge[k], StepValues[j][k]);
          }
          delayMicroseconds(Speed); //Verweilzeit um die Geschwindigkeit zu beeinflussen
      }
    }
  MotorMove(MotorStop, 0, 0); //nach beendigung aller Schritte Motor abschalten
  }
  
  //Motor Linksdrehung
  if (Direction == 2){  
    for (int i=0; i <= Steps; i++){     //Schleife für Anzahl Schritte
      for (int j=0; j <= 7; j++){       //Schleife für Anzahl Ansteuerungsmuster pro Schritt
          for (int k=0; k <= 3; k++){   //Schleife um alle Ausgänge zu setzen
            digitalWrite(Motor_Ausgaenge[k], StepValues[j][3-k]); //3-K Muster wird umgedreht
          }
          delayMicroseconds(Speed); //Verweilzeit um die Geschwindigkeit zu beeinflussen
      }
    }
  MotorMove(MotorStop, 0, 0); //nach beendigung aller Schritte Motor abschalten
  }
} //Ende Funktion Motoransteuerung

/////////////// Funktion für Motoransteuerung Ende //////////////////

[Sabine (Gast)]

Die erreichbare Auflösung ist nicht so besonders, wenn man den Motor 
immer nur um ein Vielfaches dieser 8 Sub-Schritte ansteuern kann.
Was willst du denn selber mit diesem Motor noch so anstellen? Einfach 
nur so mal drehen lassen ist doch etwas langweilig.
(Mein eigenes Projekt mit 2 dieser Motoren: 
Beitrag "Plotter aus Billig-Steppern ( 28BYJ-48)")

[Public (Gast)]

Stefan Geheim schrieb:
> Stepper.jpg
> 2 MB, 18 Downloads

Auf den ersten Blick würde ich sagen: "Arduino mit simplem Treiber, 
einem Stepper und ein paar Kabeln".

Was sollen mir diese 2MB sonst noch sagen?

[Karl H. (kbuchegg)]

Gewöhn dir for Schleifen in der Form

   for( variable = 0; variable <= Ausdruck; variable++ )
                                ^
                                |
                                |

wieder ab.
Wenn du hier ein <= siehst, musst du hellhörig werden. In mehr als 80% 
aller Fälle ist das ein Fehler.

Ein Array mit 8 Elementen

int a[8];

bearbeitet man so in einer for-Schleife

   for( i = 0; i < 8; i++ )
     mach was mit a[i]

das hat nämlich den Vorteil, dass an beiden Stellen im Code dieselbe 8 
vorkommt. Wodurch man die beiden Teile im Code per #define auch 
zusammenfassen und damit vereinheitlichen kann

#define NR_WERTE 8

int a[NR_WERTE];

..

  for( i = 0; i < NR_WERTE; i++ )
    mach was mit a[i]

Nachdem der Präprozessor dann die Textersetzung von 'NR_WERTE' mit dem 
Text '8' gemacht hat, steht damit automatisch an beiden Stellen immer 
der gleiche Wert. Selbst dann wenn sich dieser Wert mal ändert

#define NR_WERTE 15

sorgt dann der Präprozessor dafür, dass die beiden Werte wieder 
zusammenstimmen. Er ersetzt ja beide Vorkommen von NR_WERTE durch 15. So 
etwas reduziert Fehler und erleichter Anpassungen.


Oder man kann auch so arbeiten

int a[] = { 0, 1, 2, 3 }

#define ARRAY_SIZE(x)  (sizeof(x)/sizeof(x[0])

...

   for( i = 0; i < ARRAY_SIZE(a); i++ )
     mach was mit a[i]

dann rechnet der Compiler selber aus, wie groß er das Arrya aufgrund der 
Initialisierung dimensioniert hat. Voraussetzung ist allerdings, das er 
das Array auch als Array zu Gesicht bekommt.


Du hast zwar an fast allen Stellen in deinem Programm dieses 
berücksicht, wenn du an die Arrays gegangen bist, aber nicht hier

...
    for (int i=0; i <= Steps; i++){     //Schleife für Anzahl Schritte
...

deine Funktion macht einen 'Schritt' zu viel. Wenn du die Funktion 
aufrufst mit

  MotorMove(MotorLinks, 1000, 256);

macht sie keine 256 Schritte, sondern 257.
Mal ganz davon abgesehen, dass deine 'Schritte' nicht das sind, was man 
gemeinhin unter 'Schritte' eines Schrittmotors versteht.

[Stefan G. (silentforce)]

Sabine schrieb:
> Die erreichbare Auflösung ist nicht so besonders,

Nunja bei 512 Schritten/Umdrehung ergibt sich ja ein Schrittwinkel von 
c.a. 0.7 Grad. Mit einer Spindel von z.B. 2mm Steigung eine Auflösung 
von knapp 0,004 mm. Meiner ansicht nach für die allermeisten Projekte im 
Hobbybereich  absolut brauchbar.

Mir geht es hier darum die Grundlagen der Mikrokontrollerprogrammierung 
ein bisschen zu erforschen und kennenzulernen. Ich möchte dann erstmal 
ein kleines Solarpanel damit automatisch ausrichten...

Vielen Dank für den Link, werde mir das mal anschauen, sieht interessant 
aus. Ich habe vor Jahren eine komplette 4 Achsen CNC gebaut, gesteuert 
durch Mach 3...

[Stefan G. (silentforce)]

Karl Heinz:

vielen  herzlichen Dank für deine sehr konstruktive und hilfreiche 
Kritik! Solche Kommentare wünscht man sich :-D

for( i = 0; i < 8; i++ )
     mach was mit a[i]

Klar da hast du recht, macht für mich auch mehr Sinn...

#define NR_WERTE 8

int a[NR_WERTE];

auch dies ein sehr nützlicher Hinweis. Ich habe jetzt die Anzahl der 
Ausgänge und die Anzahl der Muster so definiert. Das macht den Code 
flexibler und besser anpassbar... zudem noch übersichtlicher.. :-)

for (int i=0; i <= Steps; i++)

uups... das war ein Flüchtigkeitsfehler. Nach 2 Stunden Programmieren 
und lernen.. wohl schon etwas müde ;-)

Mal ganz davon abgesehen, dass deine 'Schritte' nicht das sind, was man gemeinhin unter 'Schritte' eines Schrittmotors versteht.

Wäre schön wenn du mir das noch genauer erläutern könntest?

Vielen Dank erstmal!!!

Und hier erstmal den korrigierten Code:

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

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


//Befehle für Drehrichtung definieren
byte MotorStop    =   0; //wird automatisch am Ende nach Ausführung der Schritte aufgerufen
byte MotorRechts   =  1; //Definition von Rechts und Linksdrehung, bei Bedarf vertauschen
byte MotorLinks    =  2;

//Schrittabfolge definieren 1 Muster ergibt einen Schritt Vorwärts
byte StepValues[AnzMuster][AnzAusgange] =  { 
                        { 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  (auf ->> Eingänge ULN2003A)
byte Motor_Ausgaenge[AnzAusgange] = {10, 11, 12, 13};
 

// the setup routine runs once when you press reset:

void setup() { 
  
  //Serial.begin(9600);  //zu Testzwecken Debuggen
  
  //Alle Pins als Ausgänge setzen und auf LOW schalten
  for (byte i=0; i < AnzAusgange; i++){
      pinMode((Motor_Ausgaenge[i]), OUTPUT);
      digitalWrite(Motor_Ausgaenge[i], LOW);
      }      
 
}

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

void loop() {
  
  //Beispielprogramm zur Ansteuerung
  MotorMove(MotorRechts, 1000, 256); // MotorMove(Drehrichtung, Speed, Anzahl Schritte)
  delay(1000);
  MotorMove(MotorLinks, 1000, 256);
  delay(1000);

}



/////////////// Funktion für Motoransteuerung Anfang //////////////////

//MotorMove(byte Direction, int Speed, int Steps)
//Werte für Direction --> MotorRechts, MotorLinks, MotorStop (Motor Stop wird bei Rechts und Linksdrehung am Schluss aufgerufen)
//Werte für Speed --> kleinster Wert c.a. 1000 (Verweilzeit in Mikrosekunden) je kleiner desto schneller
//Werte für Anzahl Steps --> beliebig im Rahmen der int Variable

void MotorMove(byte Direction, int Speed, int Steps){ 
  
  //Motor Stop alle Ausgänge auf LOW schalten
  if (Direction == 0){  
    for (byte i=0; i < AnzAusgange; i++){
      digitalWrite(Motor_Ausgaenge[i], LOW);
    }      
         
  }
  
  //Motor Rechtsdrehung
  if (Direction == 1){  
    for (int i=0; i < Steps; i++){     //Schleife für Anzahl Schritte
      for (int j=0; j < AnzMuster; j++){       //Schleife für Anzahl Ansteuerungsmuster pro Schritt
          for (int k=0; k < AnzAusgange; k++){   //Schleife um alle Ausgänge zu setzen
            digitalWrite(Motor_Ausgaenge[k], StepValues[j][k]);
          }
          delayMicroseconds(Speed); //Verweilzeit um die Geschwindigkeit zu beeinflussen
          //Serial.print(i); 
          //Serial.print("\n");
      }
    }
  MotorMove(MotorStop, 0, 0); //nach beendigung aller Schritte Motor abschalten
  }
  
  //Motor Linksdrehung
  if (Direction == 2){  
    for (int i=0; i < Steps; i++){     //Schleife für Anzahl Schritte
      for (int j=0; j < AnzMuster; j++){       //Schleife für Anzahl Ansteuerungsmuster pro Schritt
          for (int k=0; k < AnzAusgange; k++){   //Schleife um alle Ausgänge zu setzen
            digitalWrite(Motor_Ausgaenge[k], StepValues[j][3-k]); //3-K Muster wird umgedreht
          }
          delayMicroseconds(Speed); //Verweilzeit um die Geschwindigkeit zu beeinflussen
      }
    }
  MotorMove(MotorStop, 0, 0); //nach beendigung aller Schritte Motor abschalten
  }
} //Ende Funktion Motoransteuerung

/////////////// Funktion für Motoransteuerung Ende //////////////////

[Stefan G. (silentforce)]

> Auf den ersten Blick würde ich sagen: "Arduino mit simplem Treiber,
> einem Stepper und ein paar Kabeln".
>

Genau! Das hast du richtig erkannt :-)


> Was sollen mir diese 2MB sonst noch sagen?

Ich denke das reicht doch oder? Ist ja schon eine ganze Menge....

[Public (Gast)]

Stefan Geheim schrieb:
> Ich denke das reicht doch oder? Ist ja schon eine ganze Menge....

Dafür, dass die Datenmenge 20000 mal so groß ist, wie der 
zusammenfassende Satz, würde ich doch noch etwas mehr Information 
erwarten.

[Karl H. (kbuchegg)]

Stefan Geheim schrieb:

>

Mal ganz davon abgesehen, dass deine 'Schritte' nicht das sind, 
> was man gemeinhin unter 'Schritte' eines Schrittmotors versteht.
>

>
> Wäre schön wenn du mir das noch genauer erläutern könntest?

Dein Schrittmotor macht ja immer 8 Schritte auf einmal, wenn ich ihn 
anweise 1 Schritt zu machen. Muss ja nicht sein. Du verschenkst dadurch 
ja Auflösung des Motors für nichts.

byte stepNr = 0;

void oneStepRechts()
{
  stepNr++;
  if( stepNr == 8 )
    stepNr = 0;

  for (byte k=0; k < 4; k++)
    digitalWrite( Motor_Ausgaenge[k], StepValues[stepNr][k]);
}

void oneStepLinks()
{
  if( stepNr == 0 )
    stepnr = 7;
  else
    stepNr--;

  for (byte_t k=0; k < 4; k++)
    digitalWrite( Motor_Ausgaenge[k], StepValues[stepNr][k]);
}

void MotorMove(byte Direction, int Speed, int Steps)
{ 
  if (Direction == MotorStop)
  {  
    for (byte i=0; i < 4; i++)
      digitalWrite( Motor_Ausgaenge[i], LOW );
  }
  
  else if (Direction == MotorRechts)
  {  
    for (int i=0; i < Steps; i++)
    {
      oneStepRechts();
      delayMicroseconds(Speed);
    }
  }
  
  else if (Direction == MotorLinks)
  {  
    for (int i=0; i < Steps; i++)
    {
      oneStepLinks();
      delayMicroseconds(Speed);
    }
  }
}

und achte ein wenig mehr auf deine Codekommentare. Die Hälfte deiner 
Kommentare im Code sind sinnlose Kommentare

    for (int i=0; i < Steps; i++){     //Schleife für Anzahl Schritte

das das eine Schleife ist, sehe ich im Code auch so. Und wenn die 
Schelifenvariable Step heisst, dann brauchst du mir im Kommentar auch 
nicht dazu schreiben, dass es sich um die Schleife für die Anzahl der 
Schritte handelt. Das kann ich "zur Not" auch so noch in 2 Sekunden 
erraten.

Als Ausgleich sollst du aber anstatt

  //Motor Rechtsdrehung
  if (Direction == 1){

was besseres schreiben. Du hast dir sooooo schöne Wertedefinitionen 
dafür gemacht (ein const davor würde noch guttun)

const byte MotorStop    =   0;
const byte MotorRechts   =  1;
const byte MotorLinks    =  2;

warum benutzt du sie denn nicht?

  if (Direction == MotorRechts){

dann brauchst du auch den Kommentar nicht. Denn das was mir der 
Kommentar erzählt, steht sowieso schon im Code mehr oder weniger im 
Klartext. Da steht "Wenn Richtung gleich Rechts". Noch ein paar 
Füllwörter dazu gedacht und fertig ist der komplette Satz. Ganz ohne 
Kommentar und nur durch Code ausgedrückt.


PS: Einen Schrittmotor brauchst du nicht im eigentlichen Sinne 
'Stoppen'. Wenn du keine Schritte machst, dann bewegt sich der auch 
nicht. Was du maximal tun kannst, ist alle Spulen stromlos schalten. Das 
will man aber meistens nicht wirklich. Denn dann hält der Motor nichts 
mehr - er lässt sich dann ganz leicht drehen. Und das will man dann ja 
meistens nicht, dass die vom Motor angetriebene Last den Motor 
verstellt, weil der keine Kraft hat, die Last an Ort und Stelle zu 
halten. Wenn schon, dann willst du das aber ganz sicher dem 
Anwendungscode überlassen, ob er das tun möchte oder nicht. 
Basisroutinen sollten eine derartig schwerwiegende Entscheidung nicht 
für sich selber treffen. Vor allen Dingen dann nicht, wenn es für den 
Anwendungscode keine Möglichkeit gibt, das zu umgehen. Ein

...
  MotorMove( MotorMove, 0, 0 );
...

kann der Anwendungscode immer aufrufen, wenn er die Spulen stromlos 
schalten will. Aber die Umkehrung kann er nicht erreichen. Er kann 
keinen

  MotorMove( MotorRechts, 1, 1000 );

aufrufen und nach vollzogener Bewegung den Motor unter Strom halten, 
damit der die Liftkabine, die er gerade hochgezogen hat, auch in der 
Station halten kann ohne dass die Kabine mit ihrem Eigengewicht den 
Motor in die andere Richtung zurückdreht.

[Stefan G. (silentforce)]

Karl Heinz schrieb:
> Dein Schrittmotor macht ja immer 8 Schritte auf einmal, wenn ich ihn
> anweise 1 Schritt zu machen. Muss ja nicht sein. Du verschenkst dadurch
> ja Auflösung des Motors für nichts.

Genau da hast du natürlich Recht. Da dieser Motor aber stark untersetzt 
ist, würde dies immer noch lange reichen für mein gedachtes Projekt. Da 
ich aber jetzt ein Programm erstellen möchte welches universell ist, 
werde ich das entsprechend abändern.

Vielen Dank für deine Lösung für dieses "Problem". Ich habe mir den Code 
durchgeschaut und soweit verstanden.

Elegante Lösung um einen Minuswert zu verhindern... da brauchte ich eine 
Weile :)

> if( stepNr == 0 )
>     stepnr = 7;
>   else
>     stepNr--;

Kann es sein dass hier das "byte_t" ein Fehler ist?

> for (byte_t k=0; k < 4; k++)

Würde etwas dagegen sprechen die "oneStepRechts" und "oneStepLinks" 
Funktion direkt in die "MotorMove" Funktion einzubauen? Oder hat dies 
Nachteile?


Auch was die Kommentare angeht, bin ich mit dir einverstanden. Ich habe 
das so aufgebaut, weil ich mit den Kommentaren zuerst ein Gerüst 
erstellt habe und dann den Code eingefügt habe... Anfängermethode halt 
:-) Ist sicher mit kommender Routine und gut gewählten Namen völlig 
überflüssig..

> Als Ausgleich sollst du aber anstatt  //Motor Rechtsdrehung
>   if (Direction == 1){
> was besseres schreiben.

Klar ein weiterer Flüchtigkeitsfehler... Ich werde den Code nochmals 
überarbeiten und die Namen noch klarer und besser definieren.

> Einen Schrittmotor brauchst du nicht im eigentlichen Sinne
> 'Stoppen'. Wenn du keine Schritte machst, dann bewegt sich der auch
> nicht.

Das ist mir schon klar, ich habe auch schon eine 4 achsen NC mit 
Schrittmotoren gebaut und arbeite seit 20 Jahren als Feinmechaniker. Das 
Wort Stop ist hier natürlich ein bisschen unglücklich gewählt. 
Eigentlich dient es nur dazu die Motoren Stromlos zu schalten 
(Überhitzung/Stromverbruach). Das war auch der Hintergedanke für mein 
Projekt "Solarpanel ausrichten". Da macht es natürlich Sinn den Strom 
noch für das halten eines Motores zu verpuffen. Da es ein "stark" 
übersetzter Getriebemotor ist, reicht das Haltemoment allemal aus... Ev. 
könnte man das auch noch über ein Schneckengetriebe verbessern. Aber 
eben, der Code soll ja universeller werden. Deshalb stimme ich dir auch 
hier wieder zu...

Wahrscheinlich werde ich dies über einen Parameter lösen, wo man diese 
Funktion ein und auschalten kann.

Bei der Schrittmotorsteuerung die ich für die NC Fräse verwendet habe, 
gab es eine "Stromabsenkungsfunktion" damit die Motoren "halten" und 
doch nicht zu heiss werden. Wie wäre dies realisierbar?

Dann bedanke ich mich erneut bei dir für dein Mühe, ich weiss das sehr 
zu schätzen... ich habe viel dazu gelernt :-)

[mike (Gast)]

Stefan Geheim schrieb:
> Bei der Schrittmotorsteuerung die ich für die NC Fräse verwendet habe,
> gab es eine "Stromabsenkungsfunktion" damit die Motoren "halten" und
> doch nicht zu heiss werden. Wie wäre dies realisierbar?

Mit einem Schrittmotortreiber, bei dem es die Möglichkeit gibt, den 
Sollwert für den Strom durch ein Steuersignal zu ändern, z.B. indem man 
die Referenzspannung für den Stromsollwert per PWM (mit TP-Filter) 
vorgibt.

[Stefan G. (silentforce)]

Hier erstmal der überarbeitete Code. Ich habe für die Variabeln noch 
klarere Namen verwendet und alles in Englisch gemacht:

//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;

byte 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);
  } 
}


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 //////////////////

Jetzt habe ich noch einen Bipolar Stepper vom Betrieb bekommen und werde 
diesen mit einem L293D ansteuern und ein paar neue Funktionen einbauen 
wie: Stromabsenkungsfunktion, mehrere Motoren, Anfahr/Stop Rampe.

[Stefan G. (silentforce)]

mike schrieb:

> Mit einem Schrittmotortreiber, bei dem es die Möglichkeit gibt, den
> Sollwert für den Strom durch ein Steuersignal zu ändern, z.B. indem man
> die Referenzspannung für den Stromsollwert per PWM (mit TP-Filter)
> vorgibt.


Dies wäre also mit dem L293D möglich und dem Bipolarstepper. Ich nehme 
an der TP Filter ist da um die Spannung zu glätten? Wie müsste ich 
diesen berechnen? Würde sich ohne TP-Filter ev. die Position des Motors 
ändern oder würde es auch ohne gehen?

[Thorsten O. (Firma: mechapro GmbH) (ostermann)]

Ohne wirst du ein starkes Rauschen hören, weil sich der Strom in den 
Motorwicklungen ständig leicht ändert. Es geht aber auch ohne PWM, in 
dem man einen Spannungsteiler aufbaut, den man über einen Transistor 
umschalten kann. So z.B.:
http://www.mechapro.de/pdf/3D-Step_Doku_20120915.pdf (Schaltplan S. 7)
Oder einfacher:
http://www.mechapro.de/pdf/tinystep_doku.pdf (Schaltplan auf S. 4)

Mit freundlichen Grüßen
Thorsten Ostermann

[Stefan G. (silentforce)]

Thorsten Ostermann schrieb:
> Ohne wirst du ein starkes Rauschen hören, weil sich der Strom in
> den
> Motorwicklungen ständig leicht ändert.


Hallo Thorsten,

vielen Dank für deinen Hinweis. Ich habe vor Jahren bei dir Bausätze für 
die 3d Step, HP Step und Tiny Step gekauft als ich meine NC Maschinen 
gebaut habe, welche ich inzwischen leider wieder verkauft habe. Damals 
hiess es glaube ich noch NC-Step... Von daher kenne ich auch diese 
Stromabsenkungsfunktion. Schön dass es deinen Shop immer noch gibt. Ich 
war sehr zufrieden mit den Produkten und dem super Support.

Ich werde mir die Schaltpläne mal anschauen... auf die Idee bin ich gar 
nicht gekommen. Ich habe den Motor mit dem L293D mittlerweilen mal 
angeschlossen und das Rauschen ist deutlich zu hören... :-)

Ich könnte mir natürlich einfach eine professionelle Karte von dir 
kaufen, aber ich möchte ja etwas mehr über Elektronik lernen... (arbeite 
als Mechaniker auf NC-Maschinen)

[Sabine W. (sabine_w)]

Lässt sich eigentlich mit entsprechend angepassten Strömen auch jeder 
beliebige Zwischenwinkel erzeugen, um z.B. einen weicheren Lauf oder 
eine höhere Auflösung zu bekommen?

[Karl H. (kbuchegg)]

Sabine W. schrieb:
> Lässt sich eigentlich mit entsprechend angepassten Strömen auch jeder
> beliebige Zwischenwinkel erzeugen,

das nennt sich dann 'Microstepping'

[Mike (Gast)]

Sabine W. schrieb:
> Lässt sich eigentlich mit entsprechend angepassten Strömen auch jeder
> beliebige Zwischenwinkel erzeugen, um z.B. einen weicheren Lauf oder
> eine höhere Auflösung zu bekommen?

Ja, das nennt sich dann Mikroschrittbetrieb. Die Genauigkeit mit der die 
Winkelunterteilung stattfindet, hängt sehr vom Aufbau des Motor ab. Der 
Lauf wird auf jeden Fall ruhiger.

[Marcel O. (marcel_o)]

Hallo,

bin neu hier und absoluter Noob was Programmieren angeht .
Demzufolge fand ich die anfänglichen Codekommentare einfach klasse auch 
wenn für viele überflüssig.

mit dem Code Läuft mein Stepper jetzt , anstatt dieses "  delay(1000);"
möchte ich den Befehl mit Tastern ausführen.

Taster an Pin 2,3,4
Pin 2 Start Motor rechts
Pin 3 Stop
Pin 4 Start Motor links.

Die anzahl der Steps kann ich im Sketch ändern und diese soll er per 
Tastendruck ablaufen lassem.


Gruß Marcel.