Arduino Parser belügt mich

[makroOderMeinFehler (Gast)]

Nee der lügt natürlich nicht. Aber es wirkt so.

Ich hab gerade eine Meldung, die ich nicht nachvollziehen kann

#define COUNT  54  // Anzahl Digitalpins (Wert 54)
#define PIN    A0  // Analoger Pin A0    (Wert 54)

#if (PIN < COUNT)
#error PIN ist zu klein
#endif

void setup() {
  Serial.begin(9600);
  delay(500);
  Serial.print("COUNT = ");
  Serial.println(COUNT);
  Serial.print("A0 = ");
  Serial.println(A0);
}

void loop() {
}

Beim compilieren kommt eine Fehlermeldung

exit status 1
#error PIN ist zu klein

Wenn ich die Prüfung des Makros auskommentiere, compiliert der Code und 
es wird 2x 54 angezeigt, was auch korrekt ist. Und wieso kriegt der 
Parser das nicht hin?

[at-user (Gast)]

Trag doch mal für PIN "100" ein ...

[Rufus Τ. F. (rufus)]

Zeig' das #define von A0.

Das ist ziemlich sicher nicht der numerische Wert 54.

[makroOderMeinFehler (Gast)]

Rufus Τ. F. schrieb:
> Zeig' das #define von A0.
>
> Das ist ziemlich sicher nicht der numerische Wert 54.

Ja iwas stimmt nicht. Nur: print gibt für "A0" definitiv 54 aus. Was 
m.E. auch ok ist.

[makroOderMeinFehler (Gast)]

Gut. Ich werde also auf die Suche gehen, wo A0 definiert ist. Hat jemand 
einen Tipp, in welcher h ich beginnen soll?

[at-user (Gast)]

Schonmal drangedacht dass "A0" eine CONST Variable ist und kein 
Präprozessor Makro?

[Theor (Gast)]

makroOderMeinFehler schrieb:
> Rufus Τ. F. schrieb:
>> Zeig' das #define von A0.
>>
>> Das ist ziemlich sicher nicht der numerische Wert 54.
>
> Ja iwas stimmt nicht. Nur: print gibt für "A0" definitiv 54 aus. Was
> m.E. auch ok ist.

Wie auch immer: Schaue Dir die Definition von A0 an.
Es wird sich vermutlich herausstellen, dass A0 zur Kompilationszeit und 
zur Laufzeit zwei verschiedene Wirkungen hat.

[at-user (Gast)]

https://electronics.stackexchange.com/questions/67087/analogread0-or-analogreada0

hardware/arduino/avr/variants/standard/pins_arduino.h

static const uint8_t A0 = 14;
static const uint8_t A1 = 15;
static const uint8_t A2 = 16;
static const uint8_t A3 = 17;
static const uint8_t A4 = 18;
static const uint8_t A5 = 19;
static const uint8_t A6 = 20;
static const uint8_t A7 = 21;

[at-user (Gast)]

Das obige kopierte stimmt natürlich nicht. Hier sind die richtigen 
Konstanten:

static const uint8_t A0 = 54;
static const uint8_t A1 = 55;
static const uint8_t A2 = 56;

[Stefan F. (Gast)]

Auszug aus der Datei hardware/arduino/avr/variants/mega:

#define PIN_A0   (54)
static const uint8_t A0 = PIN_A0;

A0 ist eine Variable im RAM. Auf solche Variablen kann der Präprozessor 
nicht zugreifen.

[makroOderMeinFehler (Gast)]

at-user schrieb:
> Schonmal drangedacht dass "A0" eine CONST Variable ist und kein
> Präprozessor Makro?

Nee. Aber wenn du recht hast erklärt es den Effekt

In pins_arduino.h ist A0 aber auch definiert

#define PIN_A0   (14)

static const uint8_t A0 = PIN_A0;

hat at-user ja auch gerade geschrieben

Nur dann verstehe ich nicht, wieso 54 ausgegeben wird.

Oder ist A0 ein Pointer und print gibt den Inhalt aus? Ich verstehs noch 
nicht

[makroOderMeinFehler (Gast)]

Stefanus F. schrieb:
> Auszug aus der Datei hardware/arduino/avr/variants/mega:
>

> #define PIN_A0   (54)
> static const uint8_t A0 = PIN_A0;
>

>
> A0 ist eine Variable im RAM. Auf solche Variablen kann der Präprozessor
> nicht zugreifen.

OK. Der Klick kam langsam. Aber jetzt ist er auch bei mir angekommen.

