AVR C - Rückgabewert von Funktion nicht richtig

[J. B. (jbme)]

Hallo zusammen,

ich habe folgenden Code, der in der while-Schleife hängen bleibt (auch 
wenn ENFG = 1 ist):

void at90can_can_controller_activate(void)
{
  // -- CAN General Control Register --
  CANGCON |= (1 << ENASTB);  // enable mode -> activate CAN controller
  //wait for controller to be enabled  
        while(at90can_can_controller_get_status() != 1);
}

uint8_t at90can_can_controller_get_status(void)
{
  return CANGSTA & (1 << ENFG);
}

Füge ich jetzt die Abfrage direkt ein, dann funktioniert es:

void at90can_can_controller_activate(void)
{
  // -- CAN General Control Register --
  CANGCON |= (1 << ENASTB);  // enable mode -> activate CAN controller
  //wait for controller to be enabled  
        while(CANGSTA & (1 << ENFG) != 1);
}

Hat jemand eine Erklärung dafür?
Danke im vorraus!

[Stefan F. (Gast)]

Wenn
> ENFG = 1
ist, dann ist
> (1 << ENFG)
gleuch 2, und
> CANGSTA & (1 << ENFG)
ist immer entweder 0 oder 2, so dass
> at90can_can_controller_get_status() != 1
immer wahr ist.

[my2ct (Gast)]

J. B. schrieb:
> Hat jemand eine Erklärung dafür?

> CANGSTA & (1 << ENFG)

Das ist ein boolscher Ausdruck. Warum vergleichst du den mit 1?
Ist bei die im System true als 1 definiert?
Portierbar ist etwas anderes.

[Stefan F. (Gast)]

my2ct schrieb:
> Das ist ein boolscher Ausdruck.

Falls du das & meinst: Nein, das ist eine bitweise Verknüpfung:4

    CANGSTA = 2 = 0b00000010
(1 << ENFG) = 2 = 0b00000010
                 ------------
Ergebnis von &:   0b00000010

Das Ergebnis ist 2, wenn beide Operanden = 2 sind. Und zwei ist wahr, 
wenn man es in einem booleschen Ausdruck verwendet. Kleiner Test mit 
if():

#include <stdio.h>

int main()
{
    int ENFG=1;
    
    int CANGSTA=0;
    if (CANGSTA & (1 << ENFG))
    {
        printf("CANGSTA=0 ist wahr \n");
    }
    
    CANGSTA=1;
    if (CANGSTA & (1 << ENFG))
    {
        printf("CANGSTA=1 ist wahr \n");
    }
    
    CANGSTA=2;
    if (CANGSTA & (1 << ENFG))
    {
        printf("CANGSTA=2 ist wahr \n");
    }
}

Erzeugt die Ausgabe:

CANGSTA=2 ist wahr

Aber: Beim TO ist das kein Boolescher Ausdruck. Er liefert das Ergebnis 
als uint8_t zurück. Deswegen ist sein Ergebnis immer 0 oder 2, also 
niemals 1.

[Peter D. (peda)]

J. B. schrieb:
> while(CANGSTA & (1 << ENFG) != 1);
> Hat jemand eine Erklärung dafür?

Weil das was völlig anderes macht.
Zuerst wird != ausgeführt, danach erst das &.

https://en.cppreference.com/w/c/language/operator_precedence

[Rolf M. (rmagnus)]

J. B. schrieb:
> uint8_t at90can_can_controller_get_status(void)

Sinnvoll wäre, den Rückgabetyp in bool zu ändern.

[STK500-Besitzer (Gast)]

Rolf M. schrieb:
> J. B. schrieb:
>> uint8_t at90can_can_controller_get_status(void)
>
> Sinnvoll wäre, den Rückgabetyp in bool zu ändern.

oder auf != 0 zu testen

[Stefan F. (Gast)]

STK500-Besitzer schrieb:
> oder auf != 0 zu testen

Das Pendant zu != 1 wäre == 0.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

J. B. schrieb:
> Füge ich jetzt die Abfrage direkt ein, dann funktioniert es:
Wenn du "bleibt nicht hängen" als "funktioniert es" definierst, dann 
schon.

