Schrittmotor Treiber-Ansteuerung (Atmel 98C51)

[konrad m. (ati)]

Hy,

Ich realisiere mittels zwei Schrittmotoren mit befestigten Spiegeln eine 
Lasershow. Diese werden über einen Treiber-IC (DRV8821)angesteuert.

Dessen Eingänge steuer ich über einen Mikrocontroller an.

Eingänge vom DRV8821:

ABSTEP: steigende Flanke->ein Schritt
ABDIR: 0 oder 1 bestimmt die Richtung
ABENBLn: 0
ABUSM0: 0
ABUSM1: 0
ABDECAY: 1
ABRESETn: 1

Da ich wirklich nicht so der Software-Erfahren bin, hoffe ich jemand von 
euch kann mir helfen.

Die zwei Bits ABSTEP und ABDIR müssen leicht verzögert am Treiber 
anliegen und da liegt mein Problem. Ich hoffe ihr könnt mir einen 
Denkanstoss geben.
Ich denke ich werde wohl um ein kleines Timer Unterprogramm nicht herum 
kommen.

Wie lange die Bits verzögert sein müssen, kann man dem Bild im Anhang 
entnehmen und hier wäre noch das gesamte Datenblatt des DRV8821:
http://www.ti.com/product/drv8821

Freundliche Grüsse
ati

[MaWin (Gast)]

Kein Timer.
Du musst nur vorher das Port-Bit für die Richtung setzen,
und dann erst frühestens in der nächsten Instruktion das Bit für den 
Takt, denn die 200ns zu unterbieten schafft der C51 gar nicht.

[spess53 (Gast)]

Hi

>Die zwei Bits ABSTEP und Die zwei Bits ABSTEP und ABDIR müssen leicht verzögert 
am Treiber
anliegen und da liegt mein Problem. Ich hoffe ihr könnt mir einen
Denkanstoss geben. müssen leicht verzögert am Treiber
>anliegen und da liegt mein Problem. Ich hoffe ihr könnt mir einen
>Denkanstoss geben. ABDIR muss gültig sein bevor du anfängst Schritte zu senden. 
Und das bleibt auf dem Pegel solange du in dieser Richtung fahren willst.

MfG Spess

[Reinhard Kern (Gast)]

MaWin schrieb:
> denn die 200ns zu unterbieten schafft der C51 gar nicht.

Bei einem 20MHz-Prozessor würde ich da sicherheitshalber im Datenblatt 
nachschauen, aber mit grosser Wahrscheinlichkeit hast du recht. Wenn 
nicht, tut's auch der eine oder andere NOP, einen Timer braucht man 
definitiv nicht.

Gruss Reinhard

[spess53 (Gast)]

Hi

da ist etwas durcheinander gekommen

>Die zwei Bits ABSTEP und Die zwei Bits ABSTEP und ABDIR müssen leicht >verzögert 
am Treiber anliegen und da liegt mein Problem. Ich hoffe ihr >könnt mir einen 
Denkanstoss geben.

ABDIR muss gültig sein bevor du anfängst Schritte zu senden.
Und das bleibt auf dem Pegel solange du in dieser Richtung fahren 
willst.

MfG Spess

[konrad m. (ati)]

Erstmals Danke für die schnellen Antworten.

Das heisst, es ist möglicherweise nicht ganz so kompliziert wie ich 
anfangs dachte.

Kann ich also einfach nach und nach ein Bitmuster an den Ausgang 
ausgeben? zB:
P1= 1100000      //H-Brücke freigegeben, STEP-MODE bestimmt
P1= 1100010      //DIR=1
P1= 1100011      //STEP=1
P1= 1100001      //DIR=0
P1= 1100000      //STEP=0
//1 Schritt in eine Richtung gemacht!

Ich schau mal noch im Datenblatt wegen den 200nS nach.

Ist es möglich, dass ich paralell dazu noch ein Bitmuster für den 
CD-Motor ausgeben kann?
Denn die Spiegel müssen sich ja auch gegensätzlich bewegen lassen.

