Hallo

bin dabei ein Programm mit Funktionen, SerPrint und switched zu schreiben
Benutze die AsuroLib und Asuroflash. SerPrint bringt mir nur Mist, ist deshalb auskommentiert.
Wenn ich GoTurnFront ohne Tastencheck betreibe, bleib das Monster jedes mal stehen, wenn switched einen Taster erkennt.
In dem unterren Programm will ich über Taste 1 gerade aus fahren und über Taste 3 im Quadrat.
Tastencheck unterscheidet die Tasten und aktiviert die SatutsLED sowie programmiert. Nur die !switched verhält sich bei quadrat richt ( bleibt sofort stehen wenn ein Taster switched verändert. Bei geradeaus wird kein switched erkannt.
Code:
//##############################################################################
// DemoProgramm für 08032008 über Taster Module auswahlbar
// Hinderniserkennung immer bei allen Modulen
// quadrat fahren
// gerade fahren  50cm ok Front ok


#include <asuro.h>
#include <myasuro.h>


  int  programme=0;    // Programmnummer  0 = kein Programm gewählt


// GoTurnFront  Funktion wie GoTurn plus Hindernisserkennung
  void GoTurnFront  (
  int distance,
  int degree,
  int speed)
{
  int l_speed =speed;      // linke Geschwindigkeit
  int r_speed = speed;     // rechte Geschwindigkeit
  int tot_count = 0;       // gefahrene Ticks
  int diff = 0;            // differenz zwischen linkes und rechtes Odometer
  unsigned  long  enc_count; // Vorgabewert der Ticks

  /* if distance is NOT zero, then take this value to go ... */
  if (distance != 0)
  {
    // Umrechnen der mm in Ticks
    enc_count  = abs (distance) * 10000L;
    enc_count /= MY_GO_ENC_COUNT_VALUE;
    // positiv Vorwaert negativ Rueckwaerts
    if (distance < 0)
      MotorDir (RWD, RWD);
    else
      MotorDir (FWD, FWD);
  }
  // wenn keine distance dann nur dregree drehen auf der stelle
  else
  {
    // Umrechnen des degree Winkels in Ticks
    enc_count  = abs (degree) * MY_TURN_ENC_COUNT_VALUE;
    enc_count /= 360L;
  // positiv in Uhrzeigersinn negativ gegen Uhrzeigersinn
    if (degree < 0)
      MotorDir (RWD, FWD);
    else
      MotorDir (FWD, RWD);
  }

  // encoder Vorgabewert linke und rechte Seite ist null
  EncoderSet (0, 0);

  StartSwitch();     // Frondkontakte aktivieren Flag=0 kein Kontakt,1= Kontakt
  switched = FALSE;  // Vorbereitung für neuen Aufruf von StartSwitch()

  // Motoren einschalten mit linker und rechter Geschwindigkeit
  MotorSpeed (l_speed, r_speed);


//Begin der while Schleife   #####################################
// sollange Ist Ticks kleiner Soll Ticks und kein Frondkontakt (!switched
  while (tot_count < enc_count && !switched)
  {
     StatusLED(RED);    // in der While Schleife
     switched = FALSE;  // Vorbereitung für neuen Aufruf von StartSwitch()

     tot_count += encoder [LEFT];    //IstTick ist linke Seite
     diff = encoder [LEFT] - encoder [RIGHT];  // differenz bilden

     if (diff > 0)     // wenn differnz groesser als null
     { // Linke Seite schneller wie Soll oder rechte Seite ist groeßer 244
        if ((l_speed > speed) || (r_speed > 244))
          l_speed -= 10;     // linke seite um 10 reduzieren
        else
          r_speed += 10;     // rechte Seite um 10 erhoehen
     }

     if (diff < 0)          // wenn differnz kleiner als null
     { //rechte Seite schneller wie Soll oder linke Seite ist groeßer 244
        if ((r_speed > speed) || (l_speed > 244))
          r_speed -= 10;     // rechte seite um 10 reduzieren
        else
          l_speed += 10;     // linke seite um 10 erhoehen
     }
     /* reset encoder */
     EncoderSet (0, 0);
     // Motoren einschalten mit linker und rechter Geschwindigkeit
     MotorSpeed (l_speed, r_speed);
     Msleep (1);

  } // Ende der Endlosschleife Nr.1

  MotorDir (BREAK, BREAK);
  Msleep (200);
  StatusLED(YELLOW);
  Msleep(200);
  StatusLED(RED);
  Msleep(200);
  StatusLED(GREEN);
  Msleep(200);

  StatusLED(YELLOW);

} // Ende GoTurnFunktion
//##########################################################################
void geradeaus50cm(void)
{

  GoTurnFront (2000,  0, 150);

  programme=0;       // Programmnummer auf 0 kein Programmm gewählt
} // Ende Funktion
//##########################################################################
void geradeaus(void)
{
  int i;          // Laufvariable i
   // Laesst den Asuro ein gerade von 500 mm fahren,
   // bei einer Geschwindigkeit von 150.

   for (i = 0; i < 1; i++)      // nur 1 mal
   {
       GoTurnFront (500,  0, 150);
       Msleep(10);
   }
   programme=0;       // Programmnummer auf 0 = kein Programmm gewählt
} // Ende Funktion
//##########################################################################
void quadrat80cm(void)
{
  int i;          // Laufvariable i
   // Laesst den Asuro ein Quadrat von 500 mm fahren,
   // bei einer Geschwindigkeit von 150.

   for (i = 0; i < 4; i++)      // 4 mal von 0 bis 3
   {
       // GoTurnFront aufrufen
       //         (distance,degree,speed)
       // SerPrint ("GoTurn 200, 0,150\r");
       GoTurnFront (0,  90, 150);  // entspricht Go   (200, 150)
       Msleep(10);
       GoTurnFront (  500, 0, 150);  // entspricht Turn ( 90, 150)
   }
   programme=0;       // Programmnummer auf 0 kein Programmm gewählt
} // Ende Funktion
//##########################################################################
void Kontakt1(void)          // Kontakt 1
{ //  Anfang Funktion
        //    FrontLED(OFF);
            StatusLED(RED);
            Msleep(1000);     // warte 1 sekunde
            programme=1;
} // Ende Funktion
//##########################################################################
void Kontakt2(void)          // Kontakt 2
{ //  Anfang Funktion
         //   FrontLED(OFF);
            StatusLED(YELLOW);
            Msleep(1000);     // warte 1 sekunde
            programme=2;
} // Ende Funktion
//##########################################################################
void Kontakt3(void)          // Kontakt 3
{ //  Anfang Funktion
        //    FrontLED(OFF);
            StatusLED(GREEN);
            Msleep(1000);     // warte 1 sekunde
            programme=3;
} // Ende Funktion
//##########################################################################
void Kontakt4(void)          // Kontakt 4
{ //  Anfang Funktion
        //    FrontLED(ON);
            StatusLED(RED);
            Msleep(1000);     // warte 1 sekunde
            programme=1;

} // Ende Funktion
//##########################################################################
void Kontakt5(void)          // Kontakt 5
{ //  Anfang Funktion
       //     FrontLED(ON);
            StatusLED(YELLOW);
} // Ende Funktion
//##########################################################################
void Kontakt6(void)          // Kontakt 6
{ //  Anfang Funktion
        //    FrontLED(ON);
            StatusLED(GREEN);
} // Ende Funktion
//##########################################################################
void Kontaktnull(void)          // Kontakt kein
{ //  Anfang Funktion
        //   FrontLED(OFF);
            StatusLED(OFF);
} // Ende Funktion

//##########################################################################
void Tastencheck(void)
{ //  Anfang Funktion
  unsigned char sw;
  //SerPrint("Tastencheck\r\n");
  //for (;;)
  //{
    sw = PollSwitch();
    if (sw == 0x00) Kontaktnull();
    if (sw == 0x01) Kontakt1();
    if (sw == 0x02) Kontakt2();
    if (sw == 0x04) Kontakt3();
    if (sw == 0x08) Kontakt4();
    if (sw == 0x10) Kontakt5();
    if (sw == 0x20) Kontakt6();
  //}
} // Ende Funktion
//##########################################################################


// Anfang Hauptschleife
int main(void)
{
//##########################################################################
// Anfangsbediengungen Initialisieren
    Init();          // damit ATMEGE8 weiss was seine Pinne machen sollen
    EncoderInit();   // Wird fuer Odometer gebraucht

  //FrontLED(ON);     // Rote Led unten an
  StatusLED(GREEN); // Statusanzeige ist Grün an
 StartSwitch();
 switched = FALSE;  // Vorbereitung für neuen Aufruf von StartSwitch()

  //SerPrint("Demo Roboterplattform\r\n");

  Msleep(1000);     // warte 1 sekunde
//##########################################################################
  while (1)     // Beginn der Endlosschleife Nr.1
   {
        Tastencheck();    // Tasten interpretieren

       Msleep(100);     // warte 0,1 sekunde
       if (programme==1) geradeaus();
       if (programme==3) quadrat80cm();

   }             // Ende der Endlosschleife Nr.1
   while (1) {}     // verhindert ein Aufrufen alter Programme
   return 0;
}

//##########################################################################
Bin für jeden Rat dankbar
Gruß
Juelicher