Kalman Filter für BASCOM

[harry1]

Hallo,

hat von euch schon mal jemand versucht einen Kalman Filter in Bascom zu schreiben?

Gruß
Harry

[Vitis]

hab ich nicht, hast mich aber auf ne Idee gebracht ...
werd mir mal diesen:
http://www.techsystemsembedded.com/Kalman.html
Quellcode zur Brust nehmen ... schaut nicht schlecht aus.

[harry1]

Hallo Vitis,

meinst du du krigst das in Bascom zum laufen, das wäre KLASSE.

Gruß
Harry

[Vitis]

der Filter 1. Ordnung ging recht easy:





'%************************************************ ************
'% Marko Hoerner, 2009
'%
'% Kalman Filter For 1st Order System Sensor Input
'% ported to Bascom AVR
'%
'%************************************************ ************


Dim Noisysen(128) As Integer ' Sensordata
Dim Z(128) As Byte
Dim Index(128) As Integer
Dim X_hat(128) As Integer
Dim X_hat_min(128) As Integer

Dim Tempsingle_1 As Single
Dim Tempsingle_2 As Single
Dim N As Byte
Dim N2 As Byte
Dim Pmin1 As Single
Dim P As Single
Dim K As Single
Dim Pmin As Single
Dim Tempbyte As Byte

'Adjust Length for length of dataarray
Const Length = 40
Const Q = 1
'Adjust R for Degree of Damping
Const R = 10

' randomized data for test
For N = 1 To Length
Tempbyte = Rnd(100)
Noisysen(n) = Tempbyte
Print Noisysen(n) ; " ";
Next

Print

For N = 1 To Length
Z(n) = Noisysen(n)
Next


For N = 1 To Length
Index(n) = N
Next

Pmin1 = 0

Tempsingle_1 = Pmin1 + R
K = Pmin1 / Tempsingle_1

Tempsingle_1 = Z(1) - Noisysen(1)
Tempsingle_1 = K * Tempsingle_1
X_hat(1) = Tempsingle_1 + Noisysen(1)

P = 1 - K
P = P * Pmin1

Pmin = P + Q

X_hat_min(1) = X_hat(1)


For N = 2 To Length

K = Pmin + R
K = Pmin / K

N2 = N - 1
X_hat(n) = Z(n) - X_hat_min(n2)
X_hat(n) = K * X_hat(n)
X_hat(n) = X_hat_min(n2) + X_hat(n)

P = 1 - K
P = P * Pmin

Pmin = P + Q

X_hat_min(n) = X_hat(n)

Next

For N = 1 To Length
'Print Fusing(x_hat(n) , "#.#") ; " ";
Print X_hat(n) ; " ";
Next
Print

[harry1]

Hallo Vitis,

wie kombinier ich das jetzt mir einem Gyro und ACC.

Gruß
Harry

[Vitis]

oder als Subroutine:

einmal der headerfile




$nocompile

'Adjust Length for length of dataarray
Const Kal_length = 70
Const Kal_q = 1
'Adjust R for Degree of Damping
Const Kal_r = 3

Dim Kal_noisysen(kal_length) As Integer ' Sensordata
Dim Kal_z(kal_length) As Byte
'Dim Index(70) As Integer
Dim Kal_x_hat(kal_length) As Integer
Dim Kal_x_hat_min(kal_length) As Integer


Declare Sub Kalman_filter()


und die sub:



$nocompile

'%************************************************ ************
'% Marko Hoerner, 2009
'%
'% Kalman Filter For 1st Order System Sensor Input
'% ported to Bascom AVR
'%
'%************************************************ ************




Sub Kalman_filter()


Local Kal_tempsingle_1 As Single
Local Kal_tempsingle_2 As Single
Local Kal_n As Byte
Local Kal_n2 As Byte
Local Kal_pmin1 As Single
Local Kal_p As Single
Local Kal_k As Single
Local Kal_pmin As Single
Local Kal_tempbyte As Byte


For Kal_n = 1 To Kal_length
Kal_z(kal_n) = Kal_noisysen(kal_n)
Next

