Hallo
ich habe ein kleines Problem bei einem Bit löschen in einer Bytevariable, die in einer Klasse definiert ist. Ich verwende GCC in verbindung mit Arduino.

Also ich habe eine Klasse geschrieben namens StateMachine. Diese wird im Hauptprogramm von Arduino in der Objekt-Variable Machine instanziert.
Die Klasse enthält unter anderem eine Routine setState(), in der der der Zustand der Maschine gesetzt wird. In der Routine wird zusätzlich ein Flag gesetzt, welches anzeigt, dass sich der Zustand geändert hat.
Eine Andere Routine stateChanged() liefert einen Booleanwert, ob das Flag gesetzt oder gelöscht ist. Weiterhin löscht diese Routine das Flag wieder, welches anzeigt, dass sich der Zustand geändert hat.

Das Setzen des Flags funktioniert wunderbar, das löschen jedoch nicht.

Hier die beiden Routinen:

Code:
/*
 *    Setzt den gewünschten Zustand der Statemaschine
 *    Zusätzlich wird Flag STATE_CHANGED gesetzt, um zu ermitteln, ob der Zustand sich geändert hat.
 */
void StateMachine::setState(tagStates newState)
{
   currentState = newState;         // Zustand setzen
   mFlags |= (1<<STATE_CHANGED);    // Flag setzen, dass Zustand geändert wurde
}
und die Flagabfrage

Code:
/*
 *    Gibt den Status des Flags STATE_CHANGED zurück und löscht das Flag
 */
boolean StateMachine::stateChanged()
{
   return boolean(mFlags and STATE_CHANGED);        // Flag zurück geben
   mFlags &= ~(1<<STATE_CHANGED);                   // Flag löschen, dass Zustand geändert wurde
}
hier noch die Header-Datei:
Code:
#ifndef statemachine_h
#define statemachine_h

#include <Arduino.h>

/*
 *    Enumeration mit den zulässigen Maschinen-Zuständen
 */
enum tagStates    // Zustände der Statemachine
   {
      STATE_MAIN=0,
      STATE_1
   };

/*
 *    Klasse StateMachine
 */
class StateMachine
{
   public:
      
      void setState(tagStates newState);     // State setzen
      enum tagStates getState();             // State abrufen
      boolean stateChanged();                // State-Flag STATE_CHANGED prüfen
      byte getMFlags();                      // MaschineFlags abrufen

   private:
      enum tagStates currentState;           // Variable nimmt aktuellen Maschinen-Zustand auf
      byte mFlags=0;                         // Diverse Flags innerhalb der Zustands-Maschine
      byte const STATE_CHANGED=7;            // Flag-Definition (Bit-Nr)

};

#endif           // statemachine_h
In der Hauptschleife habe ich im Augenblick folgenden Code:

Code:
// ------------------------------------
// Hauptschleife
// ------------------------------------
void loop() {
   // put your main code here, to run repeatedly:

   Serial.println(Machine.getMFlags());
   
   switch (Machine.getState())
   {
      case STATE_MAIN:
         if (Machine.stateChanged()!=0)
         {
            Serial.println("Zustand in STATE_MAIN geändert");
            
            delay(1000);
         }
         else
         {
            Serial.println("Zustand STATE_MAIN stabil!");
            delay(1000);
         }
         break;
   }
}
Kann mir jemand sagen was ich falsch mache? Wieso kann ich das Bit STATE_CHANGED in der privaten Variable MFlags nicht löschen?
Auch wenn ich in stateChanged() MFlags=0 angebe, wird das Flag nicht gelöscht.
Stehe ich auf dem Schlauch?

Micha.