Gleiches Problem wie: Einmaliges Reagieren auf.

[Michael (Gast)]

Hi Forum,
ich versuche mich gerade an meiner ersten Programmierung eines uCs.
Hierbei bin ich in etwa auf das selbe Problem wie im Beitrag
>> Einmaliges Reagieren auf gleiche, sich mehrfach wiederholende Zustände
gestoßen.

Das Unterbinden einer Ausführung, die auf ein bestimmtes reagiert, ist 
auch mein Problem. Ich hätte da eine Verständnisfrage, die mir hier 
bestimmte einige einfach erklären bzw. Tipps geben könnten, Wie ich im 
besagten Beitrag bereits gelesen habe, setzt man hierzu Flags ein. Meine 
Frage wäre, ob die unten dargestellte Vorgehensweise korrekt ist.

    if( zustand 1 detektiert)
    {
       zustand ausführen;
       flag = 1;
    }


    if( flag == 1)
    {
      if( zustand 1 nicht mehr vorhanden)
      flag = 0;
    }

Man wartet also erst bis der Zustand detektiert wurde und setzt dann ein 
Flag. Wenn Flag = 1 dann wartet das Programm solange bis der Zustand 
nicht mehr vorhanden und setzt dann das Flag zurück. Somit kann beim 
Auftreten des Zustandes wieder reagiert werden. Wäre das so richtig?
Micha

[Oliver J. (skriptkiddy)]

Bitte nicht so abstrakt. Was genau willst du machen?


Gruß Skriptkiddy

[Michael (Gast)]

Hallo Skript Kiddy,

tut mir Leid für die schwammige Beschreibung.

Wie bereits erwähnt habe ich leider in etwa das gleiche Problem wie in 
dem bereits erwähnten Beitrag. Mein Programm soll auf eine Folge von 
Ereignissen nur einmal reagieren. Ich bearbeite ebenfalls serielle Daten 
und dabei tritt das gleiche Zeichen 'A' mehrmals hintereinander auf.

Nach einer bestimmten Zeit tritt das Zeichen nicht mehr auf und es 
werden nur noch '0' gesendet. Wenn die Zeichenfolge 'A' wieder auftritt 
möchte ich wieder reagieren.

ich habe das mal nach dem bereits oben beschriebenen Schema gemacht. 
Allerdings reagiert mein Programm immer auf jedes 'A'.

Ich hoffe ich konnte das jetzt einigermaßen verständlich erklären.

[Skua (Gast)]

Einfach letztes Zeichen merken und vergleichen.

[Oliver J. (skriptkiddy)]

Eine State Machine ist denke ich die sauberste Lösung.

Zwei Zustände: Z0 ZA

Beim Wechsel von Z0 auf ZA tust du was. Bei Wechsel von ZA auf Z0 
nichts. In den Zuständen ebenfalls nichts tun.


Gruß Skriptkiddy

[Volker Z. (vza)]

if(zeichen == 'A' && flag==0)
{
    mach(was);
    flag=1;
}
else
{
   flag=0;
}

so in etwa

[Andreas B. (Gast)]

Michael schrieb:
> if( zustand 1 detektiert)
>     {
>        zustand ausführen;
>        flag = 1;
>     }
>
>
>     if( flag == 1)
>     {
>       if( zustand 1 nicht mehr vorhanden)
>       flag = 0;
>     }

Ins erste if muss noch der Test auf flag rein und das if (flag == 1) 
kannst du dir dann sparen, oder das alles in ein else-Zweig packen:

f()
{
        static bool primed = true;

        if (detected()) {
                if (primed) {
                        do_it();
                        primed = false;
                }
        } else {
                primed = true;
        }
}

[oldmax (Gast)]

Hi
Eigentlich ist doch das gleiche Vorgehen angesagt, wie eine 
Flankenauswertung bei Eingängen. Da ich mit "C" noch auf Kriegsfuss 
stehe, hier mal das Vorgehen:
neues Zeichen lesen und mit abgelegtem Zeichen vergleichen.
Wenn ungleich, dann Flankenmerker setzen und Zeichen in Ablage.
Ist Flankenmerker gesetzt, Zeichen bearbeiten und danach Flankenmerker 
löschen.
Die Ablage wird mit einem Default bei Programmstart belegt.
Gruß oldmax

[mac4ever (Gast)]

if (habs_erkannt == 0){
  if (zeichen_A_erkannt()){
    mach_was();
    habs_erkannt = 1;
  }
}
else  // hier wurde A erkannt und wartet jetzt auf 0
{
  if(zeichen_0_erkann()){
    habs_erkannt = 0;
  }
}

mach_was() wird einmalig ausgeführt. Anschließend wird auf die 
Zeichenfolge '0' gewartet und der Trigger wieder scharf geschaltet

[hanna (Gast)]

Und nicht vergessen, alle Variablen, die oft
und "asyncron" beschrieben werden könnten, als
"volatile" zu deklarieren, damit sie der Compiler
nicht optimiert.