Mittelwert über 3 Werte bilden

[Michael (Gast)]

Hallo,

ich möchte einen Mittelwert über 3 Werte bilden, jedoch habe ich einen 
Fehler. Der Wert ist zu gering. Kann mir jemand auf die Sprünge helfen?

#define INTEGRAL 3

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

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

[Matthias L. (Gast)]

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

#define INTEGRAL 3

float integralWert(float i_flInValue)
{
  //-- declare locals --------------------------
         float  _flClrValue        = 0;
  static float  _flSum             = 0;
  static float  _flArray[INTEGRAL];
  static u08    _u8Count           = 0;
  static u08    _u8FillLevel       = 0;
  //-- fill into array -------------------------
  if ( _u8FillLevel != 0 )  _flClrValue = _flArray[count]
  if ( _u8FillLevel < INTEGRAL )
  {
    _u8FillLevel++;
   _flSum += i_flValue;
  }
  else
  {
    _flSum = ( _flSum - _flClrValue + i_flValue );
  }
  _flArray[count] = i_flInValue;
  count = ( (count+1) % INTEGRAL );
  //-- calculate ------------------------------
  return ( _flSum / _u8FillLevel );
}

[Hans (Gast)]

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:

#define INTEGRAL 3

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

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

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

#define INTEGRAL 3

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

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

[Walter (Gast)]

count noch initialisieren?

[Hans (Gast)]

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

[Hans (Gast)]

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

also noch

static u08 count=0;

[Hans (Gast)]

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);
}

[Michael (Gast)]

Vielen Dank für den Service.

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

[Karl H. (kbuchegg)]

Ist dein Wert INTEGRAL immer 3 (oder zumindest nicht wesentlich
größer als 3).

Wenn ja, dann würde ich gar nicht lang umtun und das straight
Forward machen

#define INTEGRAL 3

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

  lastValue[count++] = Value;
  count %= INTEGRAL;
  for( i = 1; i < INTEGRAL; ++i )
    iValue += lastValue[i] - lastValue[i-1];

  return iValue / INTEGRAL;
}

Alleine durch das Fortfallen einer Division gewinnst du soviel
Zeit, dass du dir eine Menge anderer Berechnungen erlauben kannst.
Ausserdem hast du den Vorteil, dass sich Rundungsfehler auf die
Art über längere Zeit gesehen nicht aufsummieren.

[Hans (Gast)]

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.

[gast (Gast)]

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.

[Stefanie B. (sbs)]

gast wrote:
> 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.

ggf kann man auch statt Wert3 den alten Mittelwert nehmen.
Oder man nimmt 16 Werte, also 5 mal den ersten plus 5 mal den 2. plus 5 
mal den dritten und ein alten Mittelwert o. Ä.