Commands effektiv verarbeiten

[Gast (Gast)]

Hallo Leute, ich habe eine I2C Kommunikationsschnittstelle, die schnell 
reagieren muss. So dachte ich mir, es wäre effizienter CMD-Byte aus dem 
Datenstream zu extrahieren und gezielt eine entsprechende Funktion 
ausführen, ohne dabei viel Zeit mit IF oder SWITCH- Abfragen zu 
verlieren.

Mach es Sinn sich was in diese Richtung zu überlegen? Also ich habe mir 
vorgestellt, zu jedem CMD eine entsprechende Funktion zu erstellen und 
diese  dann aufzurufen, z.B. CMD "0x0A" wird in der Funktion 
translate_cmd() erkannt und ruft folglich die Funktion f_A() auf. Geht 
sowas überhaupt?

[iaby (Gast)]

Du könntest dir ein Array mit Function-Pointern anlegen!
Das 0x0A wäre dann der Index für das Array, wo der Pointer auf die 
entsprechende Funktion hinterlegt ist!

[Falk B. (falk)]

@ Gast (Gast)

>Hallo Leute, ich habe eine I2C Kommunikationsschnittstelle, die schnell
>reagieren muss.

Naja, hast du schonmal über die Relationen nachgedacht?

I2C arbeitet mit 100..400 kbit/s, macht ~11..44 kBytes/s, sprich 
23..90us/Byte. Eine CPU mit beispielsweise 8 MHz macht in der Zeit 
~184..736 Takte. Das sollte reichen, um einen normalen switch() 
auszuwerten.

MFG
Falk

[Karl H. (kbuchegg)]

Gast wrote:
> Hallo Leute, ich habe eine I2C Kommunikationsschnittstelle, die schnell
> reagieren muss. So dachte ich mir, es wäre effizienter CMD-Byte aus dem
> Datenstream zu extrahieren und gezielt eine entsprechende Funktion
> ausführen, ohne dabei viel Zeit mit IF oder SWITCH- Abfragen zu
> verlieren.
>
> Mach es Sinn sich was in diese Richtung zu überlegen?

Ja.
Macht nicht nur wegen der gesparten Auswertezeit sinn, sondern,
du wirst es gleich sehen, man dadurch eine sehr wartungsfreundliche
Struktur bekommt.

Voraussetzungen:
Deine CMD-Bytes sollten aufsteigend vergeben werden.

> Also ich habe mir
> vorgestellt, zu jedem CMD eine entsprechende Funktion zu erstellen und
> diese  dann aufzurufen, z.B. CMD "0x0A" wird in der Funktion
> translate_cmd() erkannt und ruft folglich die Funktion f_A() auf. Geht
> sowas überhaupt?

typedef void (*Function)( void );

void process_00()    // Bearbeitet das Commando mit Cmd Code 0x00
{
}

void help()          // Bearbeitet das Commando mit Cmd Code 0x01
{
}

void shutdown()      // Bearbeitet das Commando mit Cmd Code 0x02
{
}

void stop()          // Bearbeitet das Commando mit Cmd Code 0x04
{
}

Function CmdFunctions[] = 
{
   process_00,       // Commando = 0x00
   help,             //            0x01
   shutdown,         //            0x02
   NULL,             //  für 0x03 gibt es keine Behandlung
   stop              //            0x04
};

#define ARRAY_SIZE(X) ( sizeof(X) / sizeof(*(X)) )

void translate_cmd( uint8_t Code )
{
  if( Code > ARRAY_SIZE( CmdFunctions ) )
    return;

  Function Fnc = CmdFunctions[ Code ];    // Funktion bestimmen
  if( Fnc != NULL )
    (*Fnc)();                    // Funktion aufrufen
}

Siehe auch:
http://www.mikrocontroller.net/articles/FAQ#Funktionszeiger

[Gast (Gast)]

@ iaby: ich schaue, ob es dadurch schneller wird
@ falk: das ist mir klar, doch bin ich in der Situation, wo ich es 
nöttig habe und ab 115 Abfragen nichts mehr geht.
@ Karl: vielen Dank für die Anregung

[Simon K. (simon)]

Falk Brunner wrote:
> Naja, hast du schonmal über die Relationen nachgedacht?
>
> I2C arbeitet mit 100..400 kbit/s, macht ~11..44 kBytes/s, sprich
> 23..90us/Byte. Eine CPU mit beispielsweise 8 MHz macht in der Zeit
> ~184..736 Takte. Das sollte reichen, um einen normalen switch()
> auszuwerten.

Wie schon gesagt, wenn du richtig viele Befehle hast? Außerdem heißt I2C 
nicht automatisch immer 100 oder 400kbit/s. Das originale I2C 
vielleicht.

Aber man kann ja den I2C Bus auch mit höheren Frequenzen betreiben.

[Werner B. (Gast)]

I2C - gepollt oder per IRQ?
Polling frisst natürlich gewaltig viel Rechenzeit wenn die CPU auf die 
daten warten muss.