verschiedene Bytes über Bus zuordnen

[Zeroeightfifteen (Gast)]

Hallo
ich habe über I2C einen Master und einen Slave verbunden. Auf beiden 
habe ich ca 50 Variablen. Nun will ich über den Master auf dem Slave 
immer nur gezielte Variablen verändern. Wie geht das am besten?
Ich habe dies nun so gelöst.

void variablenzuweisung (zuweisung)
{

switch (steuerbyte)
{
case großX:
kleinx = zuweisung;
break;
case großY:
kleiny = zuweisung;
break;
case großZ:
kleinz = zuweisung;
break;

so bekomme ich halt einen ewig langen text zusammen.
habe mir schon gedacht ob ich dies mit einem array mache.
doch meine variablen sind teilweise int unsigned int und char.

im Grunde funktioniert mein Code so ganz gut, bin damit aber nicht 
zufrieden.

Habt ihr da eine bessere Lösung?

[Kai G. (runtimeterror)]

>doch meine variablen sind teilweise int unsigned int und char.
Wie machst du das denn dann bei deinem obigen Beispiel? Von welchem Typ 
ist denn 'zuweisung'?

[Zeroeightfifteen (Gast)]

zuweisung inst ein int.
wenn ich aber nun schreibe
char1 = variablenzuweisung(zuweisung);

void variablenzuweisung(zuweisung)
{
char2 = zuweisung;
}
dann wird hier ein char in ein char geschrieben.
zuweisung ist ja nur eine zwischenvariable.

[Zeroeightfifteen (Gast)]

hab mich verschrieben.
in diesem Beispiel rufe ich variablenzuweisung(zuweisung) nur so auf 
ohne char1 =

[Bernd M. (bernd_m)]

hi!

ich geh mal davon aus, dass du in deinem übertragungsprotokoll jeder 
variablen eine identifikation zugeordnet hast (enum).

typedef enum {
  eVar1 = 0,
  eVar2,
...
  eMaxVars
} eVars



dann kannst du eine tabelle in der art

typedef pointer_auf_schreib_func ...;
typedef pointer_auf_lese_func ...;

typedef struct {
   pointer_auf_schreib_func write;
   pointer_auf_lese_func read;
   pointer_auf_variable adr;
} zugriff_t;


void func_fuer_byte_write (adr von var, wert)
void func_fuer_word_write (adr von var, wert)
byte func_fuer_byte_read (adr von var)
word func_fuer_word_read (adr von var)


const zugriff_t zugriff_tab[eMaxVars] = {
{&func_fuer_byte_write, &func_fuer_byte_read, &var1};
{&func_fuer_word_write, &func_fuer_word_read, &var2};
....
}

if (steuerbyte < eMaxVars) {
   zugriff_tab[steuerbyte].write(zugriff_tab[steuerbyte].adr, 
neuer_wert);
}

bzw:
if (steuerbyte < eMaxVars) {
   retval = zugriff_tab[steuerbyte].read(zugriff_tab[steuerbyte].adr);
}


aufbauen. einzelheiten bitte noch entsprechend ausprogrammieren.
damit beschreibst du die zugriffsmethode auf die jeweilige
variable.

oder du baust die tabelle um auf variablen adresse und variablen länge. 
dann brauchst du nur eine lese und eine schreib funktion.


typedef struct {
   pointer_auf_variable adr;
   länge_der_variable len;
} varinfo_t;

const varinfo_t varinfo_tab[eMaxVars] = {
{&var1, sizeof(var1)};
{&var2, sizeof(var2)};
....
}


if (steuerbyte < eMaxVars) {
   memcpy(varinfo_tab[steuerbyte].adr, neuer_wert, 
varinfo_tab[steuerbyte].len)
}

bzw anders herum.

die letzte idee scheint mir kompakter.

gruss bernd