Kal_pmin1 = 0

Kal_tempsingle_1 = Kal_pmin1 + Kal_r
Kal_k = Kal_pmin1 / Kal_tempsingle_1

Kal_tempsingle_1 = Kal_z(1) - Kal_noisysen(1)
Kal_tempsingle_1 = Kal_k * Kal_tempsingle_1
Kal_x_hat(1) = Kal_tempsingle_1 + Kal_noisysen(1)

Kal_p = 1 - Kal_k
Kal_p = Kal_p * Kal_pmin1

Kal_pmin = Kal_p + Kal_q

Kal_x_hat_min(1) = Kal_x_hat(1)


For Kal_n = 2 To Kal_length

Kal_k = Kal_pmin + Kal_r
Kal_k = Kal_pmin / Kal_k

Kal_n2 = Kal_n - 1
Kal_x_hat(kal_n) = Kal_z(kal_n) - Kal_x_hat_min(kal_n2)
Kal_x_hat(kal_n) = Kal_k * Kal_x_hat(kal_n)
Kal_x_hat(kal_n) = Kal_x_hat_min(kal_n2) + Kal_x_hat(kal_n)

Kal_p = 1 - Kal_k
Kal_p = Kal_p * Kal_pmin

Kal_pmin = Kal_p + Kal_q

Kal_x_hat_min(kal_n) = Kal_x_hat(kal_n)

Next
End Sub

[jeffrey]

hoi,
ich denke das ding zu programmieren ist nicht so schwer. das hauptproblem beim kalman filter sehe ich eher im finden von geeigneten paametern.
mfg jeffrey

[Vitis]

jeffrey, full ACK ... wie er das Ding nun
in sein Projekt integriert, also einfacher kann ichs nicht machen,
den Rest muss er halt per Try and Error austüfteln.
Die Aufgabe war ja nen Kalman-Filter, nicht wie bekomm
ich den Gyro stabil :)

aber komischerweise hab ich trotz googeln nicht wirklich
nen lauffähigen Code für bascom gefunden, nur öfters
der Hilferuf nach selbigem.

[Willa]

aber komischerweise hab ich trotz googeln nicht wirklich
nen lauffähigen Code für bascom gefunden, nur öfters
der Hilferuf nach selbigem.
Das stimmt allerdings. Vielleicht finde ich ja auch mal Zeit diesen Filter zu testen. Könnte der Threadstarter bitte den Titel des ganzen Threads ändern in "Kalman Filter für BASCOM - mit Lösung", dann findet sich das hier leichter in Google (einfach den ersten Post editieren).

[Vitis]

Hab den Code bei mir mal eingebaut ... also er macht was ...

einmal die gefilterten Messwerte:


------- Graph Temperatur --------

-
-
20********************************* * *
- ******* * *
- * *****
- * * *
- ****
- * *
- ***
- *
- *
- *
19 *
- ****
-
-
-
-

----------- Graph Gas ------------

8
-
-
-
-
7
-**************************************************
- ***********
- ***
- ******
6
-
-
-
-
5



und einmal die ungefilterten:



------- Graph Temperatur --------
- * * ****** * ** * ***
-*** ************ ** ** * ** ***
20 * * * ** ** *
- ** * * * * *
- * * *
- * *
- *
- *
- *
- * * *
- ** *
-
19 *
- **
- ** *
- *
-
-
-
-
-


----------- Graph Gas ------------
8
-
-
-
-
7 * **
- * ****** **** ** ******** * ** *
-***** * *** * ******** **** * *
- ** ******
- *** ***********
6 * *
- *
-
-
-
5


sorry, mein atmega128 gibt keine jpg aus, das sind
die werte graphisch vom AVR aufbereitet und per
RS485 als Text an den PC übertragen ...

[Dirk123]

Moin!
Ich habe den Code mal nach C portiert und den Filter auf eine verrauschte Sinusschwingung mit verschiedenen R's ausprobiert.
Die Ergebnisse sehen eigentlich ganz nett aus (wobei ich nicht weiß, wie es richtig ist). Was mir jedoch auffällt ist, dass für q=1, r=10 das gefilterte Signal genauso wie eine IIR-Filterung aussieht. Und irgendwie lässt mich das zweifeln, ob der Kalmanfilter so richtig funktioniert ;-)
Die Verläufe könnt ihr im Attachment sehen.

