Overflow bei pointer in structure

Hans wrote:
> Danke für die Hilfe,
>
> aber es hapert immer noch irgendwo.

Was heist das genau?

In deiner Funktion ist ansonsten so nichts mehr zu sehen.
Solange index einen Wert groesser/gleich 6 hat und
die Werte auch richtig im Array abgelegt sind, muss das
funktionieren.

Hans wrote:
>     if(index>=29)
>        index=0;


Ööhm.
Wenn index den Wert 0 hat, was ergibt dann index - j.
Dieser Ausdruck kommt in deiner Ermittlungsfunktion vor
und j nimmt innerhalb der Schleife Werte zwischen 0 und 6
an.
Wenn also index gleich 0 ist und j schon auf den Wert 6
vorgerückt ist, dann wird 0 - 6 zu -6. Und ein Array
Element mit dem Index -6 wirst du in keinem Array finden.

Hans wrote:
> Ah, danke!
>
> Wenn ich einen Pointer auf die Mittelwerte setze und dann den Pointer
> andauernd inkrementiere, läuft dieser dann im Kreis (springt nach dem
> letzten wieder zum Ersten),

Nein.
Warum sollte er?

> oder zeigt er dann ins Nirvana?

Jep. Aber vergiss Pointer. Die bringen dich hier auch nicht
weiter.

Du musst deine Aufgabenstellung neu durchdenken. Vor allen
Dingen was du machen willst wenn weniger als 7 Mittelwerte
vorhanden sind und du aber den größten Mittelwert von 7
auf Biegen und Brechen bestimmen willst. Das kann dich
dann zur Lösung für dein jetziges Problem führen.

Hans wrote:
> So? oder gehts noch einfacher?

Was heist einfacher.
Erst mal sollte es richtig sein :-)

Vergleichst du
>                  if(sensoren[i].Mittelwert[index-j-1]>highVal)
                                  hier:      *********
>                      highVal=sensoren[i].Mittelwert[index-j];
                                  mit:                *******
>              }
>              else
>              {
>                   if(sensoren[i].Mittelwert[29+index-j]>highVal)
            und nochmal                hier:  **********

>                       highVal=sensoren[i].Mittelwert[index-j];
                                       mit:            *******

Das wird wohl nichts werden, wenn du ein ganz anderes Element
zum vergleich benutzt, als das von dem dann die Zuweisung
ausgeht.

Was lernen wir daraus?
Kommt eine 'komplexe' Berechnung mehrmals in einem Codestück
vor, dann lohnt es sich immer, dafür eine Variable abzustellen
und die Berechnung zuerst mal nur einmal zu machen und das Ergebnis
in dieser Variablen zuwischenzuspeichern. In Folge wird dann anstelle
der Berechnung die Variable benutzt.

Was lernen wir noch daraus?
Das Code bei dem allesineinerWurschtgeschriebenwird nicht gerade
die Übersichtlichkeit fördert. Ein paar Leerzeichen an strategischen
Stellen positioniert können den Unterschied ausmachen zwischen
einem Code der fehlerhaft ist und einem Code bei dem einem
die Fehler nur so in die Augen springen. Ein paar Leerzeichen
hie und da dauern weder länger zum tippen noch bekommt man
Ausschlag davon.

1

void Evaluation()

2

{

3

    uint8_t  i, j;

4

    uint16_t highVal=0;

5

    uint8_t  testIndex;

6

7

    for( i = 0; i < 12; i++ )

8

    {

9

        for( j = 0; j < 7; j++ )

10

        {

11

            testIndex = index - j;

12

            if( index < j )

13

                testIndex += 30;

14

15

            if( sensoren[ i ].Mittelwert[ testIndex ] > highVal )

16

                highVal = sensoren[ i ].Mittelwert[ testIndex ];

17

        }

18

    }

19

20

    vPutnLCD( highval );

21

}