zugriff auf Struct array

[Wolfgang H. (hastekene)]

Hallo bin mal wieder am verzweifeln!

ich habe ein Array:

struct{

uint8_t  kanal;
int8_t  start;
int8_t   t_on;
int8_t  t_off;
}led[datensatz_max];


der direkte Zugriff auf led[x].kanal usw ist kein Problem

wenn ich jetzt indirekt über eine Funktion auf led.kanal zugreifen 
möchte zb

über : serdata_to_data(led.kanal,3);
oder : serdata_to_data(led[0].kanal,3);


auf:

   void  serdata_to_data(char *data,uint8_t max){
   uint8_t dcount;

   for (dcount=0;dcount<max_empfang;dcount++)data[dcount]= max;

  }


bekomme ich nur Fehlermeldungen.

info!

Struct habe ich genommen um die Daten ins EEPROM Schreiben zu können


vielleicht kann mir jemand helfen ?

[Karl H. (kbuchegg)]

Wolfgang Hopperdietzel schrieb:

> wenn ich jetzt indirekt über eine Funktion auf led.kanal zugreifen

led.kanal  existiert nicht.
Du hast viele leds. Davon wählst du eine aus und veränderst deren 
kanal-Wert. Genau das ist die Bedeutung von

     led[x].kanal = 5;

> möchte zb
>
> über : serdata_to_data(led.kanal,3);
> oder : serdata_to_data(led[0].kanal,3);

Was soll die Funktion tun?
Beschreibe die gewünschte Funktionalität in Umgangssprache. Noch ist 
nicht klar, was du unter "ich möchte indirekt auf led.kanal zugreifen" 
verstehst.

[Karl H. (kbuchegg)]

BTW:

Solche anonymen Strukturen

struct{

uint8_t  kanal;
int8_t  start;
int8_t   t_on;
int8_t  t_off;
}led[datensatz_max];

sind keine gute Idee! Sie sind eigentlich nur dann sinnvoll, wenn man in 
einer Funktion mal schnell eine Struktur benötigt, was selten genug 
vorkommt, oder in einer union/struct eine geschachtelte struct (aus 
welchem Grund auch immer) erzeugen will. Aber als Datenstruktur, in der 
Werte tatsächlich für länger gespeichert werden, sind sie absolut fehl 
am Platze. Gib dem Datentyp einen Namen! Dann kannst du dir auch schöne 
verarbeitende Funktionen für diesen speziellen Datentyp bauen.

struct led_Data_t {    // so sieht prinzipiell eine LED aus
  uint8_t kanal;
  int8_t  start;
  int8_t  t_on;
  int8_t  t_off;
};

typedef struct led_Data_t led_Data;  // noch ein typedef um Tipparbeit zu sparen

led_Data led[datensatz_max];    // hier sind alle Led versammelt

// die Daten einer LED ausgeben
void printLed( led_Data *singleLed )
{
  printf( "Kanal: %u\n", singleLed->kanal );
  printf( "Start: %d\n", singleLed->start );
  printf( "Ein:   %d\n", singleLed->t_on );
  printf( "Aus:   %d\n", singleLed->t_off );
}

// die Daten aller LED ausgeben
void printAllLed()
{
  uint8_t i;

  for( i = 0; i < datensatz_max; ++i )
    printLed( &led[i] );
}

Nur so als Beispiel, wie man mit benannten Strukturen arbeiten kann. 
printLed bekommt einen Pointer auf eine Led. printAllLed füttern diese 
Funktion mit den entsprechenden Pointern. Dazu muss die Funktion 
printLed aber auch einen Pointer auf eine Led vereinbaren können. Und 
dazu braucht es wiederrum einen benannte Struktur.

[Karl H. (kbuchegg)]

Das hier
  serdata_to_data(led[0].kanal,3);

kann klarerweise nicht funktionieren.

