dynamische Funktionsaufrufe in c

[Reiner W. (reiner_w)]

Hallo in die Runde,
ich beschäftige mich seit geraumer Zeit mit den Cypress PSoC Chips, aber 
ich denke, meine Frage ist eher eine allgemeine C-Frage (wo ich noch 
nicht allzulange zu Hause bin), für die ich einfach keine Lösung finde.

Zum konkreten Problem:
Der PSoC Creator erzeugt zur einfachen Ansteuerung von Pins bei der 
Kompilierung eine entsprechende API.
Da gibt es dann diverse Befehle zum schreiben/lesen etc.
Die Syntax ist recht einfach. PinName_Funktion()
Pin1_Write(1) - setze Pin1 auf 1 na usw.
Jetzt hab muss ich das gleiche Bitmuster an verschiedene Pins ausgeben. 
Dafür hab ich Funktionen.

void Bitmuster_an_Pin1 (void) {
    Pin1_Write(1);   // 1 auf Pin
    //tu noch andere Sachen
    Pin1_Write(0);   // 0 auf Pin   
}

Die gleiche Funktion hab ich dann noch für 3 andere Pins.

Was ich suche ist eine Möglichkeit, den API-Funktionsnahme dynamisch zu 
erzeugen.
Etwa so:

//reiner Pseudocode
void Bitmuster_an_PinX (char PinNr) {
    API_Befehl = "Pin"+PinNr+"_Write  
    API_Befehl(1);                   
    
    //tu noch andere Sachen
    
    API_Befehl(0);  
}

Mit Makroexpansion bekomme ich es nicht hin:

#define Pin(i) Pin##i

expandiert ja nur wenn beim Aufruf i als Zahl benutzt wird.

uint8_t i = 1;
Pin(i)()  -> Fehler
Pin(1)()  -> expandiert zu Pin1()

Natürlich kann ich in eine Funktion mit switch oder case arbeiten, aber 
das wird bei vielen Pins und API_Funktionen
schon sehr unübersichtich.

Ich hoffe, ich habe mich einigermaßen verständlich ausgedrückt.
Vlt. kann mich jemand in die richtige Richtung schupsen.

[Daniel A. (daniel-a)]

Reiner W. schrieb:

> Der PSoC Creator erzeugt
> Pin1_Write(1) - setze Pin1 auf 1 na usw.
>Was ich suche ist eine Möglichkeit, den API-Funktionsnahme dynamisch zu
>erzeugen.

Wenn dieser PSoC Creator keine funktion zum setzen des n-ten pins, oder 
mehrerer pins hat, würde ich den gleich weglassen und selbst die 
entsprechende funktion schreiben. In C kann man keine funktion über 
einen zur runtime zusammengesetzten namen aufrufen, es sei denn man 
speichert funktionsname und funktionspointer in einer liste. Mit 
preprocessing ist es auch nicht möglich, weil das simple textersetzung 
ist.

Man könnte im notfall Arrays verwenden: (code ungetestet)

#define PinMacro(i) Pin ## i ## _Write
#define PinListItem(i) &PinMacro(i)
#define PinListMacro1() PinListItem(1)
#define PinListMacro2() PinListMacro1(), PinListItem(2)
#define PinListMacro3() PinListMacro2(), PinListItem(3)
#define PinListMacro4() PinListMacro3(), PinListItem(4)
#define PinListMacro5() PinListMacro4(), PinListItem(5)
#define PinListMacro6() PinListMacro5(), PinListItem(6)
#define PinListMacro7() PinListMacro6(), PinListItem(7)
#define PinListMacro8() PinListMacro7(), PinListItem(8)
#define PinListMacro(n) PinListMacro ## n()
#define SetPin(i,b) (*(SetPinList[i-1]))(b)

typedef void(*PinSetter_t)(char);

// liste
PinSetter_t SetPinList[] = {
  PinListMacro(8)
};

// beispiel
void doSomething(){
  int i = 1; // pin nummer
  SetPin(i,1);
}

Wobei switch/case sicher effizienter sind...

[Klaus W. (mfgkw)]

Evtl. helfen dir Funktionszeiger weiter:

#include <stdio.h>

void Pin1_Write( int wert )
{
  printf( "Schreibe auf Pin   1: %d\n", wert );
}

void Pin2_Write( int wert )
{
  printf( "Schreibe auf Pin   2: %d\n", wert );
}

// ...

void Pin999_Write( int wert )
{
  printf( "Schreibe auf Pin 999: %d\n", wert );
}


// Typ PinXXX_Write_t: Zeiger auf Funktion, die eine int bekommt und
// nichts zurückliefert
typedef void (*PinXXX_Write_t)( int wert );

// davon ein ganzes Feld: an Position [0] steht ein Zeiger auf die
// Funktion, die Pin 1 auf 0 oder 1 setzt, an [1] steht die Funktion,
// die selbiges für Pin 2 macht etc.
PinXXX_Write_t  PinXXX_Write_array[] =
  {
    Pin1_Write,
    Pin2_Write,
    // ...
    Pin999_Write,
  };


// Gibt auf Pin Nummer PinNr erst eine 1 aus, dann eine 0:
void mein_tolles_Bitmuster_an_PinX (char PinNr)
{
  PinXXX_Write_array[PinNr-1]( 1 ); // PinNr auf 1
  // ...
  PinXXX_Write_array[PinNr-1]( 0 ); // PinNr auf 0
}



int main( int nargs, char **args )
{
  mein_tolles_Bitmuster_an_PinX( 2 ); // Pin 2 auf 1 und dann auf 0 setzen
  return 0;
}

Das kann man (um Schreibarbeit zu sparen) mglrws. noch mit Makros 
kombinieren:

#include <stdio.h>

#define generate_PinXWrite(i)                             \
void Pin##i##_Write( int wert )                           \
{                                                         \
  printf( "Schreibe auf Pin   " #i ": %d\n", wert );      \
}

generate_PinXWrite(1)
generate_PinXWrite(2)
//...
generate_PinXWrite(999)



// Typ PinXXX_Write_t: Zeiger auf Funktion, die eine int bekommt und
// nichts zurückliefert
typedef void (*PinXXX_Write_t)( int wert );

// davon ein ganzes Feld: an Position [0] steht ein Zeiger auf die
// Funktion, die Pin 1 auf 0 oder 1 setzt, an [1] steht die Funktion,
// die selbiges für Pin 2 macht etc.
PinXXX_Write_t  PinXXX_Write_array[] =
  {
    Pin1_Write,
    Pin2_Write,
    // ...
    Pin999_Write,
  };


// Gibt auf Pin Nummer PinNr erst eine 1 aus, dann eine 0:
void mein_tolles_Bitmuster_an_PinX (char PinNr)
{
  PinXXX_Write_array[PinNr-1]( 1 ); // PinNr auf 1
  // ...
  PinXXX_Write_array[PinNr-1]( 0 ); // PinNr auf 0
}



int main( int nargs, char **args )
{
  mein_tolles_Bitmuster_an_PinX( 2 ); // Pin 2 auf 1 und dann auf 0 setzen
  return 0;
}

[Reiner W. (reiner_w)]

Klaus Wachtler schrieb:
> Evtl. helfen dir Funktionszeiger weiter:

Genauso hab ich es im Prinzip gemacht;-) Auch wenn dein Code 
aufgeräumter aussieht. Aber da feile ich noch dran.
Komme aus alten seligen dBase Zeiten und da konnte man ja zur Laufzeit 
ne Markosubstitution einfach mit

x="test()"
y = &x

machen. Aber man kann nicht alles haben.

Da die Funktionen als API ja alle schon konkret vorliegen, brauch ich ja 
nur noch ein Array mit den Funktionspointern anlegen.
Ist halt blöd, wenn da mal ein Pin dazukommt, da muss man immer dran 
denken, dass array zu erweitern.
Außerdem sind die API-Funktionen noch nicht die ganze Wahrheit, da gibt 
es auch noch Konstanten (z.B. der Pin-Drive-Mode), die nach dem selben 
Schema benannt sind. Das bedeutet schon eine zweite Dimension im Array, 
wenn ich eine solche Konstante in meiner (allgemeinen) Funktion brauche. 
Dennoch ist das besser und sicher auch platzsparender als 8 Funktionen, 
die im Grunde gleich sind.

