Array an Array in Struktur übergeben

[Bastian (Gast)]

Hallo,

ich hätte da mal eine Frage zu Thema Arrays und deren Übergabe an 
Funktionen.

Ich habe eine Schnittstellen-Funktion ( CAN_Send() ) welche eine 
CAN-Nachricht verschickt.

Wie die übergebenen Nachricht verschickt wird, hängt von dem verwendeten 
System ab. Ich benutze in diesem Fall einen AT90CAN und die „Universelle 
CAN Bibliothek“ von kreatives-chaos.com.

void CAN_Send(uint8_t *msg) // Array mit 8 Elementen wird übergeben 
{  
         // Struktur und Funktion aus der „Universelle CAN Bibliothek“
  can_t msg_transmit;  
  msg_transmit.id = 0x111; 
  msg_transmit.length = 8;
  //msg_transmit.data = msg;  // Wie geht es hier weiter?
  can_send_message(&msg_transmit);  
}

Wie übergebe ich denn dem data-Feld (auch ein uint8_t Array mit 8 
Elementen) in der Struktur msg_transmit am besten das an die Funktion 
CAN_Send übergebene Array?

Ich könnte jedes Element einzeln übergeben, oder?

msg_transmit.data[0] = msg[0];
msg_transmit.data[1] = msg[1];
.
.
.
msg_transmit.data[7] = msg[7];

Der Funktion CAN_Send wird ja ein Pointer übergeben, also die Adresse 
des ersten Elementes des Arrays. Richtig?
Dann könnte ich doch in das ersten Element des Arrays Data in der 
Struktur msg_transmit diese Adresse kopieren.
Würde das so funktionieren?
Mir ist aber leider nicht klar, wie die Syntax dazu aussehen soll?

Das hier hat mir leider auch nicht weitergeholfen:

http://home.fhtw-berlin.de/~junghans/cref/SYNTAX/struct.html#pointers

Vielleicht kann einer von euch mir auf die Sprünge helfen. Danke im 
Voraus!

[Karl H. (kbuchegg)]

Bastian schrieb:

> Ich könnte jedes Element einzeln übergeben, oder?

zuweisen.
übergeben ist was anderes
>
>

> msg_transmit.data[0] = msg[0];
> msg_transmit.data[1] = msg[1];
> .
> .
> .
> msg_transmit.data[7] = msg[7];
>

ja, kannst du.
Du kannst aber auch ganz einfach eine Schleife dafür benutzen

   for( i = 0; i < 8; i++ )
     msg_transmit.data[i] = msg[i];

oder du kannst memcpy() dafür benutzen.

> Der Funktion CAN_Send wird ja ein Pointer übergeben, also die Adresse
> des ersten Elementes des Arrays. Richtig?

Genau das steht doch im Source Text.
Und ja. Das ist die Art und Weise, wie Arrays an Funktionen übergeben 
werden. In dem sie nicht wie alle anderen Werte als Kopie übergeben 
werden, sondern in dem der Funktion die Startadresse der Daten im 
Speicher mitgeteilt wird.

> Dann könnte ich doch in das ersten Element des Arrays Data in der
> Struktur msg_transmit diese Adresse kopieren.

Kannst du machen. Die Frage ist, ob die Funktion can_send_message dann 
damit was anfangen kann. Dann auf dem CAN Bus willst du ja nicht die 
Adresse im Speicher verschicken, auf der an deinem µC die Daten im 
Speicher liegen würden. An diese Daten kommt ja der Empfänger der Daten 
nicht heran. Mit der Adresse hat der also nichts angefangen. Der will 
schon die Daten selber haben. Also musst du ihm die auch geben.

> Würde das so funktionieren?

Die Frage an sich ist schon ok. Nur ist das keine Lösung. Selbst wenn du 
die Antwort dazu kennen würdest.
Wenn die Funktion can_send_message davon ausgeht, dass die zu 
versendenden Daten in die STruktur can_t einkopiert wurden, dann musst 
du die dort auch einfüllen. Oder aber du überarbeitest die Struktur und 
die Funktion can_send_message.