VG Dirk

[Vitis]

Vorab mal merci für die Mühe

hmmm ... ja, Deinem Diagramm nach deckt sich da IIR und der Code von mir ... kann Zufall sein, glaub ich aber nicht. Da ich jetzt nicht das Mathe-Scharnir bin kann ich auch keine Aussage Treffen über die mathematishcen Zusammenhänge zwischen IIR und Kalman 1. Ordnung ... würd das ja schon gern gegenchecken, hast Du ne Quelle für ne Source für Kalman Filter, die ich portieren kann? Würd dann einfach zum Vergleich nen zweiten Code im Vergleich dagegen laufen lassen. Will ja hier keine Unwahrheiten verbreiten.

[Dirk123]

Hi Vitis,
habe leider keinen anderen Code. Ich habe Deinen dankbar aufgegriffen, weil ich auch gerade nach einer einfachen Kalmanfilterimplementierung suche.

Ich glaube, wenn man den richtig verwenden will, kommt man nicht drum rum, den auch zu verstehen :-)

Diese Folien sind ganz anschaulich, vielleicht hilft es Dir weiter:

http://www.cs.unc.edu/~welch/media/pdf/kalmanIntroSlides.pdf


Viele Grüße,
Dirk

[Vitis]

pua ... jetzt hastes mir aber gegeben ...
sorry, aber die Folien blick ich nicht, wie schon gesagt, mathe
ist nicht gerade meine Stärke und Formeln bringen mir daher
auch nicht viel mehr.
Ich wills mal so sagen ... würd mir jemand das Ding mit
Papier und Bleistift aufmalen würd ich sicher durchsteigen;
oder Messwerte im Diagramm liefern und ne Aufgabe draus formulieren
bekäm ich ziemlich problemlos nen laufenden Programmcode aus meinen
bestehenden (geistigen) Mitteln zusammen.
Ich kann noch integrieren und differenzieren,
Kurvendiskussion, aber damit hat es sich dann auch schon.
Bin nicht blöd aber auch kein Genie ... irgendwo dazwischen.
Der obige Code ist einfach 1:1 aus dem ursprünglichen Code
ins Bascom übersetzt ... wie gut der Ursprung war weiß ich nicht,
mangels Vergleich.
In meiner Anwendung gehts darum kurze Peaks aus Messwerten zu filtern,
da das Messverfahren die unregelmäßig Fehler produziert, was sich
hardwaretechnisch nicht oder nur mit großem Aufwand realisieren lässt.
Diese Aufgabe erfüllt das Progrämmchen bei mir tadellos, soweit ists
OK, wie das bei anderen Anwendungen aussieht ... keine Ahnung. :)

Bei mir läuft dann noch zum Vergleich ne lineare Regression parallel
drüber und dann verwurstle ich das ganze miteinander ...
die Regressionsanalyse in bascom zu proggen war haariger als
das Ding oben 8)

[wulle]

Hi Dirk,
ich habe Deinen Code für das Kalman-Filter in VB getestet, da ich auch an einer einfachen Ausführung des Filters interessiert bin. Ich möchte ein Kalman-Filter in ASM auf einem AVR einsetzen.
Bei dem Test hat sich Dein Verdacht bestätigt, der Code funktioniert nicht richtig. Die Verstärkung K läuft immer auf einen Wert von 0.2701562 bei R=10 und Q=1.
Es gibt im Code auch keine Rückkopplung von K auf den aktuellen Messwert.
Man könnte K auch fest auf 0.270... legen und das Ergebnis wurde fast gleich aussehen.

Gruß Wulle

[Vitis]

jep, K wird einmal berechnet:

Kal_tempsingle_1 = Kal_pmin1 + Kal_r
Kal_k = Kal_pmin1 / Kal_tempsingle_1

Die Rückkopplung von K wird im Filter 2. Ordnung
verwendet:

for n = 2: 1: 51;

K = Pmin*H'/(H*Pmin*H'+R);
k_1(n) = K(1,1);
k_2(n) = K(2,1);

der obige Code ist die Übersetzung des Filters erster Ornung ...
Zumindest steht das so in dem bereits verlinkten Dokument:
http://www.techsystemsembedded.com/Kalman.html

an dem darf sich aber wer anders verlustieren ... bin mal auf die Ergebnisse gespannt.

ps: hier gibts nen C++ Code, der auch nicht schlecht aussieht:
http://www.tyforhire.com/papers/sheffield_final.doc

schaut auch recht 'possierlich' aus ... der größte Unterschied scheint
mir das die Zeit als zweite Dimmension mit dazu kommt oder liege ich da falsch? Wenn man dann davon ausgeht das die "Samplerate" konstant ist könnt man sich den Punkt sparen, oder?

[mare_crisium]

@ alle Kalman-Fans,

das Prinzip des Kalmanfilters ist auf Folie 32 der tollen Präsentation gezeigt, die Dirk123 gepostet hat: Man benutzt ein Modell des Vorgangs ("process"), den man beobachtet, und schätzt daraus den nächsten zu erwartenden Messwert ab. Das ist die "a priori-Schätzung"; im Grunde eine Extrapolation. Anschliessend führt man die Messung durch und guckt nach, in wieweit sie mit dem vorher geschätzten Wert übereinstimmt. Ist die Übereinstimmung schlecht, dann wird das Modell des Vorgangs so angepasst, dass die Abweichung zwischen geschätztem und gemessenem Wert möglichst klein wird. Das ist die "a posteriori-Schätzung"; im Grunde eine Korrektur des Modells. Dieser Ablauf wiederholt sich dauernd. Das ist der Kreislauf den die Folie 32 zeigt.

Dass es kein Codebeispiel für "den" Kalmanfilter gibt, liegt daran, dass man unbedingt ein Modell des Vorgangs haben muss; und das sieht immer anders aus, je nachdem, ob z.B. die Fahrt eines Asuros nachgebildet werden soll oder die Fluglage eines Helikopters oder Flugzeugs. Ein Modell des Vorgangs zu erstellen, ist nicht immer einfach (siehe Folie 17ff). Die meisten der Hilferufe, die Vitis erwähnt, beziehen sich denn auch auf die Modellerstellung.

Man kann also einen Kalmanfilter für die Ortsschätzung eines Asuro schreiben und einen für die Fluglage von Willas schönem Tricopter - aber man kann den einen nicht für den anderen verwenden :-(. Schade.

mare_crisium

[Dirk123]

@ mare_crisium:
Da hast du Recht, man muss jedes Mal den Filter an ein neues Modell anpassen. Aber damit beschäftige ich mich ein anderes Mal ;-)

@ Vitis:
Um Peaks herauszufiltern, könntest du auch nen einfachen IIR-Filter benutzen, das ist etwas übersichtlicher als der Kalmanfilter :-)

filter_wert = filter_wert * s + wert * (1.0-s)
wobei s hier ein Wert zwischen 0...1 ist. Bei s=0.75 kam bei mir das gleiche raus wie beim Kalmanfilter.

[Besserwessi]

Ist zwar schon etwa her das ich mit den Kalman filter angesehen habe, und vielleicht habe ich es auch zu sehr vereinfacht. So wie ich das sehe ist der Kalmann filter oft nicht viel anders als ein IIR Filter:
Die Berechnungen mit den Kovarianzmatrizen unabhängig von den Messwerten. Nach einigen Iterationen sollte da was konstantes rauskommen. Damit kann man konstante Werte für die Kovarianzwerte nehmen, und hat dann in den meisten Fällen einfach IIR Filter.

Das Einzige was vom Kalman übrig geblieben ist, dass man eine Methode hat die Filter Parameter auf das Schätzen der Kovarianz-Matrizen zurückzuführen, und dass man ein mathemathische Begründung hat, wieso man gerade so einen Filter nutze und dafür, dass es nicht viel besser geht.

