Probleme mit dem Preprozessor. Er verrechnet sich! Oder mach ich was falsch?

[Leo B. (luigi)]

Servus beisammen,

Folgender Code baut offensichtlich ziemlich Mist und ich finde nicht 
heraus warum:

#define F_PROG  39
#define T0_PSC  1024

#define W_OPOS  0b11100000
#define W_POW  0b11010000

#ifndef F_CPU
#define F_CPU  10000000
#endif



// Berechnungen
#define F_T0    (F_CPU/T0_PSC)
#define TIMER0_TOP  (2*F_T0/F_PROG+1)/2        // clever runden
#define F_PROG_REAL  (F_CPU/TIMER0_TOP/T0_PSC)        // Reale Programmfrequenz
#define F_PROG_ERR  ((F_PROG_REAL*1000)/F_PROG-1000) // Fehler in Promille
#if (TIMER0_TOP > 255)
  #error "Programmfrequenz kann mit dem Prescaler von Timer0 nicht eingestellt werden!"
#endif
#if ((F_PROG_ERR>100) || (F_PROG_ERR<-100))      // max. +/-100 Promille Fehler
  #error "Systematischer Fehler der Programmfrequenz grösser 10 Prozent und damit zu hoch!"




// Ab hier nurnoch Debugausgabe
#define TEST    (F_CPU/TIMER0_TOP)
#endif
#if (F_PROG==39)
  #error "F_PROG==39"
#endif
#if (F_T0==9765)
  #error "F_T0==9765"
#endif
#if (TIMER0_TOP==250)
  #error "TIMER0_TOP==250"
#endif
#if (F_PROG_REAL==9)
  #error "F_PROG_REAL"
#endif
#if (F_PROG_ERR==-770)
  #error "F_PROG_ERR==-770"
#endif
#if (TEST==9980)
  #error "TEST==9980"
#endif

Ich erhalte dabei folgende Fehler:

../def_ini.h:44:4: error: #error "Systematischer Fehler der Programmfrequenz grösser 10 Prozent und damit zu hoch!"
../def_ini.h:47:4: error: #error "F_PROG==39"
../def_ini.h:50:4: error: #error "F_T0==9765"
../def_ini.h:53:4: error: #error "TIMER0_TOP==250"
../def_ini.h:56:4: error: #error "F_PROG_REAL==9"
../def_ini.h:59:4: error: #error "F_PROG_ERR==-770"
../def_ini.h:62:4: error: #error "TEST==9980"

Mach ich was falsch?
Wo könnte der Fehler liegen?

Danke schonmal euch allen
lg Leo

[Jörg W. (dl8dtl) (Moderator)]

Leo B. schrieb:
> #define TIMER0_TOP  (2*F_T0/F_PROG+1)/2        // clever runden

Da muss in der Ersetzung noch ein Klammerpaar drumrum.
Präprozessor berechnet ja an dieser Stelle keinen Wert, sondern er
setzt nur sukzessive alle rechten Seiten der Makros ein, und da
kommt ohne Klammer dann Mist raus.

Ich habe aber auch erst ein

avr-gcc -dM -E foo.c | sort | less

gebraucht, um das zu begreifen. ;-)

[Leo B. (luigi)]

OK, das verstehe ich jetzt nicht ganz...
Soweit mir bekannt kennt der Preprozessor die "Punkt vor Strich"-Regel. 
Trotzdem funktioniert das Ganze mit Klammern da drum. Ich kanns nicht 
ganz nachvollziehen aber es klappt...

Danke Danke!

Und den Weg wie du da drauf gekommen bist muss ich mir morgen aneignen 
^^
Das " | sort | less" scheint mir noch recht interessant zu sein.

Danke nochmal!

[Klaus Falser (Gast)]

Leo B. schrieb:
> #ifndef F_CPU
> #define F_CPU  10000000
> #endif

Sollte das ganze für den AVR sein, dann kann es noch zzsätzliche 
Probleme geben, weil 10000000 nicht in einer 16 bit Integer Zahl platz 
hat.
Dann muss man 10000000UL verwenden.

[Peter II (Gast)]

Klaus Falser schrieb:
> Sollte das ganze für den AVR sein, dann kann es noch zzsätzliche
> Probleme geben, weil 10000000 nicht in einer 16 bit Integer Zahl platz
> hat.
der Preprozessor weiss aber nicht das es ein AVR ist. Es kommt darauf an 
was später mit F_CPU  gemacht wird. Ich glaube nicht das diese Zahl in 
einer Variabel vom Typ int gespeichert wird - warum auch?