[Bastian (Gast)]

Ich habe mal in der Bibliothek von kreatives-chaos.com rumgesucht.
Wenn ich das richtig Verstanden habe, wird für einen AT90CAN aus 
can_send_message() at90can_send_message(), was dann 
at90can_copy_message_to_mob() aufruft.

void at90can_copy_message_to_mob(const can_t *msg)
{
  // write DLC (Data Length Code)
  CANCDMOB = msg->length;
  
  #if SUPPORT_EXTENDED_CANID
  
  if (msg->flags.extended) {
    // extended CAN ID
    CANCDMOB |= (1 << IDE);
    
    CANIDT4 = (uint8_t)  msg->id << 3;
    
    uint32_t temp = msg->id << 3;
    uint8_t *ptr = (uint8_t *) &temp;
    
    CANIDT3 = *(ptr + 1);
    CANIDT2 = *(ptr + 2);
    CANIDT1 = *(ptr + 3);
  }
  else {
    // standard CAN ID
    CANIDT4 = 0;
    CANIDT3 = 0;
    CANIDT2 = (uint8_t)  msg->id << 5;
    CANIDT1 = (uint16_t) msg->id >> 3;
  }
  
  #else
  
  CANIDT4 = 0;
  CANIDT3 = 0;
  CANIDT2 = (uint8_t)  msg->id << 5;
  CANIDT1 = (uint16_t) msg->id >> 3;
  
  #endif
  
  if (msg->flags.rtr) {
    CANIDT4 |= (1<<RTRTAG);
  }
  else {
    const uint8_t *p = msg->data;
    for (uint8_t i = 0;i < msg->length;i++) {
      CANMSG = *p++;
    }
  }
}

// ----------------------------------------------------------------------------
uint8_t at90can_send_message(const can_t *msg)
{
  // check if there is any free MOb
  uint8_t mob = _find_free_mob();
  if (mob >= 15)
    return 0;
  
  // load corresponding MOb page ...
  CANPAGE = (mob << 4);
  
  // clear flags
  CANSTMOB &= 0;
  
  // ... and copy the data
  at90can_copy_message_to_mob( msg );
  
  // enable interrupt
  _enable_mob_interrupt(mob);
  
  ENTER_CRITICAL_SECTION;
  #if CAN_TX_BUFFER_SIZE == 0
    _free_buffer--;
  #else
    _transmission_in_progress = 1;
  #endif
  LEAVE_CRITICAL_SECTION;
  
  // enable transmission
  CANCDMOB |= (1<<CONMOB0);
  
  return (mob + 1);
}

#endif  // SUPPORT_FOR_AT90CAN__

Wir hier nicht auch einfach die Adresse des Pointers erhöht?

    const uint8_t *p = msg->data;
    for (uint8_t i = 0;i < msg->length;i++) {
      CANMSG = *p++;
    }

Könnte ich jetzt nicht msg.data (hier msg_transmit.data) auf den der 
Funktion CAN_Send() übergebenen Pointer "umbiegen"?

[Karl H. (kbuchegg)]

Bastian schrieb:

> Könnte ich jetzt nicht msg.data (hier msg_transmit.data) auf den der
> Funktion CAN_Send() übergebenen Pointer "umbiegen"?

Kannst du.

Aber der Weg, das zu tun, beginnt damit, das man in der Struktur can_t 
erst mal das Array data durch einen Pointer ersetzt. Allerdings muss man 
dann quer durch alle Funktionen begutachten, ob das ueberall moeglich 
ist. In solchen Faellen geh ich dann her und aendere auch gleich den 
Namen des Members. dataPtr wuerde sich z.b. anbieten. Dann sucht mir 
naemlich der Compiler raus, wo data urspruenglich verwendet wurde und 
ich kann entscheiden, ob an diesen Stellen Codeaenderungen notwendig 
sind oder ob der Array/Pointer Dualismus zu meinem Vorteil arbeitet.