[mare_crisium]

@ Dirk123

guter Vorschlag :-). Man kann das Verfahren noch verfeinern, indem man die Abweichung des neuen Messwertes vom alten Mittelwert berücksichtigt; also den alten Mittelwert mit einer mittleren Abweichung gewichtet und den neuen mit seiner Abweichung vom alten Mittelwert. Wenn's interessiert, kann ich Formeln mal posten.

@Besserwessi,

ja, wenn das Filter das Modell optimal angepasst hat, ändert sich nichts mehr daran. D.h. wenn man die richtigen Werte errät oder sie durch Probieren herausbekommt, kann man sich den ganzen Aufwand mit der Rückkopplung sparen. Da hast Du recht. - Manchmal habe ich auch den Eindruck, als würde das Kalmanfilter als so eine Art Wundermittel betrachtet ;-). Das Paradebeispiel sind Willas Beschleunigungssensoren: Wo andere angefangen hätten, mit einem Kalmanfilter herumzuzaubern, hat er das ganze Rauschthema mit einem simplen RC-Hardwarefilter erledigt

mare_crisium

[Dirk123]

@ mare_crisium

Ja, die Formeln interessieren mich! Wäre sehr nett, wenn du sie mal posten würdest!

VG Dirk

[mare_crisium]

Dirk,

hier ist meine Berechnung. Du musst sie kritisch lesen, weil sie etwas freihändig abgeleitet ist ;-) . Der Pferdefuss ist mir leider zu spät aufgefallen: Wenn ein Messwert sehr nahe am vorherigen Wert des Mittelwerts liegt, dann gibt's eine Division durch Null. Ich habe inzwischen verschiedene andere Gewichtsfunktionen ausprobiert, um das Problem zu umgehen, leider bisher ohne Erfolg. Vielleicht hast Du ja einen guten Einfall :-) !

mare_crisium

Edit1: Anhang gelöscht wg. Upload-Quota

[Dirk123]

Danke mare_crisium!
Habe mir die PDF gerade angesehen, sieht ganz interessant aus. Aber um das zu verstehen, muss ich mir das wohl erstmal etwas näher zu Gemüte führen :-)
Die PDF hast du mit OpenOffice erstellt? Hat das etwa einen brauchbaren Formeleditor?

Viele Grüße!

[Besserwessi]

Das Problem mit dem großen Gewicht bei Werten, die zufällig dem alten Mittelwert entsprechen, sollte sich lösen lassen. Am einfachsten, indem man einfach eine feste obere Schranke einbaut. Das könnte etwa so sein, das der letzte Wert maximal etwa 1/3 des Gesamtwichtes haben kann.
Eine andere alternative wäre es statt der harten Begrenzung eine nichtlineare Funktion zu nutzen, die bei einem Wert in Sättigung geht. Z.B. statt 1/(Xn+1-Xm)^2 einfach 1/((Xn+1- Xm)^2 + const.)

Schon ein interessanter Ansatz, aber es gibt noch ein paar Probleme:
Wenn man einmal k Werte hat zu zufällig gleich sind, das kann beim AD mit nicht so viel Auflösung und eher kleinem k) schon mal vorkommen, dann werden andere Werte kaum noch berücksichtige und man kommt kaum davon weg.

Wenn die Werte wirklich stark verrauscht sind, kommt auch mal ein Wert nahe dem alten Mittelwert zufäälig vor, und der wird dann besonders stark gewertet. Das ist aber für ein normalverteiltes Rauschen nicht ideal. Ideal wäre da ein einfaches konstates gewicht.

Die Idee Werte die Weit von dem erwarteten Mittelwert abweichen schwächer zu gewichten findet man in sogenanten robusten Schätzern. Die Idee dabei ist es einzelen Ausreißer die mehr oder weniger offensichtlich nicht zu den anderen Werten passen nicht zu berücksichtigen. Der eher übliche Weg ist es Regeln zu finden welche Werte als Ausreißer gelten und dann gar nicht mehr berücksichtiget werden. Das könnten werte sein, die mehr als z.B. 4 mal so stark vom alten mittelwert abweichen wie sonst üblich. Oder man verwirft von z.B. 10 Werten den größten und den kleinsten. Bis hin zum Median, als nur dem Wert mit mittlerer Größe aus den letzten k werten.