Herzlichen Dank,
ati

[r0fler (Gast)]

>Kann ich also einfach nach und nach ein Bitmuster an den Ausgang
>ausgeben? zB:
>P1= 1100000      //H-Brücke freigegeben, STEP-MODE bestimmt
>P1= 1100010      //DIR=1
>P1= 1100011      //STEP=1
>P1= 1100001      //DIR=0
>P1= 1100000      //STEP=0
>//1 Schritt in eine Richtung gemacht!

DIR kannst du auf 1 lassen, ich denke kaum dass du nach jedem Schritt 
die Richtung ändern willst oder?
Soweit ich das verstanden habe, muss DIR einfach mindestens 200ns vor 
einem Schritt auf den gewünschten Wert gesetzt werden.

>Ich schau mal noch im Datenblatt wegen den 200nS nach.

Sollte kein Problem darstellen, kannst du bedenkenlos vernachlässigen. 
Sollte es dir dennoch lieber sein kannst du ja immer noch einen kleinen 
Delay einbauen (würde ich aber nicht mache, da sich bei so einer 
Lasershow die Spiegelchen recht schnell bewegen müssen und du so nur 
wertvolle Zeit verplemperst).

>Ist es möglich, dass ich paralell dazu noch ein Bitmuster für den
>CD-Motor ausgeben kann?

Klar! wenn du genügend Ausgänge hast..

[Karl H. (kbuchegg)]

Tim Alder schrieb:

> Kann ich also einfach nach und nach ein Bitmuster an den Ausgang
> ausgeben? zB:

und wenn du das mit logischen Verknüpfungen machst, dann kannst du den 
ganzen VCorgang in 2 Teile aufspalten:
erst mal alles freigeben und einstellen

> P1= 1100000      //H-Brücke freigegeben, STEP-MODE bestimmt
> P1= 1100010      //DIR=1


und dann für jeden Schritt, den du in diese Richtung machen musst 
einfach nur das Bit 0 auf 1 ziehen und wieder auf 0 fallen lassen

P1 = P1 | 0x01;   // Bit 0 auf 1
P1 = P1 & ~0x01;  // Bit 0 wieder auf 0

Und diese Seqeuenz machst du so oft, wie du Schritte brauchst.
Eventuell musst du eine kleine Pause dazwischen machen, aber das hängt 
dann unter anderem auch vom Motor, der angehängten Last etc. ab.

[Möve (Gast)]

Karl Heinz Buchegger schrieb:
> Eventuell musst du eine kleine Pause dazwischen machen, aber das hängt
> dann unter anderem auch vom Motor, der angehängten Last etc. ab.

Bei den kleinen Spiegelchen für die fächerung des Lasers kannst du mit 
dem richtigen Motor ziemlich schnell schalten ohne Angst zu haben dass 
Schritte "verschluckt" werden.

Vlt. noch einen Schrittzähler verwenden oder mal im Datenblatt des 
Treiber-IC's nachschauen ob ein solcher vieleicht schon mit dabei ist.

"verschluckte" Schritte könnten unter Umständen zu einem Problem werden 
wenns zu häufig vorkommt.. dann verschiebt sich der Abstrahlwinkel des 
Lasers und er wird vlt. im extremfall gar nicht mehr reflektiert.

[konrad m. (ati)]

Das hat mir jetzt schon sehr weitergeholfen. Ich freue mich schon, wenn 
mein Print am Mittwoch ferig ist und ich das Ganze anschliessen und 
programmieren/austesten kann. :)

r0fler schrieb:
> DIR kannst du auf 1 lassen, ich denke kaum dass du nach jedem Schritt
> die Richtung ändern willst oder?
> Soweit ich das verstanden habe, muss DIR einfach mindestens 200ns vor
> einem Schritt auf den gewünschten Wert gesetzt werden.

So habe ich das auch verstanden.

