Mittelwert über 3 Werte bilden

Das sieht sehr komisch aus. Versuchs mal so. Habs aber nicht getestet:

1

#define INTEGRAL 3

2

3

float integralWert(float i_flInValue)

4

{

5

  //-- declare locals --------------------------

6

         float  _flClrValue        = 0;

7

  static float  _flSum             = 0;

8

  static float  _flArray[INTEGRAL];

9

  static u08    _u8Count           = 0;

10

  static u08    _u8FillLevel       = 0;

11

  //-- fill into array -------------------------

12

  if ( _u8FillLevel != 0 )  _flClrValue = _flArray[count]

13

  if ( _u8FillLevel < INTEGRAL )

14

  {

15

    _u8FillLevel++;

16

   _flSum += i_flValue;

17

  }

18

  else

19

  {

20

    _flSum = ( _flSum - _flClrValue + i_flValue );

21

  }

22

  _flArray[count] = i_flInValue;

23

  count = ( (count+1) % INTEGRAL );

24

  //-- calculate ------------------------------

25

  return ( _flSum / _u8FillLevel );

26

}

Dein iValue muss auch static sein.
Und die Zuweisung muss so aussehen: iValue += (Value - lastVal ......

D.h. du nimmst deinen "alten" Mittelwert, ziehst den (ältesten 
Wert)/INTEGRAL ab und addierst den (neusten Wert)/INTEGRAL und erhältst 
somit den neuen Mittwelwert über 3 Werte.

Sieht dann so aus:

1

#define INTEGRAL 3

2

3

float integralWert(float Value)

4

{

5

  static float  iValue = 0;

6

  static float lastValue[INTEGRAL];

7

  static u08 count;

8

9

  lastValue[count++] = Value;

10

  count %= INTEGRAL;

11

  iValue += (Value - lastValue[(count + INTEGRAL - 2) %INTEGRAL])/INTEGRAL;

12

  return(iValue);

13

}

Ich würds aus Übersichtlichkeitsgründen aber bisschen anders machen, und 
zwar so:

1

#define INTEGRAL 3

2

3

float integralWert(float Value)

4

{

5

  static float  iValue = 0;

6

  static float lastValue[INTEGRAL];

7

  static u08 count;

8

9

  iValue -= lastValue[count]/INTEGRAL;

10

  lastValue[count++] = Value;

11

  count %= INTEGRAL;

12

  iValue += Value/INTEGRAL;

13

  return(iValue);

14

}

count noch initialisieren?

braucht man im prinzip net.
Ob er jetzt das Array von 0 an vollstopft, oder den ersten Wert in die 2 
steckt ist Wurst.

Oh braucht man doch, beim ersten Zugriff auf das Array steht ja kein % 
INTEGRAL

also noch

1

static u08 count=0;

und noch was..
Sorry für die vielen Posts, aber so früh am morgen, naja, ihr wisst 
schon :P

#define INTEGRAL 3

float integralWert(float Value)
{
  static float  iValue = 0;
  static float lastValue[INTEGRAL];
  static u08 count;

  iValue -= lastValue[count]/INTEGRAL;
  count++;
  count %= INTEGRAL;
  lastValue[count] = Value;

  iValue += Value/INTEGRAL;
  return(iValue);
}

Vielen Dank für den Service.

Ich habe vergessen zu Erwähnen dass es um die Differenzen der Werte geht 
und daraus das Mittel.

Naja, die Schleife kann man sich trotzdem sparen, Fällt natuerlich nur 
für grosse INTEGRAL ins Gewicht.

Aber nochmal zu deinem Problem: Du Willst Mittelwert der Differenzen.
Dann stimmt die Zuweisung
[c]
iValue = (Value - lastValue[(count + INTEGRAL - 2) %INTEGRAL])/INTEGRAL;
[c\]

Und dann müsste dein ursprünglicher Code eigentlich auch richtig sein, 
bis auf die fehlende Initialisierung von count. Ohne Initialisierung 
kann ja sein dass count irgendeinen Wert hat der ausserhalb der Array 
Grenzen liegt und somit dein erster value sonstwo im Speicher landet und 
natuerlich für die folgende Mittelung nicht zur Verfügung steht.
Ausserdem liefert deine Funktion erst nach 3maligem Aufruf sinnvolle 
Werte, davor ist das Array ja noch nicht komplett mit deinen Werten 
gefüllt.

Hier ein Ansatz µC mit wenig Resourcen , also ohne float nur unsigned 
char und unsigned short:

Allg. Ansatz : Wert1+Wert2+Wert3+Wert3 / 4 = MW über 3 Werte

Hier braucht nur geschoben zu werden "<<1" und ">>2"

Auch wenn Wert3 nun die doppelte Gewichtung besitzt, sollte dies
womöglich für die Anwendung auch egal sein.

Nach dem Teilen ">>2" darf natürlich das Runden der Nachkommastellen
nicht vergessen werden.