Daniel A. schrieb:
> #define PinListItem(i) &PinMacro(i)

Die Zeile kann ich noch nicht ganz nachvollziehen. Was macht das & ?
Bin leider noch nicht so firm in der C-Programmierung.

Danke schon mal für eure Hilfe. Ist ja schon mal beruhigend zu wissen, 
dass  ich nicht von vorn anfangen muss, nur weil ich den Wald vor lauter 
Bäumen nicht gesehen habe.

[Klaus W. (mfgkw)]

Reiner W. schrieb:
> Ist halt blöd, wenn da mal ein Pin dazukommt, da muss man immer dran
> denken, dass array zu erweitern.

In solchen Fällen kann man darüber nachdenken, Quelltext mit einem 
Präprozessor zu generieren (m4, awk, sed, ...).
Wenn man eh über makefiles oder ähnliches kompiliert, ist das leicht 
eingebaut.

Wenn sich etwas ändert, wird eine Konfigurationsdatei angepasst, und 
nach einem make passt alles.

[Reiner W. (reiner_w)]

Klaus Wachtler schrieb:
> In solchen Fällen kann man darüber nachdenken, Quelltext mit einem
> Präprozessor zu generieren (m4, awk, sed, ...).

Gute Idee, im konkreten Fall lohnt sich aber ein Quellcodegenerator 
sicher nicht. Und in so einem Fall muss man wieder höllisch aufpassen, 
dass die PinNamen einer Regel folgen. Pin1, Pin2..Pinx. Aber das sollten 
sie sowieso tun.

[Daniel A. (daniel-a)]

Reiner W. schrieb:
> Daniel A. schrieb:
>> #define PinListItem(i) &PinMacro(i)
>
> Die Zeile kann ich noch nicht ganz nachvollziehen. Was macht das & ?

Es gibt den funktions-pointer auf die Funktion zurück. Da eine funktion 
immer auch ein funktionspoiner ist, ist es optional. Ich verwende es aus 
kosmetischen und logik gründen. Wichtig ist, dass wenn man ein x=&func 
verwendet, später (*func)() für den aufruf verwendet wird, und bei 
x=func der aufruf immer mit x() erfolgt.

Funktion und Funktionspointer sind eben rein logisch betrachtet (nicht 
praktisch) nicht das selbe.

void x(){} // void(&){}   funktion
void(*y)()=&x; // funktionspointer
void(**z)()=&y; // objekt-pointer auf funktionspointer

[Reiner W. (reiner_w)]

Daniel A. schrieb:
> Es gibt den funktions-pointer auf die Funktion zurück

Ja klar, das Brett vorm Kopf ist weg;-)
Danke

[Sven B. (scummos)]

Wo ist der Vorteil gegenüber dem die Pin-Nummer einfach als Argument zu 
übergeben?

[Reiner W. (reiner_w)]

Sven B. schrieb:
> Wo ist der Vorteil gegenüber dem die Pin-Nummer einfach als Argument zu
> übergeben?

Ich weis jetzt nicht was du meinst. Das Problem hab ich ja schon bei her 
TE geschildert. Die PinNummer als Argument geht nicht, weil ich über 
dieses Argument nicht mehr auf den Funktion komme, es sei denn, ich 
nehme die PinNummer als Array-Index und im Array stehen die 
Funktionspointer. Das geht ganz gut, erfordert aber, dass im Vorfeld das 
Array mit den Funktionspointern angelegt wurde, wie ja Klaus Wachtler 
perfekt als Beispiel gezeigt hat.
Wenn ich es richtig sehen, läuft der Vorschlag von Daniel letztlich auch 
darauf hinaus, setzt aber den Präprozessor intensiv ein.
Ich weis jetzt nicht, ob du da noch eine andere Möglichkeit siehst und 
wie die aussehen könnte.

[Sven B. (scummos)]

Ok, sorry, ich habe das Problem falsch verstanden. Vergiss was ich sagte 
:)