Schrittmotoransteuerung

[Gerd (Gast)]

Hallo zusammen,
Kann mir jemand verraten weshalb ich nicht von dem Linkslauf in den 
Rechtslauf umschalten kann. Hab ich die Bedingungen falsch gesetzt. Ich 
bitte dringend um Hilfe!!

#include <t89c51ac2.h> // Header für Controller "AT89C51AC3" 
#include <stdio.h> 
/*------------------------------------------------------------------- 
Deklarationen von Variablen und Konstanten 
--------------------------------------------------------------------*/ 
//unsigned char x; 
bit reslo; 

bit lislo; 

sfr eingang = 0x90; 
/*-------------------------------------------------------------------- 
Hauptprogramm 
----------------------------------------------------------------------*/ 
void re_slow(void); 

void li_slow(void); 

void zeit(int i, int k); //Prototypen-Anmeldung 
void main(void) 
{ 
    P2=0x00; 
    eingang=255; 
    reslo = 0; 

    lislo = 0; 

    while(1) 
    { 
        switch(eingang) 
        { 
        case 0xFE: 
            re_slow(); 
            break; 

        case 0xFB: 
            li_slow(); 
            break; 

        default: 
            //P4=0xFF; 
            break; 
        } 
    } 
} 
/*----------------------------------------------------------------------- 
Zusatzfunktionen 
-------------------------------------------------------------------------*/ 

void re_slow(void) // Funktion Rechtslauf langsam 
{ 

    reslo=1; 
    while(reslo) 
    {       
        if(P1_0==0){      // Hier komme ich nicht weiter !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!????????????????????????? 
            P2=0x0C; // Bitmuster 1 Rechtslauf 
            zeit(5,3000); // Zeitverzögerung 
            P2=0x09; // Bitmuster 2 Rechtslauf 
            zeit(5,3000); 
            P2=0x03; // Bitmuster 3 Rechtslauf 
            zeit(5,3000); 
            P2=0x06; // Bitmuster 4 Rechtslauf 
            zeit(5,3000); 
            if (eingang == 0xEF) 
            { 

                //P2=0x00; 
                while(P1_0==0){}                     // Hier komme ich nicht weiter ich habe es mit Polling versucht!!!!!!!!!!!!!!!!!!!!!!!!!!!!?????????????????????????? 
                reslo = 0; 

            } 
        } 
    } 
} 


void li_slow(void) // Funktion Linkslauf langsam 
{ 
    lislo=1; 
    while(lislo) 
    {   
        if(P1_2==0){ 
            P2=0x06; // Bitmuster 1 Linkslauf 
            zeit(5,3000); 
            P2=0x03; // Bitmuster 2 Linkslauf 
            zeit(5,3000); 
            P2=0x09; // Bitmuster 3 Linkslauf 
            zeit(5,3000); 
            P2=0x0C; // Bitmuster 4 Linkslauf 
            zeit(5,3000); 
            if (eingang == 0xEF) 
            { 
                P2=0x00; 
                while(P1_2==0){} 
                lislo = 0; 

            } 
        } 
    } 
} 

void zeit(int i,int k) // Funktion Zeit 
{ 
    unsigned int x; 
    unsigned int y; 
    for(y=0;y<=i;y++) 
    { 
        for(x=0;x<=k;x++); //Int-Wert 62 ergibt 500 Mikrosekunden Delay 
    } 
}

[STK500-Besitzer (Gast)]

Wird "eingang" auch irgendwo noch verändert?

[Karl H. (kbuchegg)]

Deine AUswertung von 'eingang' ist mehr als suspekt.

1) Schreib das doch mit vernüftiger Schreibweise und nicht
   mit Hex-Zahlen

#define PIN_4   4

   if( eingang & (1 << PIN_4) )
   ergibt dann TRUE, wenn der Eingang am Bit 4 eine 1 hat

   if( !( eingang & (1 << PIN_4) ) )
   ergibt dann TRUE, wenn der Eingang am Bit 4 eine 0 führt

   Anstelle von 'PIN_4 nimmt man dann natürlich einen
   vernünftigen Namen, der die FUnktion des Eingangspins wiederspiegelt
   Ist da zb ein Roter Schalter am Port angeschlossen, dann
   könnte man nehmen

#define RED_SWITCH  4

    if( eingang & (1 << RED_SWITCH) )

    dann kann auch ein Blinder greifen, dass hier wohl eine AUswertung
    des roten SChalters erfolgen wird.

    Ist an diesem Pin eine Lichtschranke, die auslöst, wenn die Katzen-
    klappe ihren oberen Totpunkt erreicht hat, dann könnte das heißen

#define KLAPPE_OBEN  4

    if( eingang & (1 << KLAPPE_OBEN) )

     und wieder kann ein Blinder greifen, dass hier wohl die Abfrage
     sein wird, mit der die Endstellung der Katzenklappe überwacht
     wird.

