struct mit Funktionspointer; Funktionsaufruf macht Ärger

[Tobias W. (tobiasw)]

Servus,

ich komme direkt zur Sache. Ich habe das Gefühl ich mache beim Aufruf 
meiner Funktionen einen Fehler, denn irgendwie scheint es als würde 
keine der Funktionen aufgerufen. Geht um eine ganz einfach 
UART-Befehls-Ausführung (welche noch größer wachsen soll):

#include <stdint.h>
#include <avr/io.h>
#define BAUD 9600
#include <util/setbaud.h>

uint8_t foo1( uint8_t *d )
{
  UDR0 = *d;
  return *d;
}
uint8_t foo2( uint8_t *d )
{
  UDR0 = d[0] + d[1];
  return d[0] + d[1];
}
uint8_t foo3( uint8_t *d )
{
  UDR0 = d[1];
  return d[1];
}

typedef struct {
  uint8_t length;          // anzahl der Parameter
  uint8_t  (*f)(uint8_t *data);  // Funktionspointer mit pointer auf Parameter
} command_t;

uint8_t buf[3];
const command_t commands[3] =  // fixe liste, da wird sich nie was ändern, daher const
  {
    { 1, foo1 },
    { 2, foo2 },
    { 2, foo3 }
  };


int main(void)
{
  
  //init
  DDRD = (1<<1);
  UBRR0  = UBRR_VALUE;
  UCSR0C  = (1<<UCSZ00) | (1<<UCSZ01);  // asynchronous 8n1 Mode
  UCSR0B  = (1<<RXEN0) | (1<<TXEN0);    // Enable Receiver and Transmitter

  
  uint8_t i = 0;
  while(1)
  {
    if( UCSR0A & (1<<RXC0) )
    {
      buf[i] = UDR0;
      i++;
      if( i>0 && i == commands[ buf[0] ].length )
      {
        i=0;
        (*commands[ buf[0] ].f)( &buf[1] );
      }
    }
  }
}

Ich wollte euch als kurz fragen ob denn der Funktionsaufruf

 (*commands[ buf[0] ].f)( &buf[1] );

 so überhaupt richtig ist oder ob ich da gravierend was falsch mache, 
und wenn ja was.

Vielen Dank schonmal
Gruß
Tobias

[g457 (Gast)]

> (*commands[ buf[0] ].f)( &buf[1] );
   ^
Wenn meine Brille nicht zu verdreckt ist dann ist da ein Asterisk zu 
viel.

[Tobias W. (tobiasw)]

aber will ich denn nicht die Funktion, die dahinter steckt aufrufen?
ich will ja nicht die Adresse ausführen... oder doch?

[Rolf Magnus (Gast)]

Es spielt keine Rolle. Bei Funktionszeigern ist das äquivalent. Du 
kannst also vor den Funktionsnamen soviele '*' oder auch '&' machen, wie 
du willst. Die meisten machen deshalb gar nichts davor.

[Tobias W. (tobiasw)]

Also der Aufruf ist dann also richtig... Der Fehler muss dann irgendwo 
anders stecken. Ich glaub ich hol mal mein Oszi.

Danke euch. Hab wieder was gelernt und bin damit dann auch weiter 
gekommen.
Gruß Tobi

[Johann L. (gjlayde)]

Tobias Weilenbach schrieb:
>         (*commands[ buf[0] ].f)( &buf[1] );

Warum denn nicht einfach so?

         commands[buf[0]].f (&buf[1]);

Per Funktionszeiger kann man syntaktische genauso aufrufen wie direkt 
per Symbol.

[Klaus (Gast)]

Tobias Weilenbach schrieb:
> denn irgendwie scheint es als würde
> keine der Funktionen aufgerufen.

Einen Breakpoint auf die Funktion setzen und schauen ob er kommt?

MfG Klaus

[Tobias W. (tobiasw)]

Klaus schrieb:
> Einen Breakpoint auf die Funktion setzen und schauen ob er kommt?

Dafür war das Senden per UART gedacht. UDR0 = ...
Der Fehler war jetzt dann doch Blöder als Trivial. Beim Löten muss sich 
das Pad eines Schutzwiderstandes in der TX-Leitung des µC von der 
Leiterbahn getrennt haben. Am Port-Pin lag das Signal noch an, am 
Widerstand nimmer. Leiterbahn aufkratzen und Brücke setzten hat 
geholfen. So nen Mist.

Trotz alle dem, hab ich wieder was gelernt, Danke.

Gruß Tobi