Verglichen mit dem Verfahren oben, werden dabei die meisten werte gleich gewichtet, nur Werte die wirklich weit abweichen bekommen weniger Gewicht. Die oben vorgeschlagene Begrenzung der Gewichte ist also mehr die Regel als die Ausnahme.

[mare_crisium]

@Dirk,

ja, der Formeleditor von OpenOffice ist ziemlich gut.

@Besserwessi,

danke für die Anregungen :-) , ich werde sie mir durch den Kopf gehen lassen. Die Schwäche mit den Messwerten nah am Mittelwert ist mir bewusst; nur hat mich keine der alternativen Gewichtungsfunktion, die ich bisher ausprobiert habe, wirklich überzeugt.

Am Besten ist es natürlich, wenn der Sensor gleich auch ein Genauigkeitsmass liefert: Z.B. beim GPS-Empfänger die Anzahl empfangener Satelliten oder beim Maussensor die Anzahl beobachteter Einzelheiten.

mare_crisium

[Sternthaler]

Hallo Filtersucher,

ich bin bei meiner Recherche vor einiger Zeit auf http://www.winfilter.20m.com/ gestoßen.
Natürlich wird dort auch kein Kalmanfilter geboten, aber man kann so einige Filtertypen einstellen (IIR/FIR Low-/High-Pass/... Butherworth/Chebychev/Bessel/...). Auch die Filterordnung ist einstellbar.

Das geniale an dem Programm ist, dass es C-Code erzeugt und dazu die Koeffizienten für den Filter aus den Eingaben berechnet und gleich mit im Code einträgt.
Der Haken ist natürlich die Zeitabhängigkeit der Filter. Die generierte Funktion muss halt immer zeitlich passend aufgerufen werden. Aber das ist ja normal.


Ansonsten kann ich mich Vitis nur anschließen, wenn es um Folien aus Dirk123's Link geht. Puuuaaa!
Aber zum Glück kann man mare_crisium's pdf gut folgen. Auch die Bemerkungen von Besserwessi kann ich noch lesen. Allerdings kommt mir der Vorschlag mit dem "statt 1/(Xn+1-Xm)^2 einfach 1/((Xn+1- Xm)^2 + const.)" etwas komisch vor. Zumindest erkenne ich da keine Lösung zum Problem der "Division durch 0" da ja der Divisor immer noch 0 werden kann. (Aber wahrscheinlich geht es Besserwessi da nicht um die Division. Mein Mathewissen ist leider heftigst begrenzt.)

Frohes filtern wünscht
Sternthaler

[mare_crisium]

Buona sera, Sternthaler,

freut mich aber, dass Du Dich noch für Mathe interessierst :-) ! Ich habe natürlich noch mit meinen Formeln weitergespielt. Das Ergebnis ist aber nicht 100%ig befriedigend. Aber vielleicht kan der eine oder andere doch was damit anfangen.

Ciao,

mare_cirisum

Edit1: Anhang gelöscht wg. Upload-Quota

[Besserwessi]

@Sterntahler:
Das Problem mit der Division durch 0 hat man durch die zusätzliche Konstante im Nenner schon erledigt. Der Teil vor der Konstante ist als Quarat nie negativ. Mit einer Positiven Konstante hat man also immer etwas das drößer ist als die Konstante und damit auch eine obere grnze für das Gewicht der Messwerte. Der Vergleich mit den sonst üblichen Verfahren zeigt eher das die Konstante ruhig relativ groß sein kann, denn ohne ausreißer ist es ideal, wenn alle Werte gleich stark gewichtet werden.

@mare_cirisum:
Ich befürchte die Ideen zur schätzung der Genauigkeit der einzelnen Messwerte haben eine Problem. Die Abweichung eines einzelen Messwertes vom vorherigen Mittel lassen kaum auf die Genauigkeit dieses einzelenen Wertes schließen. Wenn man z.B. Normalverteilte Werte bekommt, ist der Ideale Schätzer einfach ein mittelwert mit konstanten Gewichten. Alles andere wird nur schlechter.