2) In der Hauptschleife vergleichst du das Eingangsbyte mit 0xFE
   Innerhalb der Funktion aber mit 0xEF


Nimm solche Dinge nicht auf die leichte SChulter. Ob Programme leicht zu 
verstehen sind, ob man Fehler leicht findet, hängt nicht unwesentlich 
davon ab, wieviel Geschick du in ein LESBARES Programm steckst. Deine 
Hex-Zahlen sind aber nicht lesbar. Das ist einfach nur eine Zahl, die 
einem beim Programmlesen nichts erzählt, die einem nichts sagt. Ganz 
abgesehen davon, dass es leicht ist, an 2 verschiedenen Programmstellen 
einen Zahlendreher einzubauen ohne es zu merken. Mit ordentlichen Namen 
passiert das nicht.

[Karl H. (kbuchegg)]

Das hier sieht auch suspekt aus

   while(reslo) 
    {       
        if(P1_0==0)
        {

            ....

            if (eingang == 0xEF) 
            { 
                while(P1_0==0)
                {
                }

                reslo = 0; 

            } 
        } 
    }

aus der äusseren while Schleife geht es nur dann raus, wenn reslo zu 0 
wird.
reslo kann aber nur dann 0 werden, wenn

 * P1_0   einen Wert von 0 hat

nur in dem Fall findet dann auch die Abfrage von eingang statt.

 * Kommt da der richtige Wert, dann fängt sich das Programm in einer 
while Schleife die solange läuft wie P1_0 gleich 0 ist.

 * P1_0 muss aber 0 gewesen sein, sonst wärst du überhaupt nie auf die 
Abfrage gekommen.

Ist das so gewollt?

[Gerd (Gast)]

STK500-Besitzer schrieb:
> Wird "eingang" auch irgendwo noch verändert?

Nicht das ich wüsste, dies ist ein quellcode von meinem Lehrer. Dieser 
aber nicht fertig war. Ich habe versucht mittels polling einen Rechts 
und Linkslauf anzusteuern. Ehrlich gesagt kenn ich mich nicht wirklich 
aus und kann jetzt hier groß mitreden. Um jede Hilfe bin ich äußerst 
dankbar.

Lg

[Karl H. (kbuchegg)]

Dazu müsste man erst mal wissen, was diese ganzen Eingänge steuern. Das 
ist (in meinen Augen) ein heilloses Ducheinander.

Wie wählst du aus, ob Rechts/Linslauf?
Wie findet sich das im Programm wieder?

(SChmeiss das Programm weg und schreib es neu. Da blickt doch kein 
Mensch mehr durch, wie das mit den Eingangsabfragen gedacht ist)

[Gerd (Gast)]

Karl Heinz Buchegger schrieb:
> Dazu müsste man erst mal wissen, was diese ganzen Eingänge steuern. Das
> ist (in meinen Augen) ein heilloses Ducheinander.
>
> Wie wählst du aus, ob Rechts/Linslauf?
> Wie findet sich das im Programm wieder?
>
> (SChmeiss das Programm weg und schreib es neu. Da blickt doch kein
> Mensch mehr durch, wie das mit den Eingangsabfragen gedacht ist)

Es wäre schön wenn ich das könnte, ich fühl mich nicht wirklich in der 
Lage gibt es hier vielleicht schon fertige Programme in c.

[Wegstaben V. (wegstabenverbuchsler)]

Gerd schrieb:
> gibt es hier vielleicht schon fertige Programme in c.

wird dann der Autor des fertigen Programmes auch gegenüber deinem Leher 
erwähnt und bekommt eine Note? Dann mach ich auch mit.

[Karl H. (kbuchegg)]

Gerd schrieb:
> Karl Heinz Buchegger schrieb:
>> Dazu müsste man erst mal wissen, was diese ganzen Eingänge steuern. Das
>> ist (in meinen Augen) ein heilloses Ducheinander.
>>
>> Wie wählst du aus, ob Rechts/Linslauf?
>> Wie findet sich das im Programm wieder?
>>
>> (SChmeiss das Programm weg und schreib es neu. Da blickt doch kein
>> Mensch mehr durch, wie das mit den Eingangsabfragen gedacht ist)
>
> Es wäre schön wenn ich das könnte, ich fühl mich nicht wirklich in der
> Lage

Na komm.

Du wirst doch wohl einen Eingang abfragen können! Sonst muss ich mich 
schon fragen, warum du überhaupt auf die Idee kommst, du könntest da 
irgendwas programmieren.

Und die Ansteuerung des Schrittmotors ist doch ganz simpel
Nacheinander die 4 Werte an einem Port ausgeben und dazwischen ein wenig 
warten. Das kann man auch eleganter machen, wie es dein Lehrer dir 
vorgegeben hat, aber fürs erste ist es auch so ok.

