Array in Struktur

[Günter G. (Gast)]

Hallo Forum,

in einer Struktur habe ich ein paar Arrays:

struct LEDstruct {
  uint8_t Rot[61];
  uint8_t Gruen[61];
  uint8_t Blau[61];
};

in einer Funktion sollen nun Werte der Arrays verändert werden:

for(i = 1;i<64;i++){
      h = Helligkeit[i];
      LEDPointer->Rot[g] = h;
      LEDPointer->Gruen[g] = h;
      LEDPointer->Blau[g] = h;
      LEDPointer->Rot[j] = h;
      LEDPointer->Gruen[j] = h;
      LEDPointer->Blau[j] = h;
      updateAll(LEDPointer);
        }

Komischerweise werden alle nicht in der Schleife gesetzten LEDs 
gelöscht. Warum?

[Peter II (Gast)]

Günter G. schrieb:

> for(i = 1;i<64;i++){
>       h = Helligkeit[i];
>       LEDPointer->Rot[g] = h;
>       LEDPointer->Gruen[g] = h;
>       LEDPointer->Blau[g] = h;
>       LEDPointer->Rot[j] = h;
>       LEDPointer->Gruen[j] = h;
>      LEDPointer->Blau[j] = h;
>       updateAll(LEDPointer);
>        }

woher sollen wir wissen was in g und j steht?

Und was macht updateAll? Ich befürchte fast, das hier eine kopie der 
stuktur gemacht wird.


> Komischerweise werden alle nicht in der Schleife gesetzten LEDs
> gelöscht. Warum?

das versteht niemand

[Oliver (Gast)]

Weil dein Programm fehlerhaft ist.

Nicht in dem gezeigten unvollständigen und nicht kompilierbaren 
Aussschnitt, sondern irgendwo anders. Zeig mal das genze Programm, oder 
zumindest den ganzen relevanten Abschnitt daraus.

Oliver

[Günter G. (Gast)]

Hallo Peter,

das wird es vermutlich sein:

void updateAll(struct LEDstruct* LEDPointer){
  Write1(LEDPointer);
  Write2(LEDPointer);
  Write3(LEDPointer);
  Write4(LEDPointer);
  Write5(LEDPointer);
  Write6(LEDPointer);
  Write7(LEDPointer);
  Write8(LEDPointer);
  Write9(LEDPointer);
  Write10(LEDPointer);
  Write11(LEDPointer);
  Write12(LEDPointer);
}

[Peter II (Gast)]

