| (5 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) | |||
| Zeile 1: | Zeile 1: | ||
Ich empfehle eine Algorithmus, der in etwa einer exponentiellen Glättung entspricht. Dies Methode ist deutlich einfacher zu implementieren und liefert bereits ab dem ersten Messwert sinnvolle Ergebnisse. Nachteil/Vorteil (je nach Applikation) reagiert schneller auf Änderungen. | Ich empfehle eine Algorithmus, der in etwa einer exponentiellen Glättung entspricht. Dies Methode ist deutlich einfacher zu implementieren und liefert bereits ab dem ersten Messwert sinnvolle Ergebnisse. Nachteil/Vorteil (je nach Applikation) reagiert schneller auf Änderungen. | ||
| − | y(t) = a * (y(t-1)) + (1-a) * x | + | <code> |
| + | <br/> | ||
| + | y(t) = a * (y(t-1)) + (1-a) * x<br/> | ||
| + | <br/> | ||
| + | y(t): neuer Schätzwert<br/> | ||
| + | y(t-1): alter Schätzwert<br/> | ||
| + | x: neuer Messwert<br/> | ||
| + | a: Gewicht im Bereich 0..1<br/> | ||
| + | <br/> | ||
| + | </code> | ||
| + | Bei z.B. a=1/2 werden neuer Messwert und alter Schätzwert gleich Gewichtet. Bei 2/3 wird mehr Gewicht auf den alten Schätzwerr gelegt, d.h. die Werte ändern sich bei Spüngen langsamer. Zu empfehlen sind Zweierpotenzen. Dann kann man mit Shift-Operationen auskommen und auf Fließkomma-Verarbeitungen verzichten. Die ist auf µCs äußerst ineffizient. | ||
| − | + | Also (in C)<br/> | |
| − | y( | + | <code> |
| − | x: | + | a= 1/2: y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder: y = (y + x) >> 1 (ist genauer)<br/> |
| − | a | + | a= 1/4: y = (y >> 2) * 3 + (x >> 2) oder: y = ((y * 3) >> 2) + (x >> 2) |
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
a = 1/2<br\> | a = 1/2<br\> | ||
t 0 1 2 3 4 5 6 7 8 9<br\> | t 0 1 2 3 4 5 6 7 8 9<br\> | ||
x 0 0 50 50 50 50 50 50 40 50<br\> | x 0 0 50 50 50 50 50 50 40 50<br\> | ||
| − | y 0 0 25 37 43 46 48 49 45 47<br\> | + | y 0 0 25 37 43 46 48 49 45 47<br\> |
| − | + | ||
| + | </code> | ||
Du siehst: Extrem effizient. Ein Variable (y) eine Programmzeile. Wenn man höhere Genauigkeit möchte, kann man Festkommazahlen verwenden. | Du siehst: Extrem effizient. Ein Variable (y) eine Programmzeile. Wenn man höhere Genauigkeit möchte, kann man Festkommazahlen verwenden. | ||
Aktuelle Version vom 29. Dezember 2009, 10:58 Uhr
Ich empfehle eine Algorithmus, der in etwa einer exponentiellen Glättung entspricht. Dies Methode ist deutlich einfacher zu implementieren und liefert bereits ab dem ersten Messwert sinnvolle Ergebnisse. Nachteil/Vorteil (je nach Applikation) reagiert schneller auf Änderungen.
Bei z.B. a=1/2 werden neuer Messwert und alter Schätzwert gleich Gewichtet. Bei 2/3 wird mehr Gewicht auf den alten Schätzwerr gelegt, d.h. die Werte ändern sich bei Spüngen langsamer. Zu empfehlen sind Zweierpotenzen. Dann kann man mit Shift-Operationen auskommen und auf Fließkomma-Verarbeitungen verzichten. Die ist auf µCs äußerst ineffizient.
y(t) = a * (y(t-1)) + (1-a) * x
y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1
Also (in C)
a= 1/2: y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder: y = (y + x) >> 1 (ist genauer)
a= 1/4: y = (y >> 2) * 3 + (x >> 2) oder: y = ((y * 3) >> 2) + (x >> 2)
a = 1/2<br\>
t 0 1 2 3 4 5 6 7 8 9<br\>
x 0 0 50 50 50 50 50 50 40 50<br\>
y 0 0 25 37 43 46 48 49 45 47<br\>
Du siehst: Extrem effizient. Ein Variable (y) eine Programmzeile. Wenn man höhere Genauigkeit möchte, kann man Festkommazahlen verwenden.
Wenn man ein System beschreiben will, bei dem Schwankungen/Sprünge nicht zufällig auftreten, sollte man sich überlegen, eine einfache Glättung zu nutzen. In deinem Beispiel sieht es so aus, als ob eine Spannungsquelle eingeschaltet wird. Da sollte man etwas einbauen, dass einen solchen Sprung erkennt und die alten Werte verwirft. Der langsame Spannungsanstieg, der durch die Glättung ermittelt wird, ist nur vorgetäuscht.
Im weiteren verlauf deines Beispiels tauchen (zufällige) Messwertschwankungen auf, die lassen sich durch eine Glättung wirklich gut ausmitteln.
