Schleife vorzeitig bei Bedingung verlassen

Hallo,
ich habe eine Frage zur Programmierung.
Ich habe folgende Situation:

while (Bedingung)
{
Anweisungen...... (dauer ca 30 sek.)
}

Ein Durchlauf der Schleife dauert ca. 30 Sekunden. Ich möchte aber gerne sobald die Bedingung der While Schleife weg fällt die Schleife sofort verlassen. Und nicht erst nach dem sie ganz durchlaufen ist und wieder bei der Abfrage steht.
Ist das mögich?

Was und wieso dauert die Schleife 30 Sekunden?
Die einzige Möglichkeit ist die Schleife kürzer zu machen zb mit einer Zustandsvariablen und millis() statt delay().
Grüße Uwe

Sigguino:
Ein Durchlauf der Schleife dauert ca. 30 Sekunden. Ich möchte aber gerne sobald die Bedingung der While Schleife weg fällt die Schleife sofort verlassen. Und nicht erst nach dem sie ganz durchlaufen ist und wieder bei der Abfrage steht.
Ist das mögich?

Hallo,

probier das doch mal so:

while(bedingung == true) {
    Anweisungen;
    if(bedingung == false)
        break;
    Anweisungen;
}

Guckst Du hier: while-Schleife

Gruß,
Ralf

Sigguino:
Ein Durchlauf der Schleife dauert ca. 30 Sekunden. Ich möchte aber gerne sobald die Bedingung der While Schleife weg fällt die Schleife sofort verlassen. Und nicht erst nach dem sie ganz durchlaufen ist und wieder bei der Abfrage steht.
Ist das mögich?

Das ist möglich mit "if ... break;".

Aber wenn Du 30 Sekunden lang laufende Busy-Waiting-Loops in Deinem Programm hast, ist entweder das grundlegende Programmdesign völlig verkorkst und Du kannst während der Programmblockierung gar nichts anderes mehr machen. Also beispielsweise nicht mal mehr auf eine "Not-Aus" Bedingung reagieren.

Oder Du blockierst Dein Programm gerne und es macht überhaupt nichts aus, dass es immer in 30-Sekunden-Blöcken blockiert wird.

Busy-Waiting-Loops sind wie delay(): Sie blockieren den Programmablauf für alles, was sonst noch gleichzeitig laufen soll, z.B. die Überwachung von Tasten oder anderen interaktiven Bedienelementen.

jurs:
[Aber wenn Du 30 Sekunden lang laufende Busy-Waiting-Loops in Deinem Programm hast, …

Hai,

meinst Du das ist so? Ich hatte die Frage eher so verstanden, dass der TO eine while()-Schleife hat, die so voll Anweisungen gepackt ist, dass deren Ausführung halt ca. 30s dauert.

Wenn Du allerdings Recht hast und die while()-Schleife wirklich 30s nur wartet, sollte der TO sein Programm-Design überdenken.

Gruß,
Ralf

Ich habe so verstanden, daß die Anweisungen in der While Schleife 30 Sekunden brauchen. Das ist aber auch nich weniger verkorkst als daß die While Schleife 30 Sekunden aud TRUE wartet. :wink:
Grüße Uwe

uwefed:
Ich habe so verstanden, daß die Anweisungen in der While Schleife 30 Sekunden brauchen. Das ist aber auch nich weniger verkorkst als daß die While Schleife 30 Sekunden aud TRUE wartet. :wink:

Tja, man weiß es nicht. Wäre halt schön bei so einer Fragestellung ein paar Infos mehr zu haben (Wink mit dem Zaunpfahl an Sigguino :fearful: ).

Gruß,
Ralf

Also wir ihr bereits gemerkt hab bin ich neu im Thema “C” und Mikrocontroller. Ich komme aus der “S7” Welt.

Folgendes ist die Anweisung um die es sich hierbei handelt:

{
lcd1.clear();
  lcd1.print("Carrera Deluxe");
  delay(1000);

  // scroll 13 positions (string length) to the left 
  // to move it offscreen left:
  for (int positionCounter = 0; positionCounter < 13; positionCounter++)
  {     
    lcd1.scrollDisplayLeft(); 
    delay(150);
  }

  // scroll 29 positions (string length + display length) to the right
  // to move it offscreen right:
  for (int positionCounter = 0; positionCounter < 29; positionCounter++) 
  {
    lcd1.scrollDisplayRight(); 
    delay(150);
  }
  
    // scroll 16 positions (display length + string length) to the left
    // to move it back to center:
  for (int positionCounter = 0; positionCounter < 16; positionCounter++)
  {
    lcd1.scrollDisplayLeft(); 
    delay(150);
  }

 lcd1.clear();
}

Sigguino:
Also wir ihr bereits gemerkt hab bin ich neu im Thema "C" und Mikrocontroller. Ich komme aus der "S7" Welt.

Kooperatives Multitasking zu programmieren funktioniert eigentlich immer gleich:
Du darfst ein Programm nicht mit "delay" blockieren, wenn "gleichzeitig" noch etwas anderes laufen soll.

Wie z.B. scrollende Texte auf einem LCD-Display realisiert werden können, habe ich hier im Forum auch schon mal gezeigt:
http://forum.arduino.cc//index.php?topic=176732.msg1312111#msg1312111

Der Beispiel-Sketch scrollt dabei Text in zwei LCD-Zeilen, einmal etwas schneller von rechts nach links und einmal etwas langsamer von links nach rechts. Und es wird nirgends ein delay (blockierte Programmausführung) verwendet.

Das Programmieren von kooperativem Multitasking funktioniert im Endeffekt so, dass Du Funktionen programmierst, die nur ganz kurze Ausführungszeiten haben.

Also statt der nicht kooperativen Logik:

void meineFunktion()
{
  starteIrgendwas();
  blockiereDasProgrammMitDelay(); 
 beendeirgendwas();
}

Kooperativ:

void meineFunktion()
{
  WennNichtsZuTunIst return; 
  if (EtwasSollGestartetWerden())  starteIrgendwas();
  if (EtwasSollBeendetWerden())  beendeirgendwas();
}

Bei der nicht kooperativen Logik läuft immer nur eine Funktion zur Zeit. Und läuft, und läuft, und läuft, bis sie fertig ist. Nebenbei kann nichts anderes gemacht werden.

Bei der kooperativen Logik wird die Funktion aus der loop heraus wieder und wieder aufgerufen. Wenn nichts zu tun ist, ist die Funktion blitzschnell zu Ende. Und wenn etwas zu tun ist, wird es erledigt und die Funktion ist fast genau so schnell zu Ende.

Ok Vielen Dank für die Hilfestellung.
Ich werde mich vom delay verabschieden :smiley: