Schrittmotor-Problem..!

hallo,

ich versuche einen Schrittmotor anzusteuern, aber er macht leider nur komische Halbdrehungen, woran kann das denn liegen?

Das wichtige Teil des Codes:

Code:

---

#define F_CPU 8000000

#include <avr/io.h>
#include <stdio.h>
#include <stdbool.h>
#include<util/delay.h>

uint8_t step[6] = {0xE6, 0xBC, 0xE8, 0xBA, 0xBC, 0xE8};

void rotate(direction)
{
 
  int i;
  if(direction)
        {
     
          PORTD |= 0x80 ;//LED1 geht an
          //PORTA = 0x82;
          //PORTA = 0x84;
     
          for(i=0;i<6;i++)
          {         
          _delay_ms(250);
          PORTA = step[i];
          };   
        }
  else
    {
          PORTD |= 0x20;//LED2 geht an
    }
}

---

P.S: - Die 250ms habe ich nur so da eingefügt, da ich nicht weiss, wie ich diese Zeit berechnen kann.
- ich benutze TCA3727G als Motortreiber.
Danke.

hier zumindest mal das datenblatt (braucht n paar sekündchen zum laden:

http://pdf1.alldatasheet.co.kr/datas.../TCA3727G.html

da is auch ne anschlussbelegung dabei.

könnte es sein, dass du eine spule deines schrittmotors ausversehen an den falschen anschluss gesetzt hast, oder so....

Danke A|KI!
Das Datenblatt habe ich auch sorgfältig gelesen, und die Anschlussbelegung habe ich mit Multimeter Überprüft das ist Einwandfrei!
Ich glaube aber das es an der Delay Funktion liegt
Der Schrittmotor bekommt Die Kommandos zu schnell von dem Prozessor aber diese Verzögerungszeit kann ich leider nicht berechnen, hast du vielleicht eine Idee?

mit prozessor proggen hab ich noch keine ahnung, aber der wird doch au irgendwo n schwingkreis (oszilator?) haben, welcher ihn taktet. vlt den mal etwas "abändern", also nen gröseren kondensator reinhaun, wenn der auserhalb liegt.

ansonsten erkundig dich mal nach dem sleep-teil (_delay_ms_ oder was das ist) ob der richtig ist. ansonsten, dieses

for(i=0;i<6;i++)

ist doch irgendwie quatsch, oder? damit machst du aus i irgendwie immer 1, und dann wieder null nach dem durchlaufen der schleife, und bevor sie wieder gestartet wird, wieder 1. zumindest wärs in C++ so, oder der compiler regt sich auf...

schau mal, wie es mit dem wär:

Code:

---

...

int i=0 ... ; //sollte glaub auserhalb der funktionen sein :-)

void rotate(direction)
{

...
while(i<6)
{
PORTA =step[i];
_delay_ms(1000);
i++;
}
}

---

zumindest kenn ichs so mit C++ progs
(evtl das while durch for ersetzen)

step[i] ist ein array(Platzhalter) und wenn i durch 0 ersetzt ist ,heisst nicht dass step[0]=0
sondern der inhalt von Platzhalter step[0] ,also in meinem Programm 0xE6

ok, und wenn du i um 1 erhöhst, dann rufst du quasi den inhalt vom nächsten platz auf?

wenn ja, dann rufst du doch irgendwie immer das ausm platz i auf, oder blick ichs grad net?

genau, und so soll es auch sein.

lol, warum so umständlich?

wenn du doch immer dasselbe aufrufst, da i ja irgendwie immer 1 ist, warum machst du dann sowas in der art von

Code:

---

mach aus i (wieder) 0; // i=0
zähle zu i 1 dazu; // jetzt ist i=1
rufe i auf;
warte Xms;
und wieder von vorn;

---

geht doch einfach so:

Code:

---

rufe i auf;
warte Xms;
wieder von vorn;

---

was du machen wolltest, war wohl sowas:

Code:

---

while(true)
{
if (i<6) //du hast 5 schritte? oder nur die 4 schritte 1-5?
{
führe den ablauf von i aus;
warte Xms;
i++;
}
// wenn das ganze ne endlosschleife werden soll, dann noch:
if (i=6)
{
i=0 // oder 1, wenn du nur die schritte 1-5 hast
}
}

---

die i ist doch nicht immer 1,die i kann Werte von 0 bis 5 annehmen je nachdem welche Array wir benutzen.

ja, aber i ist doch so, wie ich deine funktion da oben verstehe, immer 1, da du aus i nach dem durchlaufen wieder 0 und gleich darauf wieder 1 machst. es ist doch nach deiner formel egal, was i nach dem durchlaufen der for() bedingung ist, denn du machst ja daraus wieder 1.

guck dir nochmal die codes an, die ich da oben geschrieben hab. wenn ich da irgendwas falsch verstehe, sags mir.

du willst ja nach und nach i als:
0; 1; 2; 3; 4; 5; 1; 2; 3; 4; 5; 1; 2; undsoweiter
haben

nurist i bei dir, so wie ich deinen code oben verstehe

0; 1; [wird ausgeführt]; 0; 1; [wird ausgeführt]; 0; 1; undsoweiter

das 0; 1; passiert in der for()-funktion

nee,wieso denn ?
Die ganze Werte von 0 bis 5 werden durchläuft, oder habe ich gerad
was übersehen?

Hi,
ich glaube ihr redet gerade schwer aneinander vorbei.
Alki scheint aus der C++-Welt zu kommen und da gibt es offensichtlich keine for schleife mehr.
@ALKI in der for-Schleife in C wird i=0 nur beim ersten betreten ausgeführt, danach werden nur noch der zwiete und dritte Befehl in der Klammer ausgefürt. Also i++ und Kontrolle ob i<6.
Also die for schleife macht nichts anderes als dein

Code:

---

while(i<6){
//irgendein Befehl
i++;
}

---

Mit dem Vorteil das wenn die Schleife mehrmals aufgerufen werden muss der Parameter i immer bei 0 beginnt.

Hallo

es werden die Werte von 0 bis 5 durchlaufen. Ist ja eine normale For-Schleife. (hab auch eigentlich keinen Fehler in der For-Schleife gefunden).
Was ich aber nicht verstehe ist deine Abfrage mit dem Parameter direction. So wie das Programm jetzt ist rufst du ja irgendwann diese Funktion auf. z.B. rotate(200); Dann überprüft das Programm ob der Parameter <> 0 ist. Was soll dann überhaupt der Parameter direction?
Wenn Direction<>0 ist führt der einmal die 6 Schritte aus und das wars. Müssten die nicht eigentlich ständig ausgeführt werden, damit sich der Motor dauerhaft dreht?

@zumgwadrad: ahh, thx!!!!! gut zu wissen!

@RIFMAN: das selbe wie robojunior habe ich aber auch schon gedacht, oder hast du vor der ganzen funktion noch sowas wie ne while(true o.Ä.) schleife?

willst du den motor einfach dauernd drehen lassen, oder um ne bestimmte anzahl schritte, die du voher eingegeben hast?

Ich danke euch!
das ist aber nicht das komplette Programm .Ich werde es posten,wenn ich zu Hause bin.

Also das ist das Programm:

Code:

---

#define F_CPU 8000000

#include <avr/io.h>
#include <stdio.h>
#include <stdbool.h>
#include<util/delay.h>




#define T1 0x04
#define T2 0x08
#define T3 0x10


uint8_t direction;
uint8_t step[8] = {0xEE, 0xBC, 0xE8, 0xBA, 0xEE, 0xBC, 0xE8, 0xBA};//Halbschritt Steuerung
uint8_t rev_step[8] = {0xBE, 0xEA, 0xB8, 0xEC, 0xBE, 0xEA, 0xB8, 0xBC};//Halbschritt Steuerung
               

   


//***********************************************

void rotate(direction)
{
 
  int i;
  if(direction)
        {
          PORTD &=~(0x20);
          PORTD &=~(0x40);
          PORTD |= 0x80 ;
         
        for(i=0;i<8;i++)
          {         
          _delay_ms(80);
          PORTA = step[i];
      };   
        }
  else
    {
        PORTD &=~(0x80);
        PORTD &=~(0x40);
        PORTD |= 0x20;
        for(i=0;i<8;i++)
          {
          _delay_ms(80);
          PORTA = rev_step[i];
          };
        }
}         
       
//************************************************


int main()
{
 uint8_t start;
 uint8_t release1;
 uint8_t release2;
 uint8_t release3;
 
 release1 = 0x01;
 release2 = 0x01;
 release3 = 0x01;
 
 direction = true;
 start = false;
 

 DDRA |= 0xFE;//Port A pin 1-7 als Ausgang setzen
 PORTA = 0x00;//pull up's auf low setzen
 DDRD &= ~(0x1c);//Port D; PIN 2, 3 und 4 als Eingang setzen
 //PORTD &= ~(0x1c);//pull up's auf low setzen
 DDRD |= 0xE0;
 
 while(1)
 {
  if((PIND & T1)&&(release1 == 0x01)) //Taster1 gedrückt
  {
  release1 = 0x00;
  direction = true;
  start= true;
  }
 
 else
  {
  if (!(PIND & T1))
  {
    release1 = 0x01;
  }
  }
 
 
 if((PIND & T2)&&(release2 == 0x01)) //Taster2 gedrückt
  {
    release2 = 0x00;
    direction = false;
    start = true;
  }
  else
  {
  if (!(PIND & T2))
    {
   
        release2 = 0x01;
         
    }
  }
 
 if((PIND & T3)&&(release3 == 0x01))//Taster3 gedückt
  {
  PORTD |= 0x40;
  PORTD &=~(0x80) ;
  PORTD &=~(0x20);
  release3 = 0x00;
  PORTA &=~(0x80);
  start = false;
  }
 
 else
  {
  if (!(PIND & T3))
  {
    release3 = 0x01;
       
  }
  }         

 
 if(start == true)
  {
         
        rotate(direction);
  }

}       
return 0;
}

---

wie ihr sieht das ganze will ich mit Tastensteuerung machen.

ich habe es jetzt mit Halbschritt-modus geschafft,das der Schrittmotor sich einigermaßen sauber dreht, aber was mich ärgert dass er immer noch vibriert,er macht das nicht fliessend, weiss jemand was darüber?

bist du dir sicher, dass du den motor richtig angeschlossen hast?

was hast du denn für einen (anschlussmäßig)? 4 anschlüsse? oder 5?

hallo A|KI,
ich glaube schon, dass ich den Motor richtig angeschlossen habe, sonst hätte er sich kaum drehen können.
das ist ein 4-Anschluss Schrittmotor.

ah, ok, bei denen gehts ja schwer, die falsch anzuschließen. was hat der denn sonst so für daten (schrittwinkel...)?

Kann ich dir nicht sagen,da ich ehrlich gesagt keine Datenblatt vom Motor habe

Hallo!
ich habe das Datenblatt gefunden!
Schrittwinkel= 11,25
Nennspannung=4,5

Hi,
also bei diesem riesigen Schrittwinkel wirst du wohl die Schrittauflösung noch weiter runtersetzen müssen um einen einigermaßen sauberen Lauf hinzukriegen.
Mein Schrittmotor hat ne Auflösung von 0,9° Grad im Vollschritt und wenn ich so unter 75 1/min gehe fängt der auch an zu ruckeln und zu vibrieren. Du musst halt versuchen eine kontinuierliche Bewegung zu machen dann wird des mit dem ruckeln nimmer so schliumm!
Also im Halbschritt vielleicht so 200 1/min. Das entspricht bei Halbschritt und deinem Motor 12800 Schritten pro Minute. Probier des mal!!
Viel Erfolg

hmmm, was mir gerade noch eingefallen ist: kann es sein, dass dein controller da immer ne kleine weile braucht, bis er die for()-schleife wieder aufruft? wenns nur n paar ms sind, kann das u.U. schon der grund sein...

wo kann ich das in meinem Programm denn ändern?

Keine Ahnung, ich glaub aber im nachhinein, dass Zumgwadrad recht hat, der schrittwinkel is sehr groß. mit dem delay([Zahl]), oder was bei dir die verzögerungen zwischen den einzelnen schritten (nicht den for()-schleifen!) ausmacht, kannst du ja mal probieren, ob ne kleinere zahl da hilft....
*latein am ende sei*

wie kann ich denn die optimale Schrittauflösung für meinen Motor ausrechnen?
es gibt bestimmt eine Zusamenhang zwischen Schrittwinkel und die Schrittauflösung,oder?

Hi,
naja der Schrittwinkel bestimmt ja die Schrittauflösung!
Vibrationsfrei kriegst du die Kiste eigentlich nur wenn du aus der nichtkontinuierlichen Schrittbewegung eine kontinuierliche Rotation hinkriegst!
Die Auflösung kannst du durch sogenannten Mikroschrittbetrieb erhöhen, das wirst du wohl müssen bei diesem riesigen Schrittwinkel!
Wo hast du den Motor eigentlich her? Schrittmotoren haben doch eigentlich ne viel kleinere Schrittweite oder ist der rein permanent erregt?

ich glaube nicht, dass es ein permanent erregter Motor ist, der ist für eine bestimmte Funktion gefertigt worden !
danke!

Hi,
oh ich glaube schon wieder ein Missverständnis!
Permanent erregt heißt das auf dem Rotor Dauermagnete sitzen die dan vom Ständer angezogen bzw. abgestoßen werden. Da sich der Schrittwinkel mit der anzahl der Dauermagnete ändert und deswegen aus kostengründen permanent erregte Motoren nur mit sehr großen Schrittwinkel gebaut werden habe ich darauf geschlossen das dein Motor ein solcher ist.
Läuft er denn jetzt einigermaßen rund???

hi,

nachdem ich die Verzögerungszeit verkürzt habe läuft er glatter.
aber eines verstehe ich nicht; wie kann ich jetzt die Geschwindigkeit ändern?

Zitat:

---

Zitat von RIFMAN

... wie kann ich jetzt die Geschwindigkeit ändern?

---

ganz einfach: nur noch schneller. und das nur bis zu nem bestimmten punkt, wo dein motor nicht mehr hinterher kommt und es zu schrittfehlern kommt.

abhilfe schafft ein getriebe, dadurch kannst du die geschwindigkeit verringern.

hi,
bei 20ms erreicht der Motor seine maximale Geschwindigkeit wenn ich kleinere oder größere Verzögerungszeit eingebe dann wird er langsamer

Hi,
naja dann ist er aber schon ordentlich fix unterwegs.
Bei 20ms delay macht der immerhin 50 Schritte pro Sekunde, das wären ja dann 33000 irgendwas umdrehungen pro minute, oder?
Oder waren die 20ms schon im Halbschritt?
Trotzdem noch schnell, meiner geht so bei 175 1/min im Vollschritt in die Knie, bin aber da schon bei 1,2kHz Ansteuerfrequenz.
Kannst du denn jetzt eigentlich noch kleinere Schritte als Halbschritt machen?

Hallo
Motor 1.8° -> 200 Schritte/U
50 Schritte in der sec also 15u/min

Mit freundlichen Grüßen
Benno

ja, laut das Datenblatt kann der motor mit viertel- und sogar minischritte
angesteuert werden

Hi,

Zitat:

---

Schrittwinkel= 11,25
Nennspannung=4,5

---

Also liegt der Schrittwinkel nicht bei 1,8°.
1,8° ist halt nur Standard.