[C] Bitwert in einer Zustandsmaschine abfragen und setzen/löschen

[Alex (Gast)]

Hallo,

habe folgendes Problem:

Programmiere grad an einem Projekt mit einem Tinkerforge µC. Ich habe 
eine Zustandsmaschine programmiert. Diese bekommt von einer Funktion 
einen Wert "*bit" mit 1 oder 0.
Nun möchte ich mit dem Wert *bit verschiedene Bedingungen durchlaufen. 
Je nach dem ob er 1 oder 0 ist. Funktioniert auch soweit nur ein Problem 
taucht auf was ich bis jetzt nicht lösen konnte:

In einer If-Schleife soll der Wert 8 mal (für 1 Byte) aufgerufen werden 
und je nach dem ob 1 oder 0 ist mit 1 oder 0 ausgegeben und 
abgespeichert werden.
Meine bisherige Lösung fragt ja nur einen Wert der am Anfang kommt ab. 
Dieses Problem war mir am Anfang gar nicht aufgefallen...

Kurze Beschreibung warum das ganze:
Ich habe 2 Tinkerforge µC. An dem ersten ist eine LED an dem 2. ein 
Helligkeitssensor. Ich möchte mit der LED Bits übertragen. LED an -> 1, 
aus -> 0
Es soll ein Byte übertragen werden. Am Anfang Startkennung mit 11 und 
dann immer Doppelkodierung mit einer 0 vorweg.

Das Problem tritt in der CASE LESE_BIT: aus

Hier der zusammengefasste Code:

int leseBit(int *bit){
    
    int helligkeit; 
    
    uint16_t illuminance; //lies illuminace(&_______, &helligkeit)
    ambient_light_get_illuminance(&al, &illuminance);
    
    helligkeit = (illuminance/10);
    
    if(helligkeit<SCHWELLWERT)
        *bit =0;
    else
        *bit=1;
}

void state_machine(){

    int j=0;
    int bit;
    
    usleep(500000);
    
    while(1){
    
    leseBit(&bit);       
    
    switch (zustand){
      
    case UNDEF:       
        sleep(1);      
        if(bit){
            printf("1 -> geht zu WARTE: ");
            zustand = WARTE;                    
        }
        else{
            printf("0 -> bleibe in UNDEF: ");
            zustand = UNDEF;
        }
        break;  
             
    case WARTE: 
        sleep(1);
        if(bit){
            printf("1 -> gehe zu VOR_BIT: ");
            zustand = VOR_BIT;                  
        }
        else{
            printf("0 -> bleibe oder gehe in UNDEF: ");
            zustand = UNDEF;
        }
        break; 
            
    case VOR_BIT:
        sleep(1); 
        if(bit){
            printf("1 -> bleibe oder gehe in UNDEF: ");
            zustand = UNDEF;
        }
        else {
            printf("0 -> gehe zu LESE_BIT: ");
            zustand = LESE_BIT;                 
        }
        break;
                
    case LESE_BIT:
   
        for (i=0; i<8; i++) {
            
            if (bit){//((bit<<i)&0x80) {
                sleep(1);
                //bit |= (1<<i);
                printf("1\n");//printf("%d a\n",i);//printf("01");
                //sleep(1);
            }            
            else {
                sleep(1);
                //bit &= ~(1<<i);  
                printf("0\n");//printf("%d b\n",i);//printf("00");
                //sleep(1);
            }            
        }
        
        printf("Byte gesendet -> gehe zu UNDEF: ");
        zustand = UNDEF;

    }
 
    uint16_t illuminance;
    
    if(ambient_light_get_illuminance(&al, &illuminance) < 0) {
    fprintf(stderr, "Could not get value, probably timeout\n");
    exit(1); 
    }
    
    printf("Illuminance: %f Lux\n", illuminance/10.0);
    
    }
    
}

[Karl H. (kbuchegg)]

Du kannst hier keine for-Schleife machen

    case LESE_BIT:
   
        for (i=0; i<8; i++) {
            
            if (bit){//((bit<<i)&0x80) {
                sleep(1);
                //bit |= (1<<i);
                printf("1\n");//printf("%d a\n",i);//printf("01");
                //sleep(1);
            }            
            else {
                sleep(1);
                //bit &= ~(1<<i);  
                printf("0\n");//printf("%d b\n",i);//printf("00");
                //sleep(1);
            }            
        }

denn du würdest ja 8-mal dasselbe Bit behandeln.

Aber:
Du kannst natürlich mitzählen! Im zu LESE_BIT vorgelagerten Zustand 
setzt du dir einen Zähler auf 0 und jedesmal, wenn du in LESE_BIT kommst 
(weil dein Timing ja mit sleep gesteuert ist) erhöhst du diesen Zähler. 
Ist er bei 8 angelangt, dann hast du alle 8 Bit gelesen.

Also so ungefähr

    case VOR_BIT:
        sleep(1); 
        if(bit){
            printf("1 -> bleibe oder gehe in UNDEF: ");
            zustand = UNDEF;
        }
        else {
            printf("0 -> gehe zu LESE_BIT: ");
            zustand = LESE_BIT;
            bitZaehler = 0;                 
        }
        break;
                
    case LESE_BIT:
      if(bitZaehler == 8) {
        printf("alle 8 Bit eines Bytes empfangen -> gehe zu UNDEF: ");
        zustand = UNDEF;    
      }
      else {
        bitZaehler++;

        if (bit){
            ....

Im übrigen kommen mir in deinem Code etwas zuviele sleep vor. Wenn das 
mal gut geht. Die ganze Zustandsmaschine sieht so gesehen nicht richtig 
aus, weil du dich nie auf irgendeine Flanke synchronisierst, an der du 
dann deine tatsächlichen Zeiten loslaufen lassen könntest. Auch denke 
ich, dass ein nicht ganz unwesentlicher Anteil an der Funktionsfähigkeit 
deiner Zustandsmaschine darin besteht, dass auch ein printf Zeit 
benötigt. So gesehen, beeinflusst dein Messmittel das zu untersuchende 
System. Aber das wirst du dann schon noch sehen, wenn die mal alle weg 
sind.

[Alex (Gast)]

Ok, danke!

Die printf's sind nur zum ersten nachvollziehen. Die verschwinden dann 
alle. Genauso die Sleep's. ist nur für den Anfang zum nachvollziehen. 
Ansonsten funktioniert es jetzt. DANKE!