Variablen in einem Array organisieren und ansprechen

[Viktor K. (krieger)]

Ich habe ein kleines Problem, nur weiß ich nicht wie man das nennt.(?)

Bei Kommunikation zweier ATmegas über SPI möchte ich direkt in der ISR 
auf die Variablen(8,16,32Bit) direkt zugreifen. Kurz gesagt, ich möchte 
gerne die globalen Variablen, die an irgend einer anderen Stelle im 
Programm verwendet werden, nur in der ISR verändern, so dass die anderen 
Programmteile nichts davon "mitbekommen".

Ideal wäre natürlich wenn man die Variablen als ein mehrdemensionales 
Array organisieren könnte.

etwa so:

#define varAdr 5 //Speicherstellen für max 5 Variablen, 8-,16- oder 32-Bit

unsigned char varArray[varAdr][4];

ISR(SPI_STC_vect){

  if(!isr_count){
    isr_count++;
    cmdByte= SPDR;
    varAdr= cmdByte & 0x0F;
  }
  
  if(cmdByte & 0x80){//Schreiben
    varArray[varAdr][i++]= SPDR;
  }
  else{//sonst lesen
    SPDR= varArray[varAdr][i++];
  }
}

somit wären dann alle 5 Variablen linksbündig im Array angeordnet, also 
in etwa so:
var0: Byte3,Byte2,Byte1,Byte0 //32Bit Variable
var1: Byte1,Byte0             //16Bit Variable
var2: Byte0                   //8Bit Variable
var3: ...

Wie kann man auf diese Daten als "richtige" Variablen zugreifen, ohne 
dass man diese erst "zusammen bauen" muss?
wie unsigned int myVar= (varArray[1][0]<<8)|(varArray[1][1]);

Oder gibt es bessere (elegantere) möglichkeiten?

[Johannes S. (johanness)]

Mir fiele da das Stichwort "Union" ein. Damit kann man mehrere Variablen 
definieren, die sich einen Speicherbereich teilen. Hier hat der Compiler 
die Arbeit, ist recht komfortabel.

Ansonsten würde ich mit meinen C-Kenntnissen aus einem 
Informatik-Praktikum im Grundstudium folgendes bauen:

int* zeiger=varArray+4*varAdr; // Zeiger auf die gesuchte Variable
unsigned int myVar = *zeiger;

weiß nicht mehr so genau, aber vielleicht funktioniert auch

unsigned int myVar = *((int*)varArray[varAdr])

Alles ohne Gewähr, war Standard-C, nicht fürn µC, und ist ne Weile her 
;-)

[Klaus (Gast)]

Ich würde einfach ein Array Uint32_t varArray[varAdr] benutzen. Den 
einzelnen Feldern kannst du ohne Probleme auch 1 Byte lange Werte 
zuweisen. Umgekehrt lässt sich ein Uint32_t auch wieder ohne Probleme in 
ein char casten:
char c = (char) varArray[0];

[Viktor K. (krieger)]

eigentliches Problem liegt ja darin, dass ich die (32- und 
16Bit)Variablen byteweise schreiben und lesen muss, damit das ganze mehr 
oder weniger automatisch abläuft.
So würde ich beim Master im ersten Byte, bit7 als RW Bit zum lesen oder 
schreiben setzen, in bit3...bit0 die "Adresse" der Variable mitteilen, 
die ich auslesen oder beschreiben möchte und anschließend weitere 1, 2 
bzw. 4 Bytes, je nach dem ob es eine 8,16,32Bit Variable ist.

Ich will die daten nicht zwischenpuffern und dann diese in eine Variable 
übertragen, weil dann währe ich genau so weit wie jetzt.
Auf dieser Weise funktioniert das bereits ganz gut.
Nun möchte ich so etwas wie dirkter Speicher Zugriff realisieren um die 
Kommunikation zu vereinfachen und den Code dadurch schneller und 
effizienter zu machen, da der gesammte Datenaustaucsch nur durch die ISR 
über SPI erfolgen soll.