J. B. schrieb:
> auch wenn ENFG = 1 ist
ENFG ist laut Datenblatt das Bit 2 im Register CANGSTA und damit ist der 
#define ENFG auch immer 2.
Du meinst vermutlich den Pegel des Flags ENFG.

Peter D. schrieb:
> Zuerst wird != ausgeführt, danach erst das &.
Und weil 1<<2 = 4 und damit 4 != 1 ist, ist das Ergebnis dieses 
Vergleichs 1. Und deshalb wird mit der Abfrage:
while(CANGSTA & (1 << ENFG) != 1);
tatsächlich das abgefragt:
while(CANGSTA & 1);
und das betrifft das ERRP Bit, das nur dann 1 wird, wenn der Controller 
in den Fehlermodus geht.

@  J. B. (jbme)
Im Grunde musst du deine Abfrage also so schreiben, dann passiert das, 
was du eigentlich wollltest:
while( (CANGSTA&(1<<ENFG)) != (1<<ENFG) );

Und natürlich musst du diese Geschichte auch bei dem 
Funktionsrückgabewert beachten.

my2ct schrieb:
>> CANGSTA & (1 << ENFG)
> Das ist ein boolscher Ausdruck.
Du verwechselst das binäre "&" mit dem logischen "&&"

[J. B. (jbme)]

Vielen Dank für eure Antworten! Ich habe meinen Code entsprechend 
angepasst:

void at90can_can_controller_activate(void)
{
  // -- CAN General Control Register --
  CANGCON |= (1 << ENASTB);  // enable mode -> activate CAN controller
  //wait for controller to be enabled  
  while(at90can_can_controller_get_status() == false);
}

bool at90can_can_controller_get_status(void)
{
  return CANGSTA & (1 << ENFG);
}

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

J. B. schrieb:
> return CANGSTA & (1 << ENFG);
Diese Rechung ergibt 4, wenn das ENFG Flag gesetzt ist.
Wenn aber ein bool mit 1=true und 0=false ist, was ist dann mit diesen 
4?

Wenn du also schon einen boolschen Rückgabewert definierst, dann 
solltest du korrekterweise auch einen boolschen Wert für die Rückgabe 
berechnen:

return (CANGSTA & (1<<ENFG)) != 0; // gibt true zurück, wenn das Flag gesetzt ist

Und dann liest sich sowas natürlich doof:

if (at90can_can_controller_get_status() == false)

Wenn du das nämlich in einem Jahr liest, dann denkst du dir:
Was zum Senkel soll denn an dem Controllerstatus "falsch" oder "wahr" 
sein?

[J. B. (jbme)]

Tatsächlich habe ich nachdem ich meinen vorherigen Beitrag geschrieben 
habe nochmals umgeändert, weil ich mir genau das, was du erwähnt hast, 
auch gedacht habe...

NOCHMAL EIN DICKES DANKESCHÖN!

[Stefan F. (Gast)]

>> return CANGSTA & (1 << ENFG);

Lothar M. schrieb:
> Diese Rechung ergibt 4, wenn das ENFG Flag gesetzt ist.
> Wenn aber ein bool mit 1=true und 0=false ist, was ist dann mit diesen
> 4?

Er liefert true zurück, wenn der Ausdruck wahr ist. Und 4 ist wahr.

Das ist eine Besondertheit bei bool.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Stefan ⛄ F. schrieb:
> Er liefert true zurück, wenn der Ausdruck wahr ist.
Es wird "false" zurückgegeben, wenn der arithmetische Wert == 0 ist.
Und sonst kommt "true" zurück.

> Und 4 ist wahr.
Es ist nicht "falsch". Glück gehabt...  ;-)

[Stefan F. (Gast)]

Lothar M. schrieb:
> Es ist nicht "falsch". Glück gehabt...  ;-)

Ja. Ich habe mir das so gemerkt: Alle Zahlen die nicht 0 sind, sind 
wahr.

Oder meinetwegen auch "nicht falsch".