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

Jörg E. #3893944
Lesenswert?
• ▲
▼ 
Hallo liebe Forumsteilnehmer,
folgendes Problem: Wenn man den Teil unten mit
1
 

2
#if 1

3
......

4
#endif

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

1
../main.c:56:32: error: missing binary operator before token "("

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

3
                                ^

4
../main.c:66:48: note: in expansion of macro 'T0_COUNTER'

5
 #define BAUD_REAL_NEW (F_CPU/(T0_PRESCALE * (( T0_COUNTER / 2 )+1)))     // Reale Baudrate

6
                                                ^

7
../main.c:71:26: note: in expansion of macro 'BAUD_REAL_NEW'

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

9
                          ^

10
../main.c:77:7: note: in expansion of macro 'BAUD_ERROR_NEW'

11
 #if ((BAUD_ERROR_NEW <990) || (BAUD_ERROR_NEW >1010))

12
       ^

13
make: *** [main.o] Error 1

Ich bin ratlos. Bitte um Erleuchtung. Danke schonmal.
1
#include <avr/io.h>

2
#include <inttypes.h>

3
#include <avr/interrupt.h>

4
#include <avr/sleep.h>

5
#include <util/delay.h>

6


7
#undef F_CPU

8
#define F_CPU 8000000

9
// Berechnungen

10
#define     BAUD 9600

11


12
// --------------------------------------------------------

13
// Timer0 ist 8 Bit

14
// Wir berechnen den optimalen Prescale-Faktor

15
// --------------------------------------------------------

16


17
#define T0_MAX_COUNTER    256UL

18


19
// --------------------------------------------------------

20
// 8-Bit Timer - Timer0

21
// --------------------------------------------------------

22
#define _T0_PRESCALE_0    (0)

23
#define _T0_PRESCALE_1    (1<<CS00)

24
#define _T0_PRESCALE_8    (1<<CS01)

25
#define _T0_PRESCALE_64    (1<<CS01 | 1<<CS00)

26
#define _T0_PRESCALE_256  (1<<CS02)

27
#define _T0_PRESCALE_1024  (1<<CS02 | 1<<CS00)

28


29
// --------------------------------------------------------

30
// Timer0 Vorteiler für Baudrate berechnen

31
// --------------------------------------------------------

32
#if (F_CPU  / BAUD ) < T0_MAX_COUNTER

33
# define T0_PRESCALE    1UL      // prescaler :1

34
# define T0_PRESCALE_VALUE  _T0_PRESCALE_1

35


36
#elif (F_CPU  / (BAUD  * 8UL )) < T0_MAX_COUNTER

37
# define T0_PRESCALE    8UL      // prescaler :8

38
# define T0_PRESCALE_VALUE  _T0_PRESCALE_8

39


40
#elif (F_CPU  / (BAUD  * 64UL )) < T0_MAX_COUNTER

41
# define T0_PRESCALE    64UL      // prescaler :64

42
# define T0_PRESCALE_VALUE  _T0_PRESCALE_64

43


44
#elif (F_CPU  / (BAUD  * 256UL )) < T0_MAX_COUNTER

45
# define T0_PRESCALE    256UL      // prescaler :256

46
# define T0_PRESCALE_VALUE  _T0_PRESCALE_256

47


48
#elif (F_CPU  / (BAUD  * 1024UL)) < T0_MAX_COUNTER

49
# define T0_PRESCALE    1024UL      // prescaler :1024

50
# define T0_PRESCALE_VALUE  _T0_PRESCALE_1024

51


52
#else

53
# error "T0_FREQUENCE"

54
#endif

55


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

57
// in T0_PRESCALE_VALUE stehen dann Bit-Werte für den Prescaler.

58
//#define TEST1 ( T0_COUNTER / 2 )

59


60
// Berechnungen

61
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden

62
#define BIT_TIME UBRR_VAL * 2

63
#define BIT_TIME_ALT (int) (1000000.0/((float) BAUD)+0.5)

64
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate

65
#define BAUD_REAL_ALT (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate

66
#define BAUD_REAL_NEW (F_CPU/(T0_PRESCALE * (( T0_COUNTER / 2 )+1)))     // Reale Baudrate

67


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

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

70


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

72


73
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))

74
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!

75
#endif

76
#if 1

77
#if ((BAUD_ERROR_NEW <990) || (BAUD_ERROR_NEW >1010))

78
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!

79
#endif

80
#endif

81
int main() { //Wayne ?

82
}
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Karl H. #3893976
Lesenswert?
• ▲
▼ 
Ich denke, du verwechselst da was. Oder bedenkst es nicht.

Natürlich kannst du schreiben
1
#define PI 3.141592654

2


3
int main()

4
{

5
  double radius = 5.0;

6
  double area = 2 * PI * radius;

7
}


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
1
#if (PI > 2 )

2
  #error "Pi ist zu gross"

3
#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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Name Gast #3894799
Lesenswert?
• ▲
▼ 
Jörg Esser schrieb:
>
1
> ../main.c:56:32: error: missing binary operator before token "("

2
>  #define T0_COUNTER  (uint16_t) ((1.0 * F_CPU / (( T0_PRESCALE * BAUD ) 

3
> + 0.5)))

4
>


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).
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren