C-Schleife die wartet bis bedingung erfüllt ist

[duke (Gast)]

hi,

ich bin neu in sachen C-Programmieren hab mich nun mal en bissle durch
forum gelesen und en bissle gegoogelt allerdings nichts gefunden.

Und zwar suche ich eine C-Schleife die wartet bis eine bestimmt
bedingung erfüllt und zwar muss ich einen sensor abfragen und dann
dementsprechend ein ventil schalten allerdings darf dies erst geschen
wenn der sensor aktiv ist!!!

Ich hoffe einer versteht mein Problem bin leider noch blutiger anfänger
und brauch noch en bissle stütze fürn anfang :-)

gruß

[Chief Brady (Gast)]

bool BedingungErfuellt = false

while ( !BedindungErfuellt )
{
  :
  :
  wasserstand = SensorAbfrage()
  if ( wasserstand > max_wasserstand ) BedingungErfuellt = true
  :
}

[Egon (Gast)]

while(bedingung_erfuellt == 0);  // warten bis != 0

Dies ist aber schlechter Stil. Es fehlt ein Timeout, damit das Programm
nicht hängen bleibt.

[duke (Gast)]

ok erstmal danke fr die infos ich werde mich gleich mal drangeben und es
versuchen!!!

danke

[inoffizieller WM-Rahul (Gast)]

Vielleicht solltest du dir erst mal einen Plan malen (auch Struktogramm,
Ablaufdiagramm genannt).
Solche Sachen sind sprachenunabhängig, und die Elemente, die es in
diesem Bereich gibt, werden von jeder Programmiersprache unterstützt.
Also: Werde dir über das Problem klar, fasse es in Worte und/oder
Bilder und setze dieses dann in eine Programmiersprache deiner Wahl
ein.

In C gibt es 3-4 Sorten von Schleifen, mit denen man dein Problem auf
verschiedene Arten lösen kann.
Auch wenn es nicht besonders beliebt ist: Auch bei Programmiersprachen
muß man Vokabeln lernen und die Grammatik verstehen.

Zu deinem Problem:

#include<sensor.h>
void main(void)
{

  warte_bis_sensor_laueft();
  while(1)
  {
     fragesensorab();
     zeigewertan();
   }
}

warte_bis_sensor_laueft(); fragesensorab(); und zeigewertan();
werden in sensor.h definiert...

[crazy horse (Gast)]

so in etwa.
Allerdings blockiert so eine Vorgehensweise den MC komplett, d.h. er
kann nichts anderes mehr machen - wenn er das auch nicht muss, kann man
das so machen.
Besser ist es, sich einen regelmässigen Timerinterrupt  zu
programmieren  (z.B. alle 10ms), dort den Eingang befragen und
entsprechende Aktionen auslösen. Somit bleibt der MC frei für andere
Aufgaben.

[Harry (Gast)]

Aber was ist wenn man sagen wir mal nur 480us warten will, soll man da
auch einen Interrupt nehmen?

[duke (Gast)]

hi,

also programm ablaufplan und so hab ich mir ja schon alles gemacht bin
halt nur grad dabei mit c anzufangen ich muss mich da jetzt auch
erstmal reindenken und die ganzen verschiedenen schleifen
kennenlernen.

Es ist mir auch klar das ich Vokabeln und Grammatik lernen muss aber
nach zwei wochen weiß man auch nciht alles über c oder lieg ich da
falsch!!!

[duke (Gast)]

@Chief Brady

Ich hab mal das ausprobiert was du mir geschrieben hast allerdings ist
das ja fast der gleiche effekt wie wenn ich eine do-while schleifen
benutze.
Ich will das,dass Programm so lange auf der Abfrage nach dem Sensor
stehen bleibt bis der Sensor aktiv wird und dann erst weiter läuft.

[Profi (Gast)]

Bei manchen µC gibt es auch Interrupt-on-change (manchmal
Keyboard-Interrupt genannt), d.h. ein Interrupt wird ausgelöst, wenn
ein InputPin den Zustand ändert.
Für die fallende Flanke könnte man sogar eine Serielle Schnittstelle
zweckentfremden, da diese bei Low-Pegel ein Byte empfängt und einen
Interrupt auslöst.

[Schoasch (Gast)]

Naja.. es gibt 3 Arten von Schleifen.

1.
for-Schleifen:
for(i=0;i<9;i++);
{
....
}
Diese Schleife verwendet man, wenn man eine Aufgabe n-Mal wiederholen
woll.