Das ist doch nun wirklich keine Raketentechnik.

[Karl H. (kbuchegg)]

Karl Heinz Buchegger schrieb:

> Das ist doch nun wirklich keine Raketentechnik.

..
int main()
{
  ...

  Endlosschleife {

    wenn der Eingang für rechts eingeschaltet ist {
      gib die 4 Werte in der richtigen Reihenfolge für
      Rechtslauf aus
    }

    sonst: wenn der Eingang für links eingeschaltet ist {
      gib die 4 Werte in der richtigen Reihenfolge für
      Linkslauf aus
    }
  }
}

fertig. WEnn da nicht noch irgendwelche Endschalter im SPiel sind, 
sondern es erst mal nur darum geht, dass sich der Motor überhaupt 
rechts/links dreht, dann wars das dann schon.

Jeder der eine LED abhängig davon ob ein Taster gedrückt ist einschalten 
kann, kriegt das hin.

[Gerd (Gast)]

> Jeder der eine LED abhängig davon ob ein Taster gedrückt ist einschalten
> kann, kriegt das hin.
Leider sind noch Endschalter mit im Spiel ich baue Model So zusagen ein 
Rolltor einer Garage hierbei nutze ich Ribkontakte als Endschalter was 
muss ich bei der Programmierung dann beachten etwa mit Polling so wie 
ich es oben bereits versucht habe.

[Karl H. (kbuchegg)]

Gerd schrieb:
>> Jeder der eine LED abhängig davon ob ein Taster gedrückt ist einschalten
>> kann, kriegt das hin.
> Leider sind noch Endschalter mit im Spiel