Karl Heinz Buchegger schrieb:
> und wenn du das mit logischen Verknüpfungen machst, dann kannst du den
> ganzen VCorgang in 2 Teile aufspalten:
> erst mal alles freigeben und einstellen
>
>> P1= 1100000      //H-Brücke freigegeben, STEP-MODE bestimmt
>> P1= 1100010      //DIR=1
>
>
> und dann für jeden Schritt, den du in diese Richtung machen musst
> einfach nur das Bit 0 auf 1 ziehen und wieder auf 0 fallen lassen
>
> P1 = P1 | 0x01;   // Bit 0 auf 1
> P1 = P1 & ~0x01;  // Bit 0 wieder auf 0
Ahaa, mit logischen Verknüpfungen geht das natürlich noch besser. Ich 
muss dieses Thema unbedingt nochmals anschauen. Danke für den Anstoss.
Für die andere Richtung müsste ich dann nur am Anfang Bit 1 auf 0 
setzen, aber die log. Verknüpfungen bleiben die selben.

Möve schrieb:
> Bei den kleinen Spiegelchen für die fächerung des Lasers kannst du mit
> dem richtigen Motor ziemlich schnell schalten ohne Angst zu haben dass
> Schritte "verschluckt" werden.
>
> Vlt. noch einen Schrittzähler verwenden oder mal im Datenblatt des
> Treiber-IC's nachschauen ob ein solcher vieleicht schon mit dabei ist.
>
> "verschluckte" Schritte könnten unter Umständen zu einem Problem werden
> wenns zu häufig vorkommt.. dann verschiebt sich der Abstrahlwinkel des
> Lasers und er wird vlt. im extremfall gar nicht mehr reflektiert.

Ich verwende zwei Schrittmotoren von Trinamic:   QSH4218-51-10-049 
heisst das Ding. Ich denke, die bringen einen rechten Drehmoment hin und 
sollten keine Mühe mit so kleinen Spiegel'n haben.
Aber das mit dem Schritte verschlucken macht mir auch ein wenig Mühe. 
Zuerst dachte ich, ich baue noch eine Lichtschranke ein, um die Schritte 
zu zählen. Doch dies bedeutet einen grossen zusätzlichen Hardware 
Aufwand.
Da wäre eine Software-mässige Lösung wohl einfacher zu realisieren.

Evt. eine Variable, die bei 0 anfängt, und je nach Richtung 1+ oder 1- 
zählt. Bei Unstimmigkeiten könnte ich so die ursprüngl. Ausgangslage 
wieder anfahren.
Im Treiber ist, so wie ich das sehe, kein Schrittzähler mit dabei.

Ich schreibe auf jeden Fall wie die ersten Tests gelaufen sind. Hoffe, 
dass die Print-Fräsmaschine am Mi. wieder läuft. :)

Vielen Dank,
gruss ati.

[Cööder (Gast)]

>Da ich wirklich nicht so der Software-Erfahren bin, hoffe ich jemand von
>euch kann mir helfen.

Mal ein Gedankenanstoss:


void drive (char dir, char mode) // dir -> richtung, mode -> effekt
                                 // (mehrere effekte?)
{ P1= 1100000      //H-Brücke freigegeben, STEP-MODE bestimmt
  if (dir == 1)
  {
   P1= 1100010      //DIR=1
  }
  else
  {
   P1= 1100000      //DIR=0
  }

switch(mode)
{
  case 0: while(???){P1 = P1 | 0x01; P1 = P1 & ~0x01;}  // mit delay?
  break;
  case 1....
  ...
}

}

void main (void)
{
  drive(1, 1);
}


Schonmal sorry für falsche Funktionen? Bin schon länger nicht mehr mit C 
im Rennen ;) aber die Funktion sollte (hoffe ich) verständliche und 
ausbaufähig sein

[Karl H. (kbuchegg)]

> void drive (char dir, char mode) // dir -> richtung, mode -> effekt


Das ist doch eine unsinnige Schnittstelle. Du mischt da wild 
Mustergenerierung und Schrittrichtung durcheinander.

Die Schrittrichtung ergibt sich aus dem abzufahrenden Muster. Auf 
tieferer Ebene, also alles unter den Softwareebene 'Muster' existiert 
kein Muster mehr. Da geht es nur noch darum, dass ein Motor 25 Schritte 
nach links machen soll, dann 10 Schritte rechts und wieder 35 Schritte 
links.

Also wenn schon dann

void drive( unsigned char direction, int steps )
{
  P1= 1100000;
  if( direction )
    P1 |= 0x02;

  for( int i = 0; i < steps; ++i )
  {
    P1 |= 0x01;
    P1 &= ~0x01;
  }

  P1 = 0x00;
}

(wobei ich die Initialisierung und das Einschalten des Treibers sogar 
noch aus dieser Funktion raushalten würde.

Über dieser Funktion liegt dann eine Funktion, die den mode (also eine 
Musternummer) bekommt und aus der Musterbeschreibung dann entsprechende 
Aufrufe für drive generiert.

So könnte aus dem ganzen ein Schuh werden, denn die interessante Frage 
kommt ja erst noch: wie werden eigentlich 2 Schrittmotoren gleichzeitig 
angesteuert, so dass sich auch Bewegungen realisieren lassen, die nicht 
entlang der Hauptachsen von statten gehen.

[ati (Gast)]

Karl Heinz Buchegger schrieb:
> So könnte aus dem ganzen ein Schuh werden, denn die interessante Frage
>
> kommt ja erst noch: wie werden eigentlich 2 Schrittmotoren gleichzeitig
>
> angesteuert, so dass sich auch Bewegungen realisieren lassen, die nicht
>
> entlang der Hauptachsen von statten gehen.

Ich hab jetzt meine Platine fertig und kann Sie über mein uC-Board 
ansteuern. Jetzt stellt sich mir genau diese Frage?

Mit dem Programm, das ich bis jetzt geschrieben habe, kann ich die 
Anzahl Schritte und die Geschwindigkeit einfach verändern.
Aber nur für ein Motor.

#include <reg51xD2.h>

long int i=0,k=0;
sbit S1= P0^7;
int X=1;


void main (void)
{

while (1)
{



//******** Automatisches Laserbild1************//
  if (S1)  {


  switch (X)  {


  case 1:
    P1=0x40;          //Gegenuhrzeigersinn
    P1=P1|0x24;          //Konfig.
    for(i=0;i<500;i++);      //Pause
    P1=P1|0x01;          //1 Step
    for(i=0;i<500;i++);      //Pause

    if (k<30)          //Anzahl Schritte
    {
    X=1;
    k++;
    }
    else 
    {
    X=2;
    k=0;
    }
  break;

  case 2:
    P1=0x40;          //Uhrzeigersinn
    P1=P1|0x20;          //Konfig
    for(i=0;i<500;i++);      //Pause
    P1=P1|0x01;          //1 Step
    for(i=0;i<500;i++);      //Pause
  
    if (k<30)          //Anzahl Schritte
    {
    X=2;
    k++;
    }
    else 
    {
    X=1;
    k=0;
    }
  break;
   

  }
  }
}
}

Hoffe mir kann jemand helfen.
Gruss ati

[R. W. (quakeman)]

Also wenn ich das richtig mitbekommen habe, dann benutzt er doch einen 
8051 kompatiblen Controller. Wieso verwendet ihr dann nicht auch dessen 
spezielle Eigenschaft die Bitadressierbarkeit, welche die Programmierung 
sowie die Lesbarkeit des Codes deutlich vereinfachen?
Zumindest in dem Fall, dass nur ein Bit verändert werden soll braucht 
man keine Zuweisung des gesamten Bytes auf den Port. Ebenfalls keine 
"and" oder "or" Verknüpfungen.

Also anstatt folgenden Code zu schreiben:

void drive( unsigned char direction, int steps )
{
  P1= 1100000;
  if( direction )
    P1 |= 0x02;

  for( int i = 0; i < steps; ++i )
  {
    P1 |= 0x01;
    P1 &= ~0x01;
  }

  P1 = 0x00;
}

Solltet ihr lieber direkt die Pins ansprechen:

void drive( unsigned char direction, int steps )
{
  P1= 1100000;
  if( direction )
    P1^1 = 1;

  for( int i = 0; i < steps; ++i )
  {
    P1^1 = 1;
    P1^1 = 0;
  }

  P1 = 0x00;
}

Das direkte Ansprechen der Bits hat gleich zwei Vorteile.
Erstens braucht dieser Befehl nur 2 Byte Codespeicher im Gegensatz zur 
und/oder-Verknüpfung oder der byteweisen Zuweisung, welche 3 Byte 
benötigen.
Zweitens wird der Befehl in der Hälfte der Zeit abgearbeitet.

Also insofern nur ein einzelner Portpin verändert werden soll, sollte 
man doch diesen auch direkt ansprechen. :)