Das wird nur anders, wenn man eine andere Verteilung hat. Der Fall der gelegentlich vorkommt, sind Fehlerquellen, die nur selten auftreten aber einen großen Einfluß haben. Dann sind Werte weit weg häufiger als bei der Normalverteilung und sollte irgendwie unterdrückt oder abgeschwächt werden. Bei den Werten dicht am Mittelwert hat man keine Chance die von normalen Werten irgendwie zu unterscheiden, und sollte sie also alle gleich behandeln.

Dazu gibt es schon einige gut entwickelte und anerkannte Formeln unter dem Begriff "robuste Schätzer".

[Sternthaler]

Guten Morgen mare_crisium,

klar interessiere ich mich noch für Mathe. Macht mir immer wieder Spaß über Dinge zu reden von denen ich keine Ahnung habe. OK, ich weiss ganz genau worauf du hinaus willst, ich komme aber nicht in die Pötte :-(.


Hallo Besserwessi,

danke für den Tritt in den Hintern. Oh man, oh man. Das ist mal wieder typisch für mich, dass solche Lapalien von mir übersehen werden.


Und da kommen sie schon wieder die Fragen zu übersehenen Dingen:

Im deinem PDF mare_crisium, führst du oben in der Ableitung an:
"Die Streuung der Messwerte wird dabei mit dem Kehrwehrt des Genauigkeitsmasses abgeschätzt"
Wenn aber der dritte Algorithmus das Genauigkeitsmass immer reduziert (bis auf (Xn - X[mittel]n-1)=0 ), dann bedeutet dies ja automatisch, dass die Streuung immer größer wird.
Pendeln meine Messwerte nun (zufälligerweise) immer konstant um den Mittelwert, dann ist die Streuung konstant, aber das Genauigkeitsmass wird immer weiter reduziert. (Bitte sagt mir was ich mal wieder nicht gelesen habe!)

Frage: Entspricht deine eigene Erklärung zu dem "... Das stimmt aber nicht: ..." und auch der Einwand von Besserwessi meiner Überlegung?
Wenn ja, gibt es dann trotzdem einen Grund diesen Ansatz zu nutzen?
Z.B. Vorteile oder ein bestimmter Nutzen bei großem k? Oder bei Messwerten, die eben nicht zufällig konstant pendeln wie in meiner Annahme?

Und noch eine Frage: Wo ist Algorithmus 2?
Kann ich nun zumindest besser zählen als du, oder habe ich auch das schon wieder übersehen ;-)?

Gruß Sternthaler
P.S.: Jagt meine Mathe-Beiträge lieber durch ne'n Kalman-Filter. Könnte zwar sein, dass dann nur noch OT rauskommt, aber zumindest wird das Genauigkeitsmass dieses Threads dann nicht mehr reduziert.

[mare_crisium]

@Sternthaler,

tja, der zweite Algorithmus gefiel mir nicht und hab' ihn zur Strafe gelöscht. Dabei habe ich leider vergessen, die Nummerierung nachzuhalten. Pecunia astrale, pecavi!!

Im Grunde ist das Ergebnis meiner Rechnerei, dass sich der Aufwand nicht lohnt. Es reicht völlig aus, einfach die Formel

neuer_Mittelwert = (1-s)*alter_Mittelwert + s*neuer_Messwert

einem angepassten Wert von s grööser als 0 und kleiner als 1 zu verwenden (siehe Code-Schnipsel von Dirk123, im Posting vom 11.10.2009).

@Besserwessi,

habe angefangen, mich auch mit den robusten Schätzalgorithmen zu beschäftigen. Dauert aber noch ein Weilchen ;-).

Ciao,

mare_crisium

[goara]

hui interessant, da war ich auch neulich mal dran... immer diese drohenbastler mit ihren kalmans ^^
hab grad keine zeit, aber werde mal demnext meine erkenntnisse beifügen...