Vielen Dank :)

[at-user (Gast)]

>Nur dann verstehe ich nicht, wieso 54 ausgegeben wird.

54 ist der Inhalt der in der Variable drin steht, die du gerade 
ausliest.
A0 ist kein Pointer, sondern ein ganz normaler Integer.
Println() wandelt dir automatisch deinen Integer in einen String um und 
gibt diesen aus.

[makroOderMeinFehler (Gast)]

at-user schrieb:
>>Nur dann verstehe ich nicht, wieso 54 ausgegeben wird.
>
> 54 ist der Inhalt der in der Variable drin steht, die du gerade
> ausliest.
> A0 ist kein Pointer, sondern ein ganz normaler Integer.
> Println() wandelt dir automatisch deinen Integer in einen String um und
> gibt diesen aus.


OK noch eine Frage zum verständnis: Was "sieht" der Parser, wenn er A0 
sieht?

[makroOderMeinFehler (Gast)]

#define COUNT  54  // Anzahl Digitalpins (Wert 54)
#define PIN    A0  // Analoger Pin A0    (Wert 54)

Und was mir noch -etwas- unklar ist:
PIN wird aber vom Parser bestückt, der den Wert A0 nicht erkennt.
Im Programm -runtime- hat PIN dann aber dann doch den korrekten Wert 54.

Das würde ich gerne verstehen.

[Dr. Sommer (Gast)]

static_assert funktioniert mit Konstanten und Makros:

static_assert(PIN >= COUNT, "PIN ist zu klein");

Bei der Gelegenheit kann man auch direkt die dumme Textersetzung via 
Makro durch richtige Konstanten ersetzen:

static constexpr uint8_t COUNT = 54;
static constexpr auto PIN =  A0;

[at-user (Gast)]

>Was "sieht" der Parser, wenn er A0 sieht?

Nichts, er ignoriert es, weil keine Zuordnung bekannt ist. Es existiert 
kein "#define A0", deswegen wird A0 niemals Aufmerksamkeit schenken.

[at-user (Gast)]

>Im Programm -runtime- hat PIN dann aber dann doch den korrekten Wert 54.

Ja logisch, weil der Parser alles mit "PIN" durch "A0" ersetzt. Es ist 
so als hättest DU A0 statt PIN geschrieben!

Bitte hier die Grundlagen nachholen:
http://public.beuth-hochschule.de/~kempfer/skript_c/Kap10.html

[Dr. Sommer (Gast)]

makroOderMeinFehler schrieb:
> OK noch eine Frage zum verständnis: Was "sieht" der Parser, wenn er A0
> sieht?

Der Parser vom Präprozessor und der vom Compiler sehen beide ein 
Terminalsymbol "A0".

makroOderMeinFehler schrieb:
> PIN wird aber vom Parser bestückt, der den Wert A0 nicht erkennt

Der Parser liest nur Dinge ein. Der verarbeitet und ersetzt gar nichts. 
Makro-Textersetzung würde der Präprozessor nach dem Parsen machen, 
wenn A0 denn ein Makro wäre. Der Präprozessor - welcher das #if und 
#error auswertet - sieht nicht dass die beiden A0 zusammen hängen.

Der Compiler sieht erst eine Definition von A0 als Konstante. Bei der 
Nutzung von A0 sucht er die gleichnamige Konstante (gäbe es eine lokale 
Variable namens A0, würde diese stattdessen gefunden). Das Constant 
Folding im Optimizer wird den Wert 54 an die Stelle der Nutzung 
übertragen und da in die "ldi"-Instruktion einsetzen, die hier 
wahrscheinlich genutzt wird. Ein sehr dummer Compiler der keinerlei 
Optimierung vornimmt, könnte die Konstante stattdessen in den RAM legen 
(beim Start initialisiert) und dann bei der Nutzung erst aus dem RAM 
laden (z.B. per "lds") und dann an println übergeben.

at-user schrieb:
> Ja logisch, weil der Parser alles mit "PIN" durch "A0" ersetzt

Der Parser ersetzt nichts. Das macht der Präprozessor.

[Stefan F. (Gast)]

Der Präprozessor ersetzt Text. Wenn du schreibst:

#define PIN_A0   (54)
static const uint8_t A0 = PIN_A0;
#define PIN A0
Serial.println(PIN);

Wird daraus:

static const uint8_t A0 = (54);
Serial.println(A0);

Nach dieser Textersetzung wird dein Quelltext compiliert.