Ciao,
     Rainer

PS: Ob die korrekte Syntax nun P1^1 oder P1.1 lautet hängt etwas vom 
Compiler ab.

[konrad m. (ati)]

Hallo miteinander,

Ich habe mein Programm jetzt soweit, dass ich meine Motoren/Spiegel 
Schritt für Schritt justieren und somit in Stellung bringen kann.
Also der manuelle Modus ist soweit fertig.
Mit dem automatischen Modus komme ich überhaupt nicht zurecht.

Jetzt stehe ich vor dem Problem, dass ich es nicht hinbekomme, meine 
Spiegel "gleichzeitig" zu bewegen.

Ich möchte als erstes ein ganz simples Bild an die Wand zaubern. Es soll 
wie eine "Laserwand" aussehen die sich hin und her bewegt.

Das heisst Motor 2 (Y-Achse) soll sich immer ein Schritt hin und wieder 
zurück bewegen.
Motor 1 (X-Achse) hingegen soll gleichzeitig -etwas langsamer- 5 
Schritte hin und wieder zurück fahren.

Die Ports sind P1 und P2.
Bit 0 ist jeweils das STEP-Bit (steigende Flanke=1 Schritt)
Bit 2 ist jeweils das DIR-Bit  (0=Uhrzeigersinn, 1=Gegenuhrzeigersinn)

Ich hoffe jemand von euch hat eine Idee, wie man das realisieren könnte.

Hier wäre der Code, den ich bis jetzt geschrieben habe.

#include <reg51xD2.h>

sbit MODE = P0^7;
sbit motorwahl = P0^6;
sbit DIR = P0^5;
sbit STEP = P0^4;
unsigned char pegel_vorher,pegel_vorher1;
int k,i,modus,manuell,automatisch=10, motor;

