www.mikrocontroller.net

Forum: Compiler & IDEs Mittelwert über 3 Werte bilden


Autor: Michael (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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);
}

Autor: Matthias Lipinsky (lippy)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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 );
}

Autor: Hans (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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);
}

Autor: Walter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
count noch initialisieren?

Autor: Hans (Gast)
Datum:

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

Autor: Hans (Gast)
Datum:

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

also noch
static u08 count=0;

Autor: Hans (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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);
}

Autor: Michael (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielen Dank für den Service.

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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Hans (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: gast (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Stefanie B. (sbs)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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. Ä.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.