Dann gibt es eben noch jeweils eine Zusatzbedingung

  ...

  Endlosschleife {

    Wenn der Schalter für Rechtslauf eingeschaltet ist
    UND der Endschalter für den rechten Anschlag nicht eingeschaltet ist

       DANN gibt die 4 Werte für Rechtslauf in der richtigen
          Reihenfolge einmal aus

   ...

Ich wollte dir die Sache für deine ersten Schritte einfach machen, aber 
mir kommt vor, du stehst da wie die Maus vor der Schlange. Vor einem 
Bild einer Schlange, denn du hast schon Angst vor etwas, noch ehe du es 
probiert hast.

[Gerd (Gast)]

Also soweit bin ich jetzt mal. Kann mir jemand sagen ob das soweit sinn 
macht und wie ich jetzt genau die Bedingungen mit den Endschaltern rein 
bekomm?

Ein Beispiel das sich an meinem Quelltext orientiert würde mir sehr 
weiterhelfen

Vielen Dank im Voraus.

[Gerd (Gast)]

Gerd schrieb:
> Also soweit bin ich jetzt mal. Kann mir jemand sagen ob das soweit sinn
> macht und wie ich jetzt genau die Bedingungen mit den Endschaltern rein
> bekomm?
>
> Ein Beispiel das sich an meinem Quelltext orientiert würde mir sehr
> weiterhelfen
>
> Vielen Dank im Voraus.

 #include<t89c51ac2.h>
#include <stdio.h>

 

void verz(unsigned int zaehler);
void verz(unsigned int zaehler){
  unsigned int i;
  for(i=0;i<zaehler;i++){
    }
  }

 unsigned int zaehler=65000;
void main (void){
  P2=0;
  P1=0;
while(1){
  if(P1_0==1){
      P2=0x0C; // Bitmuster 1 Rechtslauf 
            verz(25000 ); // Zeitverzögerung 
            P2=0x09; // Bitmuster 2 Rechtslauf 
            verz( 25000);
            P2=0x03; // Bitmuster 3 Rechtslauf 
            verz(25000 ); 
            P2=0x06; // Bitmuster 4 Rechtslauf 
            verz(25000 );
      
      }
      else if(P1_1==1){
        P2=0x06; // Bitmuster 1 Linkslauf
      verz(25000 ); // Zeitverzögerung 
      P2=0x03; // Bitmuster 2 Linkslauf
      verz(25000 ); // Zeitverzögerung 
      P2=0x09; // Bitmuster 3 Linkslauf
      verz(25000 ); // Zeitverzögerung 
      P2=0x0C; // Bitmuster 4 Linkslauf
      verz(25000 ); // Zeitverzögerung 
         }
        } 
    
    
    
    }

[Hinz (Gast)]

Wenn du deine Port_Pins schon nicht so benennst, dass man als 
Außenstehender direkt sieht, was wo dran hängt, beschreib das doch bitte 
in drei kurzen Sätzen.
Wo legst du in deinem Programm fest, was Eingang und was Ausgang ist?

[Gerd (Gast)]

//P1_0 ist der Eingang für einen Linkslauf

//P1_1 ist der Eingang für den Rechtslauf

P2 ist der Ausgang

[Hinz (Gast)]

Gerd schrieb:
> P2 ist der Ausgang
Dann steht zu vermuten, dass von dem Ausgang P2 nur das untere Nibble 
benutzt wird und darüber direkt die Phasensignale für den Schrittmotor 
ausgegeben werden. Richtig?

Warum legst du nicht einfach ein Array mit den Phasensignalen an und 
nimmst einen Phasenzähler, der bei Linkslauf inkrementiert und bei 
Rechtslauf dekrementiert wird.

Vorausgesetzt, deine beiden Signale für Linkslauf und Rechtslauf (P1_0 
und P1_1) treten nicht gleichzeitig auf, könnte das dann als Pseudocode 
so aussehen

PhaseCode [0..3] = (0x0c, 0x09, 0x03, 0x06)

TSTEP=25000
while (1)
  {
     if (P1_0)      Phase++     'Linkslauf
     else if (P1_1) Phase--     'Rechtslauf

     P2 = PhaseCode[Phase & 0x03)
     delay(TSTEP)
  }

[Gerd (Gast)]

Es ist einfacher gesagt als getan !!!
Könntest du mir vielleicht so ein Quellcode mal schreiben ich komm 
einfach grad gar nicht mehr mit

[Karl H. (kbuchegg)]

Hinz schrieb:

> Warum legst du nicht einfach ein Array mit den Phasensignalen an und
> nimmst einen Phasenzähler, der bei Linkslauf inkrementiert und bei
> Rechtslauf dekrementiert wird.

Machs ihm nicht zu schwer.
Der Mann hat schon Schwierigkeiten genug mit einem simplen logischen 
Und.

Du überforderst ihn gerade.

[Hinz (Gast)]

Gerd schrieb:
> Es ist einfacher gesagt als getan !!!
Was fehlt dir denn?

Grundlage/Referenzen zu C findest du z.B. in
http://de.wikibooks.org/wiki/C-Programmierung

[Gerd (Gast)]

was haltet ihr von dem Quelltext. Es scheint mir als wie es so 
funktionieren könnte. Also wenn ich den Taster P1_0 betätige wird der 
Rechtslauf betätigt, wenn jemand P1_1 zwischenzeitlich betätigt wird 
eine Verriegelung vorgenommen weil nur Eine Laufrichtung eingeschlagen 
werden kann das gleiche gilt auch anderst herum. Kann mir jemand sagen 
wie ich die direkte Umschaltung mache.

lg

#include <t89c51ac2.h> // Header für Controller "AT89C51AC3" 
#include <stdio.h>

#define stepper P1_0  //Eingang für Rechtslauf
#define stepper P1_1   //Eingang für Linkslauf
void delay();

void main()


{
        while(1){
    if(P1_0==0){
                  P2= 0x0C;     //P2 ausgang zum Schrittmotor 
                  delay();
                  P2 = 0x09;
                  delay();
                 P2 = 0x03;
                  delay();
                  P2 = 0x06;
                  delay();
          while(P1_1==0){}
    }   if(P1_1==0){
          P2= 0x06;
                  delay();
                  P2 = 0x03;
                  delay();
                   P2 = 0x09; 
                  delay();
                  P2 = 0x0C;
                  delay();
          while(P1_0==0){}

        }

        }
}
void delay(){
        unsigned char i,j,k;
        for(i=0;i<6;i++)
                for(j=0;j<255;j++)
                        for(k=0;k<255;k++);
}

[Gerd (Gast)]

Kann man dieses Programm in einer Simulation testen um zu schauen, ob 
Schritte übersprungen werden??

[Karl H. (kbuchegg)]

Dazu solltest du dich mal fragen, wie es eigentlich dazu kommt, dass 
Schritte übersprungen werden.

Das passiert nicht, weil die Steuerung die Schritte nicht erzeugt, 
sondern weil der Motor mit der Schritt-Geschwindigkeit nicht mehr 
mitkommt. Das kann sein, weil die Schrittgeschwindigkeit grundsätzlich 
schon zu hoch ist, das kann aber auch sein, weil der Motor banal gesagt, 
es nicht schafft, die Last in der vorgegebenen Zeit eben um einen 
Schritt zu bewegen. Und genau so wie auch du zb einen LKW nicht durch 
Seilziehen aus dem Stand heraus auf 5 km/h beschleunigen kannst (du 
kannst die 5km/h erreichen, wenn man dir genug Zeit lässt und du den LKW 
2 Stunden lang immer ein kleines bischen schneller ziehen kannst) 
genauso schafft es auch ein Schrittmotor nicht, aus den Stand heraus 
eine gewisse Geschwindigkeit zu erreichen, sondern er muss erst mal mit 
kleinen Drehzahlen anfangen um dann sukzessive schneller werden zu 
könnnen.