Schwierigkeiten mit c macros

[macro (Gast)]

Hallo.


Gibt es die Möglichkeit, den Wert einer Variablen mittels macro in einen 
string zu konvertieren? Das ganze sollte so aussehen:


#define MAC(x)  #x


char var = "B";
char B;

 MAC(var) = 3;  <--  hier sollte dann stehen:  B = 3;



Bitte um Hilfe. :)

[Dominik S. (dasd)]

???
Was soll das bringen?

[Sebastian W. (sebastian_w29)]

macro schrieb:
> #define MAC(x)  #x
>
> char var = "B";
> char B;
>
>  MAC(var) = 3;  <--  hier sollte dann stehen:  B = 3;

#x (stringify) in einem Makro verwandelt x in einen String. MAC(var) = 
3; wird also zu "var" = 3;

Was du möchtest geht nicht, weil der Preprozessor den Inhalt von 
Variablen nicht kennt.

LG, Sebastian

[macro (Gast)]

Sebastian W. schrieb:
> Was du möchtest geht nicht, weil der Preprozessor den Inhalt von
> Variablen nicht kennt.

Vielen dank Sebastian für die Info. :)


Gibt es sonst eine Möglichkeit, so etwas zu machen wenn auch nicht mit 
defines? Ich möchte, dass der Benutzer in einem vorgegebenen Datei 
einfach schreiben kann:

  Init.Port = "A";
  Init.Pin  = "A5";

und ich dann an diversen Stellen in meinem Program einfügen kann:

  DDR + Init.Port |= (1<<Init.Pin); <-- also das soll dann bedeuten DDRA 
|= (1<<A5);


Wie macht man sowas? :)

[lange weg (Gast)]

du schreibst dir ein programm welches dann aus der config datei aus 
Init.Port = "A" ein #define INIT_PORT A macht und in code wird nicht 
Init.Port sondernINIT_PORT verwendet...

das programm wird im make prozess mit eingebunden und wird für dem 
compile porzess ausgeführt

So etwas "ähnliches" machen wir hier, da die debugg messages im Code 
nicht ins Flash gehen werden diese mit ID's versehene. Vorm Compilieren 
werden alle Texte in einer Datenbank hinterlegt mit einer ID und das 
Programm fügt im Text Macro die ID ein wenn noch nicht vergeben. und 
dann wird kompilert. für die Betrachtung auf der Konsole braucht man 
natürlich eine eigene Konsole die die IDs wieder in Strings verwandelt.

Grüße

[XTALE (Gast)]

lange weg schrieb:
> du schreibst dir ein programm welches dann aus der config datei aus
> Init.Port = "A" ein #define INIT_PORT A macht

Hmm. Wie würde das konkret aussehen? So vll.:

switch (Init.Port)
{
    catch A:
         #define INIT_PORT  A
    break;
    ...
}

[Oliver (Gast)]

In den Anwender-Parameter-header kommt das hier:

#define INITPORT A
#define INITPIN 5

In deinen header dann das hier:

#define CONCAT2(a,b) a##b
#define CONCAT(a,b) CONCAT2(a,b)

#define INIT_PORT CONCAT(PORT, INITPORT)
#define INIT_DDR CONCAT(DDR, INITPORT)
#define INIT_PIN_PRE CONCAT(P, INITPORT)
#define INIT_PIN CONCAT(INIT_PIN_PRE, INITPIN)

Da PAx, PINx, PBx, usw. bei allen bekannten AVRs immer gleich x sind, 
braucht es INIT_PIN eigentlich nicht, da kann man gleich INITPIN 
verwenden.

Also so:

 INIT_DDR |= (1<<INIT_PIN);

oder gleich so:

 INIT_DDR |= (1<<INITPIN);

Oliver

[Oliver (Gast)]

Nachtrag:

INITPIN als Bezeichner für die Pinnummer ist in meinem obigen Beispiel 
blöd gewählt, da du ja auch noch das PIN-Register des Ports ansprechen 
können wollen willst ;)

Ber das kriegst du schon selber hin.

Oliver

[lange weg (Gast)]

da wirst einen parser brauchen, nimmst z.b. java mit config files gehts 
rel. simple da brauchst nur über alle drüber iterieren...

[XTALE (Gast)]

Oliver schrieb:
> #define CONCAT2(a,b) a##b
> #define CONCAT(a,b) CONCAT2(a,b)

Noch eine kurze Frage. Wieso reicht das nicht aus:

#define CONCAT(a,b) a##b

Was ist der Sinn von CONCAT2?



lange weg schrieb:
> da wirst einen parser brauchen, nimmst z.b. java mit config files gehts
> rel. simple da brauchst nur über alle drüber iterieren...

Hm oki. Danke :)

[Stefan R. (srand)]

XTALE schrieb:
> Noch eine kurze Frage. Wieso reicht das nicht aus:
>
> #define CONCAT(a,b) a##b
>
> Was ist der Sinn von CONCAT2?

http://www.c-faq.com/ansi/stringize.html

[macro (Gast)]

Oliver schrieb:
> #define INITPORT A
> #define INITPIN 5

Gibt es eine Möglichkeit, das ganze ohne defines mittels eines 
Funktionsaufrufs zu machen?

Init(int Port, int Pin)
{
   DDR + Port |=  (1<<Pin);    <--- das soll sein:  DDRA |= ....  
   ...

}

Ich hoffe ihr versteht was ich meine. :)

[W.S. (Gast)]

macro schrieb:
> Ich hoffe ihr versteht was ich meine.

Nein.

Ansonsten halte ich es mit Leuten, die sich im Konstruieren von Macros 
ergehen, so ähnlich wie Osmin: Erst geköpft und dann gehangen, dann 
gespießt auf heiße Stangen, dann..... naja.

Kurzum, Macros sind ein elendiger Mist, den man besser bleiben lassen 
sollte. Wer auf solche Ideen kommt, täte besser daran, seine Algorithmen 
gründlich zu überdenken.

W.S.

[macro (Gast)]

W.S. schrieb:
> Kurzum, Macros sind ein elendiger Mist, den man besser bleiben lassen
> sollte.

Hi W.S. Deshalb auch meine Frage, ob man macros umgehen kann und vom 
user ausgewählte Ports und pins in Init.Port und Init.Pin ablegen kann. 
Und zwar so ablegen, dass man an vielen Stellen im Quellcode mit DDRx, 
PORTx usw. ansprechen kann.  "Lange weg" hat zwar eine Möglichkeit 
aufgezeigt, aber vielleicht gibt es da auch was einfacheres.


gruß
macro

[Sebastian W. (sebastian_w29)]

macro schrieb:
> Gibt es eine Möglichkeit, das ganze ohne defines mittels eines
> Funktionsaufrufs zu machen?
>
>

> Init(int Port, int Pin)
> {
>    DDR + Port |=  (1<<Pin);    <--- das soll sein:  DDRA |= ....
>    ...
> 
> }
>

Das ginge zur Laufzeit vielleicht so (ist aber nicht genau so effizient 
wie eine Definition zur Compilezeit):

volatile uint8_t* WhichIo (char* ioname) {
    if (!strcmp(ioname,"DDRA")) return &DDRA;
    else if (!strcmp(ioname,"DDRB")) return &DDRB;
    else if (!strcmp(ioname,"PORTA")) return &PORTA;
    else if (!strcmp(ioname,"PORTB")) return &PORTB;
    ...
    else return 0;
}

void Init (volatile uint8_t* Ddr, int Pin) {
    *Ddr |= 1<<Pin;
}

void ExplicitExample () {
    Init(WhichIo("DDRA"),5);
    volatile uint8_t* port = WhichIo("PORTA");
    *port |= 1<<5;
    *port &= ~(1<<5);
}

void ConfigExample () {
    char* portname = ReadConfigString("OUTPUTPORT");
    char* ddrname = ReadConfigString("OUTPUTDDR");
    volatile uint8_t* port = WhichIo(portname);
    int pin = ReadConfigInt("OUTPUTPIN");
    Init(WhichIo(ddrname),pin);
    *port |= 1<<pin;
    *port &= ~(1<<pin);
}

LG, Sebastian

[W.S. (Gast)]

macro schrieb:
> und vom
> user ausgewählte Ports und pins in

Hehe.. der User bist doch du selber!
Ich halte es für keine gute Idee, immerzu zwischen "User" und "Ich hier" 
unterscheiden zu wollen. Ich weiß zwar nicht, was du im konkreten Falle 
mit diesem Init.Port usw. bezwecken willst, aber so etwas überhaupt 
anzudenken, ist wirklich falsch. Bedenke doch bitte, daß ein µC immer in 
eine bestimmte Schaltung eingelötet wird und daß er deshalb 
selbstverständlich gerade an seinen Portpins genau so programmiert 
werden muß, wie es die umgebende Schaltung erfordert. Oder willst du 
gelegentlich gegeneinander ankämpfende Output-Pins erzeugen?

Also, schreib dir die Treiberroutinen einfach so, wie es die benutzte 
Peripherie erfordert und halte die zugehörige Headerdatei frei von 
triberinternem Zeugs. Dort sollten nur die Nutzaufrufe stehen, die man 
vom Rest der Firmware aus benötigt, um über den Treiber mit der Hardware 
und damit mit der Außenwelt zu kommunizieren. Dazu braucht man keine 
Macros.

W.S.

[Harry L. (mysth)]

W.S. schrieb:
> macro schrieb:
>> Ich hoffe ihr versteht was ich meine.
>
> Nein.
>
> Ansonsten halte ich es mit Leuten, die sich im Konstruieren von Macros
> ergehen, so ähnlich wie Osmin: Erst geköpft und dann gehangen, dann
> gespießt auf heiße Stangen, dann..... naja.
>
> Kurzum, Macros sind ein elendiger Mist, den man besser bleiben lassen
> sollte. Wer auf solche Ideen kommt, täte besser daran, seine Algorithmen
> gründlich zu überdenken.
>
> W.S.

Zitat Dieter Nuhr: "Wer keine Ahnung hat....."

Komisch, daß son Müll immer nur anonym gepostet wird.

Makros sind eine hervorragende Möglichkeit, bestimmte Konstrukte lesbar 
zu halten, und trotzdem das Zielsystem nicht mit unnötigen Berechnungen 
zu belasten.
Ausserdem helfen sie Code portabel zu halten
Wenn du W.S. die Funktion von Makros nicht verstehst, und damit nicht 
umgehen kannst, dann lern es, oder halt die Klappe, aber verbreite nicht 
son Blödsinn, und verunsicher nicht die Leute, die ernsthaft 
programmieren lernen wollen!