Präprozessor Fehler oder der vorm PC? Ich hoffe der am PC

[Jörg E. (jackfritt)]

Hallo liebe Forumsteilnehmer,
folgendes Problem: Wenn man den Teil unten mit

 
#if 1
......
#endif

auskommentiert (#if 0 ;) dann gibt es keine Fehlermeldung ala:

../main.c:56:32: error: missing binary operator before token "("
 #define T0_COUNTER  (uint16_t) ((1.0 * F_CPU / (( T0_PRESCALE * BAUD ) + 0.5)))
                                ^
../main.c:66:48: note: in expansion of macro 'T0_COUNTER'
 #define BAUD_REAL_NEW (F_CPU/(T0_PRESCALE * (( T0_COUNTER / 2 )+1)))     // Reale Baudrate
                                                ^
../main.c:71:26: note: in expansion of macro 'BAUD_REAL_NEW'
 #define BAUD_ERROR_NEW ((BAUD_REAL_NEW*1000)/BAUD)
                          ^
../main.c:77:7: note: in expansion of macro 'BAUD_ERROR_NEW'
 #if ((BAUD_ERROR_NEW <990) || (BAUD_ERROR_NEW >1010))
       ^
make: *** [main.o] Error 1

Ich bin ratlos. Bitte um Erleuchtung. Danke schonmal.

#include <avr/io.h>
#include <inttypes.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <util/delay.h>

#undef F_CPU
#define F_CPU 8000000
// Berechnungen
#define     BAUD 9600

// --------------------------------------------------------
// Timer0 ist 8 Bit
// Wir berechnen den optimalen Prescale-Faktor
// --------------------------------------------------------

#define T0_MAX_COUNTER    256UL

// --------------------------------------------------------
// 8-Bit Timer - Timer0
// --------------------------------------------------------
#define _T0_PRESCALE_0    (0)
#define _T0_PRESCALE_1    (1<<CS00)
#define _T0_PRESCALE_8    (1<<CS01)
#define _T0_PRESCALE_64    (1<<CS01 | 1<<CS00)
#define _T0_PRESCALE_256  (1<<CS02)
#define _T0_PRESCALE_1024  (1<<CS02 | 1<<CS00)

// --------------------------------------------------------
// Timer0 Vorteiler für Baudrate berechnen
// --------------------------------------------------------
#if (F_CPU  / BAUD ) < T0_MAX_COUNTER
# define T0_PRESCALE    1UL      // prescaler :1
# define T0_PRESCALE_VALUE  _T0_PRESCALE_1

#elif (F_CPU  / (BAUD  * 8UL )) < T0_MAX_COUNTER
# define T0_PRESCALE    8UL      // prescaler :8
# define T0_PRESCALE_VALUE  _T0_PRESCALE_8

#elif (F_CPU  / (BAUD  * 64UL )) < T0_MAX_COUNTER
# define T0_PRESCALE    64UL      // prescaler :64
# define T0_PRESCALE_VALUE  _T0_PRESCALE_64

#elif (F_CPU  / (BAUD  * 256UL )) < T0_MAX_COUNTER
# define T0_PRESCALE    256UL      // prescaler :256
# define T0_PRESCALE_VALUE  _T0_PRESCALE_256

#elif (F_CPU  / (BAUD  * 1024UL)) < T0_MAX_COUNTER
# define T0_PRESCALE    1024UL      // prescaler :1024
# define T0_PRESCALE_VALUE  _T0_PRESCALE_1024

#else
# error "T0_FREQUENCE"
#endif

#define T0_COUNTER  (uint16_t) ((1.0 * F_CPU / (( T0_PRESCALE * BAUD ) + 0.5)))
// in T0_PRESCALE_VALUE stehen dann Bit-Werte für den Prescaler.
//#define TEST1 ( T0_COUNTER / 2 )

// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BIT_TIME UBRR_VAL * 2
#define BIT_TIME_ALT (int) (1000000.0/((float) BAUD)+0.5)
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_REAL_ALT (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_REAL_NEW (F_CPU/(T0_PRESCALE * (( T0_COUNTER / 2 )+1)))     // Reale Baudrate

#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.
#define BAUD_ERROR_ALT ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.

#define BAUD_ERROR_NEW ((BAUD_REAL_NEW*1000)/BAUD)

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif
#if 1
#if ((BAUD_ERROR_NEW <990) || (BAUD_ERROR_NEW >1010))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif
#endif
int main() { //Wayne ?
}

[Karl H. (kbuchegg)]

Der Präprozessor ist nicht der Compiler.
Mit einem uint16_t kann der nichts anfangen.

#define T0_COUNTER  (uint16_t) ((1.0 * F_CPU / (( T0_PRESCALE * BAUD ) + 0.5)))
                     ********

[Kaj (Gast)]

Jörg Esser schrieb:
> Präprozessor Fehler oder der vorm PC? Ich hoffe der am PC
Was haben diese Fehler mit deinem PC zu tun?

[Karl H. (kbuchegg)]

Und wenn ich den Rest so sehe: Nope. Der Präprozessor kann auch 
offiziell nicht Floating Point rechnen.

[Karl H. (kbuchegg)]

Ich denke, du verwechselst da was. Oder bedenkst es nicht.

Natürlich kannst du schreiben

#define PI 3.141592654

int main()
{
  double radius = 5.0;
  double area = 2 * PI * radius;
}

und der Präprozessor ersetzt dir PI durch 3.141592654.
Aber das ist eine reine Textersetzung! Dem Präprozessor ist es 
grundsärtzlich wurscht, was du im #define als Ersatztext für PI 
angegeben hast.

Wenn du den Präprozessor aber nötigst, den Ersatztext zu interpretieren

#if (PI > 2 )
  #error "Pi ist zu gross"
#endif

dann muss der Präprozessor mit dem Ersatztext tatsächlich arbeiten. Und 
da gibt es Einschränkungen. Hier ist PI nicht nur einfach ein Text der 
durch einen anderen Text ersetzt wird. Das was dann durch die Ersetzung 
entsteht muss auch den syntaktischen Anforderungen des Präprozessors 
entsprechen. Und der ist da viel einfacher gestrickt als der Compiler.

[Jörg E. (jackfritt)]

Ok verstanden. Vielen Dank Karl Heinz. Ich werde mal versuchen den Teil 
als Präprozessortauglichen Text umzuschreiben.

[Daniel (Gast)]

Kaj schrieb:
> Was haben diese Fehler mit deinem PC zu tun?

Gemeint ist kein Fehler am PC sondern vor dem PC, PEBCAK also (Problem 
Exists Between Chair And Keyboard)

[Kaj (Gast)]

Daniel schrieb:
> Gemeint ist kein Fehler am PC sondern vor dem PC, PEBCAK also (Problem
> Exists Between Chair And Keyboard)
Ah ok, dann hab ich nichts gesagt :)

[R. F. (rfr)]

OSI Ebene 8 halt.

Gruss

Robert

[Name (Gast)]

Jörg Esser schrieb:
>

> ../main.c:56:32: error: missing binary operator before token "("
>  #define T0_COUNTER  (uint16_t) ((1.0 * F_CPU / (( T0_PRESCALE * BAUD ) 
> + 0.5)))
>

Sieht aus, als ob dem Compiler uint16_t nicht bekannt ist und dadurch 
den Cast nicht erkennt (ein generelles Problem von C's typedefs - ein 
typedef-Identifier ändert die Syntax; jenachdem was 'a' ist, ist 
'(a)(b)' gültig oder ein Syntaxerror).

[Jim M. (turboj)]

Name schrieb:
> Sieht aus, als ob dem Compiler uint16_t nicht bekannt

Falsch. Erstens ist da inttypes.h included (und damit uint16_t bekannt) 
und zweitens ist das innerhalb einer Präprozessor #if Anweisung. Damit 
muss das bereits vom Präprozessor ausgewertet werden können - der kann 
aber kein uint16_t typecast.