Günter G. schrieb:
> Hallo Peter,
> das wird es vermutlich sein:
> void updateAll(struct LEDstruct* LEDPointer){

nein ist es nicht, du übergibst einen Zeiger das ist schon ok.

Aber ich(wir) verstehen das Problem immer noch nicht. Zeige den gesamten 
code.

[Karl H. (kbuchegg)]

Mehr Code!

Aber:

Das hier

struct LEDstruct {
  uint8_t Rot[61];
  uint8_t Gruen[61];
  uint8_t Blau[61];
};

ist höchst wahrscheinlich verkehrt rum aufgezogen. Denn der logische 
Zusammenhang zwischen Rot/Grün/Blau ist stärker als die Tatsache, dass 
es 61 Stück davon gibt. D.h. das sollte so sein

struct LEDstruct {
  uint8_t Rot;
  uint8_t Gruen;
  uint8_t Blau;
};

Diese Struktur beschreibt 1 RGB-Led. Und davon, also von den RGB-Leds, 
hast du 61 Stück.

struct LEDstruct myLeds[61];

myLeds[5] wären dann zb die Daten der 6ten Led. Jede einzelne LED 
besteht aus einer Rot-Komponente, einer Gruen Komponente und einer Blau 
Komponente. Die Rot-Komponente der 6-ten LED ist dann myLeds[5].Rot 
Jetzt liest sich das auch von links nach rechts in einer logisch 
sinnvollen Art und Weise vom Groben zur Detailinformation.

    myLeds            das sind alle Leds
    myLeds[5]         das ist eine einzelne aus dem Pool aller Leds
    myLeds[5].Blau    das ist eine Farbe einer einzelnen Led aus
                      dem Pool aller Leds.

Stukturen muss man auch sinnvoll einsetzen. Sonst bringen sie nichts.

[Karl H. (kbuchegg)]

Günter G. schrieb:
> Hallo Peter,
>
> das wird es vermutlich sein:

Nein.

Hör mit deiner Salamitaktik auf und zeig alles.

[Günter G. (Gast)]

In main():

struct LEDstruct LEDs;
while(1)
    {
        loading(&LEDs);
    }

void loading(struct LEDstruct* LEDPointer){
  uint8_t sm;
  uint8_t sn;
  uint8_t j;
  uint8_t i;

  for(i = 1;i<61;i++){
    LEDPointer->Rot[i] = 0;
    LEDPointer->Gruen[i] = 0;
    LEDPointer->Blau[i] = 0;
  }
  updateAll(LEDPointer);

  j = 31;
  for(sn=30;sn>0;sn--){
    for(i = 1;i<64;i++){
      sm = Helligkeit[i];
      LEDPointer->Rot[sn] = sm;
      LEDPointer->Gruen[sn] = sm;
      LEDPointer->Blau[sn] = sm;
      LEDPointer->Rot[j] = sm;
      LEDPointer->Gruen[j] = sm;
      LEDPointer->Blau[j] = sm;
      updateAll(LEDPointer);
    }
   j++;
    updateAll(LEDPointer);
  }
  clearAll(LEDPointer);

}

Wird durch struct LEDstruct* LEDPointer eine neue Kopie erzeugt?

[Karl H. (kbuchegg)]

Günter G. schrieb:

> Wird durch struct LEDstruct* LEDPointer eine neue Kopie erzeugt?

Nein. Du brauchst ganz dringend ein C-Buch

Und gewöhn dich daran, dass wir in C

  for(i = 1;i<61;i++){

bei 0 anfangen zu zählen!

Ein Array mit 3 Elementen

int arr[3];

besteht aus den Elementen

  arr[0]
  arr[1]
  arr[2]

zähl nach, sind genau 3 Stück.

[Malte S. (maltest)]

Günter G. schrieb:
> for(i = 1;i<61;i++){
>     LEDPointer->Rot[i] = 0;
>     LEDPointer->Gruen[i] = 0;
>     LEDPointer->Blau[i] = 0;
>   }

Macht also was du ihm sagst?

[Karl H. (kbuchegg)]

Und dein gezeigter Code hilft immer noch nicht zu erklären, was du unter

> Komischerweise werden alle nicht in der Schleife gesetzten
> LEDs gelöscht. Warum?

eigentlich genau verstehst, bzw. wie man dieses 'gelöscht' deuten soll. 
Was sind 'nicht alle'?

[Stefan E. (sternst)]

Günter G. schrieb:
> Komischerweise werden alle nicht in der Schleife gesetzten LEDs
> gelöscht. Warum?

Weil du vor der "Setzen-Schleife" eine "Komplett-Löschen-Schleife" hast.
Was also erwartest du?

[PittyJ (Gast)]

Also ich werde daraus nicht schlau.

Warum sind es mal 61, und mal 31?

Am besten, man definiert richtige Konstanten dafür.

Was soll die Variable sn? Kann man der nicht einen vernünftigen Namen 
geben, damit auch Unbeteiligte wissen, was das bedeutet?
Kommentare wären auch ganz nützlich.

Schleifen, die mit 1 beginnen, sind auch immer suspekt. Was ist mit dem 
0-Element?

[Günter G. (Gast)]

Hallo,

ja, im Code werden alle LEDs erstmal auf 0 gesetzt.

Dann wird LED 30 und 31 hochgedimmt. Danach 29 und 32, da soll aber 30 
und 31 anbleiben, geht aber wieder aus.

Bei 1 fange ich deshalb an, weil es bei den LEDs auch mit eins losgeht 
und ich diese Stolperfalle weghaben wollte.

[Malte S. (maltest)]

Das ergibt sich doch ganz klar alles aus dem Code. Vielleicht. Also aus 
dem Teil des Codes, den es wohl nur nach Unterzeichnung eines NDA gibt. 
Was schlecht ist, wenn man etwas will.

[Karl H. (kbuchegg)]

> Bei 1 fange ich deshalb an, weil es bei den LEDs auch mit eins
> losgeht und ich diese Stolperfalle weghaben wollte.

Na wart mal ab.
Dieses 'bei 1 anfangen' ist die viel größere Stolperfalle.

Im übrigen bin ich raus. Ratespielchen kann ich mit meinem eigenen Code 
auch veranstalten. Den seh ich wenigstens komplett, auch wenn ich mir 
manchmal wünschen würde es wäre weniger.

[Günter G. (Gast)]

Ich gebe auch auf.

Danke für die sachliche und geduldige Hilfe.

[Stefan E. (sternst)]

Günter G. schrieb:
> Dann wird LED 30 und 31 hochgedimmt. Danach 29 und 32, da soll aber 30
> und 31 anbleiben, geht aber wieder aus.

Dann zeige die Definition von 'Helligkeit'. Vermutlich hast du da bei 
der Initialisierung nicht an deinen "Index-Offset" gedacht.

[Malte S. (maltest)]

Günter G. schrieb:
> ja, im Code werden alle LEDs erstmal auf 0 gesetzt.

Okay, auch wenn ich die Verwendung von memset() erwägen würde. Oder 
clearAll()? Zumindest klingt das so.

> Dann wird LED 30 und 31 hochgedimmt. Danach 29 und 32, da soll aber 30
> und 31 anbleiben, geht aber wieder aus.

Und dafür soviel Rumgeschwätze im Code?
Hättest du wie Karl-Heinz schon sagte ein Array von Strukturen, könntest 
du auch das mit memset() erledigen. Und anstatt zwei Variablen 
unabhängig voneinander zu zählen, könnte dir auffallen, das etwas wie

for (i = 0; i < 30; ++i) {
  LEDPointer->Rot[30 - i] = ...
  LEDPointer->Rot[31 + i] = ...
}

dein Ansinnen ohne jeden weiteren Kommentar und zweiten Blick 
dokumentiert hätte.

> Bei 1 fange ich deshalb an, weil es bei den LEDs auch mit eins losgeht
> und ich diese Stolperfalle weghaben wollte.

Um dich nicht am Kaffee zu verbrennen, trinkst du ihn auch immer kalt? 
Das ist doch Käse, mal davon abgesehen, dass du so pro Farbei ein Byte 
(Index 0) verschwendest.

Apropos verschwenden: wieviel SRAM hat denn dein Controller? Passen da 3 
mal 61 Byte plus Stack plus was noch alles im geheimen Restcode 
verwendet wird rein? Oder wird vielleicht das Array durch eine der 
unzähligen lokalen Variablen überschrieben - wobei die wegoptimiert 
werden sollten, aber deine Compilerflags kennen wir ja auch nicht.