2.
while-Schleife:
while(flag)
{
..
}
Diese Schleife benutzt man meistens dann, wenn man auf ein Ereignis
wartet, welches von "ausserhalb" beeinflusst wird. zb wenn man darauf
wartet das der ADC sein Flag setzt und somit signalisiert, dass er
fertig ist.

3.Dann gibt es noch die do-while-Schleife
do{

}while(flag)
Sie ist so ähnlich wie die while Schleife, nur das sie 1 mal
durchlaufen wird und das die abfrage am ende der Schleife gemacht wird
und nicht am anfang.

So.. das ist halt nur eine kleine Erklärung..

[Karl heinz B. (kbucheg)]

> Ich will das,dass Programm so lange auf der Abfrage nach dem Sensor
> stehen bleibt bis der Sensor aktiv wird und dann erst weiter läuft.

Ein Programm kann nicht 'auf einer Abfrage stehen bleiben'.
Sprich: Der Prozessor hört auf zu arbeiten bis eine
Bedingung erfüllt ist.
Ein Prozessor arbeitet immer. Er macht immer irgendetwas.

Daher ist die wortwörtliche Umsetzung dessen was
du willst:

  while( Bedingung nicht erfüllt )
    tue_nichts;

Das macht genau das was du willst. Andere haben schon beschrieben
das sowas bei etwas längeren Wartezeiten keine so gute Idee ist
und warum das so ist.

[duke (Gast)]

ja so ähnlich hatte ich mir das auch mal gedacht allerdings hab ich das
problem das ich 16 sensoren habe und nicht soviele Int_Inputs.
Ich brauch doch einfach nur ne schleife die solange läuft bis ein
bestimmter wert da ist (1=ON 0=OFF) und wenn der wert nicht erreicht
ist einfach nur an den anfang der schleife zurück springt und wieder
durchläuft solange bis der sensor anspricht.

Es soll wenn es fertig ist eine Elektropneumatische steuerung für eine
prüfstation werden.

[Karl heinz B. (kbucheg)]

while( Wert != Dein_Vorausberechneter_Wert )
  ;

[Schoasch (Gast)]

Uh... und der standardfehler den man meist macht bei schleifen ist bei
mir auch.
Bei der for-Schleife gehört das Semikolon natürlich nicht hin.
Also richtig ist:
for(i=0;i<9;i++)

sorry

[Peter D. (peda)]

"Aber was ist wenn man sagen wir mal nur 480us warten will, soll man
da
auch einen Interrupt nehmen?"


Hängt ganz von Deiner konkreten Anwendung ab, ob diese Wartezeit
toleriert werden kann oder nicht.

Ich hab auch mal 1-wire in nen Timerinterrupt verlagert, der dann alle
480µs oder 60µs aufgerufen wird.
Der muß dann aber die höchste Priorität (8051-Derivat) kriegen, da 60µs
mal schnell von anderen Interrupts aufgebraucht werden.


Peter

[Karl heinz B. (kbucheg)]

Natürlich musst du dafür sorgen, dass Wert überhaupt eine
Chance hat sich zu ändern.

Das kann jetzt sein, dass eine Interrupt Funktion regelmäßig
die Sensoren abfragt und die Variable verändert oder aber
du musst innerhalb der Schleife die Sensoren abfragen:

 Wert = Sensoren_Abfragen();
 while( Wert != Dein_Vorausberechneter_Wert )
   Wert = Sensoren_Abfragen();

Da du hier aber Sensoren_Abfragen() auf jeden Fall mindestens
einmal aufgerufen haben möchtest, würde sich eine do-while
Schleife anbieten:

  do {
    Wert = Sensoren_Abfragen();
  } while( Wert != Dein_Vorausberechneter_Wert );

[Unbekannter (Gast)]

> Wert = Sensoren_Abfragen();
> while( Wert != Dein_Vorausberechneter_Wert )
>   Wert = Sensoren_Abfragen();

Der Code ist doch hässlich. Man kann das in C auch eleganter
formulieren:


  int wert;
  while ( (wert=sensor_abfragen()) != erwarteter_wert )
    if ( abbruch_bedingung() )
      break;

  if ( wert == erwarteter_wert )
  {
    // mach was damit
  }
  else
  {
    // Behandle Abbruch
  }

Dieses Thema hat natürlich unendliche Variationen...