#defines in C-Präprozessor Funktion

[Franz F. (franzman)]

Hallo,

ich habe ein #define PINconf_SPI1_MISO 0x24 was heißt das SPI1 an Port B 
Pin 4 hängt.
Jetzt möchte ich die Information im Programm nutzen und z.B 
PIN_SPI1_MISO und PORT_SPI1_MISO verwenden.

Ich habe in einem Zentralen .h File alle PINconf* definiert, allerdings 
möchte ich jetzt nicht bei allen Pins ein extra define für Port und Pin 
machen.

Deswegen wollte ich das Problem so lösen:

DECLARE_PIN(SPI1_MISO, 0x24)

#define DECLARE_PIN(name,conf) { \
  #define PIN_##name conf && msk_GPIO_PIN\
  #define PORT_##name conf && msk_GPIO_PORT\
}

Dieser Ansatz verursacht diesen Fehler:
 error: '#' is not followed by a macro parameter

ich habe dann gelesen, dass man in defines keine defines machen kann, 
deswegen frage ich euch nach einem anderen Ansatz für mein Problem.

Habt ihr eine ander Idee?

PS: Ich programmiere einen Cortex M0 mit CoIDE

[grundschüler (Gast)]

mit glue geht das:

  
  #define GLUE(a, b)  a##b
  #define PORT(x)    GLUE(PORT, x)
  #define PIN(x)    GLUE(PIN, x)
  #define DDR(x)    GLUE(DDR, x)
  #define sbi(var, bit) (var|=1<<bit)//set
  #define cbi(var, bit) (var&=~(1<<bit))//clear
  #define tbi(var, bit) (var^=1<<bit)//toggle
  #define gbi(var, bit) (var>>bit&1)//get
  #define wait  _delay_ms(1000)
  #define wait10  {_delay_ms(3333);_delay_ms(3333);_delay_ms(3333);}
  #define u8  uint8_t
  #define u16 uint16_t
  #define u32 uint32_t
  #define v volatile
...
#define pinSET(x,y) PORT(x) |=(1<<y)
#define pinCLR(x,y) PORT(x)&=~(1<<y)
#define pinTOG(x,y) PORT(x)^=(1<<y)

#define pinDIRin(x,y) DDR(x)&=~(1<<y)
#define pinDIRout(x,y) DDR(x)|=(1<<y)
//#define pinDIRaf(x,y) GPIO(x)->MODER |= (2<<(y*2))//
#define pinVAL(x,y) (PIN(x)&(1<<y))
//#define pinSPEED(x,y) GPIO(x)->OSPEEDR|=(GPIO_Speed_50MHz<<(y*2))//2=>50
#define pinPULLUP(x,y,z) PORT(x)|=(1<<y)//0_no 1_up

[Dr. Sommer (Gast)]

Makros sind ein Relikt aus (Makro-)Assemblern, die es nach C geschafft 
haben. Man sollte sie einfach ganz weglassen. Du kannst beliebige 
Datenstrukturen als Konstanten definieren:

struct Pin {
  uint8_t port;
  uint8_t pin;
};

static const Pin SPI1_MISO { 3, 4 }; // Port 3, Pin 3

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

Franz F. schrieb:
> #define DECLARE_PIN(name,conf) { \
>   #define PIN_##name conf && msk_GPIO_PIN\
>   #define PORT_##name conf && msk_GPIO_PORT\

Geht nicht.

[Franz F. (franzman)]

Dr. Sommer schrieb:
> Makros sind ein Relikt aus (Makro-)Assemblern, die es nach C geschafft
> haben. Man sollte sie einfach ganz weglassen. Du kannst beliebige
> Datenstrukturen als Konstanten definieren:
>

struct Pin {
>   uint8_t port;
>   uint8_t pin;
> };
> 
> static const Pin SPI1_MISO { 3, 4 }; // Port 3, Pin 3

Hallo,

wenn ich aber soetwas machen möchte muss ich immer 8 bit werte 
verwenden. Ich wollte es ungefähr so machen.

#define msk_GPIO_PIN     0b0000000000001111   //GPIO_Pin_0...15
#define msk_GPIO_PORT    0b0000000011110000  //GPIO_Port A...P
#define msk_GPIO_PuPd    0b0000001100000000  //00 No Pull
                        //01 Pulldown
                        //10 Pullup
#define msk_GPIO_Speed    0b0000110000000000  //00 GPIO_Speed_Level_1
                        //01 GPIO_Speed_Level_2
                        //10 GPIO_Speed_Level_3
#define msk_GPIO_OType    0b0001000000000000  //0  Push Pull
                        //1  Open Drain
#define msk_GPIO_Mode    0b0110000000000000   //00 Input
                        //01 Output
                        //10 Analog
                        //11 Alternate Function
#define msk_GPIO_Def_Out  0b1000000000000000  //Default state in Output

Deswegen würde es sich anbieten im Präprozessor die Port und Pin als 
eigene Defines zu definieren.

[Dr. Sommer (Gast)]

Franz F. schrieb:
> wenn ich aber soetwas machen möchte muss ich immer 8 bit werte
> verwenden.
Hä, wieso das? Du kannst natürlich auch uint16_t und uint64_t oder was 
auch immer verwenden...

Franz F. schrieb:
> Deswegen würde es sich anbieten im Präprozessor die Port und Pin als
> eigene Defines zu definieren.
Voll kompliziert. Mach lieber ein Struct mit Portnummer, Pin-Nummer, 
PuPd-Wert, Speed-Wert etc. Dann machst du dir eine Init-Funktion, die 
diesen struct entgegennimmt und den Pin entsprechend initialisiert.

[Bernd K. (prof7bit)]

Also bei avr-gcc mach ich das so:

#define FOO       A,2
#define BAR       A,3
#define BAZ       B,0


// helper macros
#define _SET(type,name,bit)    type##name |= _BV(bit)
#define _CLR(type,name,bit)    type##name &= ~_BV(bit)
#define _GET(type,name,bit)    (type##name & _BV(bit))

// use these macros in the application
#define SET_AS_OUTPUT(pin)     _SET(DDR,pin)
#define SET_AS_INPUT(pin)      _CLR(DDR,pin)
#define SET_HIGH(pin)          _SET(PORT,pin)
#define SET_LOW(pin)           _CLR(PORT,pin)
#define TOGGLE(pin)            _SET(PIN,pin)
#define IS_HIGH(pin)           _GET(PIN,pin)



[...]


int main(void) {
    SET_AS_OUTPUT(FOO);
    SET_AS_OUTPUT(BAR);

    SET_HIGH(FOO);

    [...]

Der gcc schluckt das anstandslos. Vielleicht kannst Du dieses Verfahren 
sinngemäß anpassen und anwenden. Der Trick besteht einfach im Umweg über 
die Helper-Macros und der Textersetzung die bei der Auflösung der Makros 
stattfindet und aus dem "scheinbar" nur einem Parameter und dem 
geschickt eingesetzten Komma "automagisch" wieder zwei Parameter macht.

[Franz F. (franzman)]

Bernd K. schrieb:
> #define _SET(type,name,bit)    type##name |= _BV(bit)

Hallo,

das "##" ist ja nicht das Problem.
Der Präprozessor kann anscheinend keine defines in makros ausführen:

http://stackoverflow.com/questions/1135822/escaping-a-symbol-in-a-define-macro

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

Franz F. schrieb:
> Der Präprozessor kann anscheinend keine defines in makros ausführen:

So ist es. Und das war schon immer so. Weshalb dir Bernd eine 
Alternative zu deinem Ansatz präsentierte.