Deine Funktion hat die Signatur:

  void  serdata_to_data(char *data,uint8_t max){

Das erste Argument muss also ein Pointer auf einen char sein.
Du übergibst led[0].kanal
Mal sehen.
led           ist das komplette Array
led[0]        ist ein Element aus dem Array, also eine
              komplette Struktur
led[0].kanal  wählt aus diesem einen Strukturelement den Eintrag
              'kanal' aus. Das ist dann bereits ein uint8_t

led[0].kanal ergibt einen Zahlenwert, nämlich die Kanalnummer der Led 0. 
Das ist aber nicht das was serdata_to_data haben möchte. Die möchte 
keinen Zahlenwert, sondern die Adresse an der sie etwas ablegen soll. Du 
willst also eigentlich die Adresse des Kanaleintrags der Led 0 haben, 
damit serdata_to_data dort was ablegen kann.

Ergo:

  &led[0].kanal

BTW: deine Funktion serdata_to_data sieht nicht richtig aus. Kann sein, 
dass das so stimmt. Möglich. Aber zumindest ist sie sehr ungewöhnlich. 
Und meistens ist es so, dass Funktionen die ungewöhnlich aussehen, bei 
Anfängern einfach nur völlig falsch sind.

[Wolfgang H. (hastekene)]

Hallo erst mal danke für die schnellen Antworten.

Die Struct :
struct{

uint8_t  kanal;
int8_t  start;
int8_t   t_on;
int8_t  t_off;
}led[datensatz_max];

habe ich desshalb genommen um das ganze Datenpaket ins EEPROM schreiben 
und wieder lesen zu können.

weiter greife ich direkt auf led[satz].kanal etz zu

mit indirekt meine ich den Zugriff auf die 1. Variable in der  Struct 
hier .kanal

oder die 4. .t_off ohne deren Namen zu nennen

zb led[variable][satz]= 99;

und wie kann ich in einer Funktion  auf die Variable zugreifen ?

zu deiner Antwort:
  woher kommt jetzt singleLed in
          void printLed( led_Data *singleLed ) ?

zu meiner Funktion wiso sollte sie fehlerhaft sein
dcount,data und max  ist deklariert.
 und  in einer for Schleife wird Data ein wert zugewiesen

sicher nicht der Stoff für eine Funktion war nur als Aschauung.

zu deiner LED Ausgabe die sieht bei mir so aus

void seriellData(){
char send[100];
uint8_t cout;

uint8_t help_flash;
uint8_t help_kanal;
uint8_t help_led;

  for (cout=0;cout<datensatz_max;cout++){

  help_flash= led[cout].kanal & 0b00001000;

  help_kanal= led[cout].kanal & 0b00000111;
  help_led  = led[cout].kanal>>4;


  sprintf(send , "Satz %03d  Kanal %03d  Start %03d  T_ON %03d  T_OFF 
%03d  Flash %03d   LED %03d",

  cout,help_kanal,led[cout].start,led[cout].t_on,led[cout].t_off,help_flas 
h,help_led);

      uputsnl(send );
                  }
    uputintnl(datensatz_max);
}

[Karl H. (kbuchegg)]

Wolfgang Hopperdietzel schrieb:

> oder die 4. .t_off ohne deren Namen zu nennen
>
> zb led[variable][satz]= 99;

Das geht offiziell so nicht.
Wenn du das willst, dann nimm ein 2-D Array.

> zu meiner Funktion wiso sollte sie fehlerhaft sein
> dcount,data und max  ist deklariert.
>  und  in einer for Schleife wird Data ein wert zugewiesen

Weil sie seltsam aussieht. Insbesonder mit diesen Variablennamen und 
unter Berücksichtigung desen was in der Funktion geschieht.

[Checker (Gast)]

Hallo,

darf ich fragen was hier mit Tipparbeit erspart gemeint ist?
Für welchen weiteren Ausbau ist das angedacht?

struct led_Data_t {    // so sieht prinzipiell eine LED aus
  uint8_t kanal;
  int8_t  start;
  int8_t  t_on;
  int8_t  t_off;
};

typedef struct led_Data_t led_Data;  // noch ein typedef um Tipparbeit zu sparen

led_Data led[datensatz_max];    // hier sind alle Led versammelt

man könnte doch schreiben ...

struct led_Data_t {    // so sieht prinzipiell eine LED aus
  uint8_t kanal;
  int8_t  start;
  int8_t  t_on;
  int8_t  t_off;
}led[datensatz_max];

[Dirk B. (dirkb2)]

Es geht um das nicht mehr tippen von "struct" bei weiteren 
Variablendefinitionen.

In C++ kannst du das einfach weglassen, bei C jedoch nicht.
Darum das typedef.

[Rufus Τ. F. (rufus)]

Checker schrieb:
> man könnte doch schreiben ...

Könnte man. Aber jedesmal, wenn irgendwo der Strukturtyp benötigt wird, 
sei es, um einen Pointer drauf zu vereinbaren, oder um einen 
Funktionsparameter zu basteln, muss man "struct led_Data_t" schreiben, 
anstelle von "led_Data".

Obendrein kann diese Strukturdefintion/deklaration nicht sinnvoll in 
einer Headerdatei untergebracht werden, weil dann die Variable led[] 
jedesmal beim Einbinden der Headerdatei erneut angelegt wird.

[Checker (Gast)]

aha, Danke für die Info, kann ich bestimmt mal gebrauchen ...