void main (void)  {

P1=0x00;
P2=0x00;
P3=0x00;
while (1)  {

while (MODE==0)  {
  

//***********************MANUELLER MODUS**************************************///
/////////////////////////////////////////////////////////////////////////////////
                      //Manuell

    if ((motorwahl == 0)&&(DIR==0))        //Motor1, Uhrzeigersinn
    motor=10;
    
    if ((motorwahl == 0)&&(DIR==1))        //Motor1, Gegenuhrzeigersinn
    motor=20;
    
    if ((motorwahl == 1)&&(DIR==0))        //Motor2, Uhrzeigersinn
    motor=30;
    
    if ((motorwahl == 1)&&(DIR==1))        //Motor2, Gegenuhrzeigersinn
    motor=40;


    switch (motor)  {

    //*****************Motor1, Uhrzeigersinn*************//
    case 10:                
    P2=0x60;
    if ((STEP==1)&&(pegel_vorher1==0))  {  //positive Flanke  
      for(i=0;i<500;i++);          //Pause
      P2=P2|0x01;              //STEP=1;
      for(i=0;i<500;i++);          //Pause
      P2=P2&0x60;              //STEP=0;
      pegel_vorher1=1;
    }
  
    
    if ((STEP==0)&&(pegel_vorher1==1))  {   //negative Flanke
      for(i=0;i<500;i++);          //Pause
      P2=P2|0x01;              //STEP=1;
      for(i=0;i<500;i++);          //Pause
      P2=P2&0x60;              //STEP=0;
      pegel_vorher1=0;
    }    

  break;
    //*****************Motor1, Gegenuhrzeigersinn*************//
    case 20:            
    P2=0x64;
    if ((STEP==1)&&(pegel_vorher1==0))  {  //positive Flanke  
      for(i=0;i<500;i++);          //Pause
      P2=P2|0x01;              //STEP=1;
      for(i=0;i<500;i++);          //Pause
      P2=P2&0x64;              //STEP=0;
      pegel_vorher1=1;
    }
  
    
    if ((STEP==0)&&(pegel_vorher1==1))  {   //negative Flanke
      for(i=0;i<500;i++);          //Pause
      P2=P2|0x01;              //STEP=1;
      for(i=0;i<500;i++);          //Pause
      P2=P2&0x64;              //STEP=0;
      pegel_vorher1=0;
    }    
  break;

    //*****************Motor2, Uhrzeigersinn*************//
    case 30:            
    P1=0x64;
    if ((STEP==1)&&(pegel_vorher1==0))  {  //positive Flanke  
      for(i=0;i<500;i++);          //Pause
      P1=P1|0x01;              //STEP=1;
      for(i=0;i<500;i++);          //Pause
      P1=P1&0x64;              //STEP=0;
      pegel_vorher1=1;
    }
  
    
    if ((STEP==0)&&(pegel_vorher1==1))  {   //negative Flanke
      for(i=0;i<500;i++);          //Pause
      P1=P1|0x01;              //STEP=1;
      for(i=0;i<500;i++);          //Pause
      P1=P1&0x64;              //STEP=0;
      pegel_vorher1=0;
    }
  break;

    //*****************Motor2, Gegenuhrzeigersinn*************//
    case 40:            
    P1=0x60;
    if ((STEP==1)&&(pegel_vorher1==0))  {  //positive Flanke  
      for(i=0;i<500;i++);          //Pause
      P1=P1|0x01;              //STEP=1;
      for(i=0;i<500;i++);          //Pause
      P1=P1&0x60;              //STEP=0;
      pegel_vorher1=1;
    }
  
    
    if ((STEP==0)&&(pegel_vorher1==1))  {   //negative Flanke
      for(i=0;i<500;i++);          //Pause
      P1=P1|0x01;              //STEP=1;
      for(i=0;i<500;i++);          //Pause
      P1=P1&0x60;              //STEP=0;
      pegel_vorher1=0;
    }    
  break;
    }
}

//***********************AUTOMATISCHER MODUS**************************************///
/////////////////////////////////////////////////////////////////////////////////

      switch  (automatisch)  {

//!!!!Nach dem im manuellen Modus die Spiegel Waagrecht justiert wurden, werden Sie im "case 10" in Stellung gebracht!!!
      case 10:                   
            P1=0x60;          
            P2=0x64;
            for(i=0;i<500;i++);      //Pause
            P1=P1|0x01;          //1 Step
            P2=P2|0x01;          //1 Step
            for(i=0;i<500;i++);      //Pause
        
            if (k<23)          //Anzahl Schritte
            {
            automatisch=10;
            k++;
            }
            else 
            {
            automatisch=20;
            k=0;
            
            }

       break;
//!!!! AB HIER SOLLTE ES MIT DER SICH HIN UND HER BEWEGENDEN LASERWAND LOSGEHEN!!!!!!!

       case 20:                

       break;



      }

}
}

Mit freundlichem Gruss
ati