[(prx) A. K. (prx)]

Leo B. schrieb:

> OK, das verstehe ich jetzt nicht ganz...

Der Präprozessor rechnet erst im #if. Davor macht er nur 
Textersetzungen. Aus

#define TIMER0_TOP  (2*F_T0/F_PROG+1)/2
#define F_PROG_REAL (F_CPU/TIMER0_TOP/T0_PSC)

wird daher (vereinfacht)

#define F_PROG_REAL (F_CPU/(2*F_T0/F_PROG+1)/2/T0_PSC)

und das ist nicht eben nicht das Gleiche wie

#define F_PROG_REAL (F_CPU/((2*F_T0/F_PROG+1)/2)/T0_PSC)

Daraus leitet sich die Daumenregel ab, dass man Rechenausdrücke in 
#define immer einklammern sollte. Man weiss nie was sonst draus wird.

[Klaus Falser (Gast)]

Peter II schrieb:
> Klaus Falser schrieb:
>> Sollte das ganze für den AVR sein, dann kann es noch zzsätzliche
>> Probleme geben, weil 10000000 nicht in einer 16 bit Integer Zahl platz
>> hat.
> der Preprozessor weiss aber nicht das es ein AVR ist. Es kommt darauf an
> was später mit F_CPU  gemacht wird. Ich glaube nicht das diese Zahl in
> einer Variabel vom Typ int gespeichert wird - warum auch?

Siehe oben.
Der Präprocessor rechnet nicht. Am Ende kommt eine Wurst von Anweisungen 
heraus, und diese wird vom Compiler nach den C Regeln aufgelöst.
Und wenn dort steht (10000000/8) dann wird beim AVR die 10000000 zuerst 
auf 16 bit integer gekürzt und dann (falsch) durch 8 dividiert.

[(prx) A. K. (prx)]

Für ähnliche Überraschungen ist übrigens auch dieser Code gut:

#define TRACE(x) if (trace) printf(x)

if (a > 100)
  TRACE("Sollte nicht vorkommen");
else 
  printf("Hallo");

weil sich das dem Compiler tatsächlich als

if (a > 100)
  if (trace) 
    printf(x);
  else 
    printf("Hallo");

darstellt.

Schreibt man statt dessen

#define TRACE(x) if (trace) { printf(x); }

dann kriegt man de fakto

if (a > 100)
  if (trace) { printf(x); }; 
else 
  printf("Hallo");

und damit einen Syntax Error.

Aus diesem Grund klammert man das gern als

#define TRACE(x) do{ if (trace) printf(x); }while(0)

[(prx) A. K. (prx)]

Klaus Falser schrieb:

> Der Präprocessor rechnet nicht.

An exakt einer Stelle tut er es doch: im #if Statement.

[Stefan E. (sternst)]

Klaus Falser schrieb:
> Und wenn dort steht (10000000/8) dann wird beim AVR die 10000000 zuerst
> auf 16 bit integer gekürzt und dann (falsch) durch 8 dividiert.

Nein.
10000000 hat den Typ long, und auch die Division wird in long gemacht.

[Klaus F. (kfalser)]

Stefan Ernst schrieb:
> Klaus Falser schrieb:
>> Und wenn dort steht (10000000/8) dann wird beim AVR die 10000000 zuerst
>> auf 16 bit integer gekürzt und dann (falsch) durch 8 dividiert.
>
> Nein.
> 10000000 hat den Typ long, und auch die Division wird in long gemacht.

Nicht so viel ich weiß.

10000000L ist eine Konstante vom Type long.
10000000  ohne L ist eine Konstante vom Type integer. Auf 32 bit 
Rechnern wird sie als integer darstellbar sein, auf 16 bit Rechnern 
nicht.
C spezifiziert 16 Bit als minimum für integer, deshalb ist auch auf 8 
Bit Rechnern ein int 16 bit lang.

[(prx) A. K. (prx)]

Klaus Falser schrieb:

> 10000000L ist eine Konstante vom Type long.
> 10000000  ohne L ist eine Konstante vom Type integer.

Lexikalische Konstanten ohne Suffix sind vom kleinsten Typ in den sie 
problemlos reinpassen. Anfangend bei "int", bei hex/oct weiter mit 
"unsigned", dann "long", etc. Daher hängt es von der Zielmaschine ab, ob 
10000000 "int" oder "long" ist.

Das bedeutet übrigens auch, dass auf einer 16-Bit Zielmaschine 32768 
"long" ist, das vom Wert her identische 0x8000 aber "unsigned".