RN-Wissen.de - Benutzerbeiträge [de]

Diskussion:TWI Slave mit avr-gcc

2012-08-08T09:58:30Z

RedBaron:

Hallo Uwe,

als mein Master mit Deinem Slave reden wollte, hängte sich der wegen nen Programmierfehler meines Masters auf. Die SCL-Leitung hat er dadurch einfach nicht mehr losgelassen. Durch ändern der Zeile

//switched to the non adressed slave mode...
#define TWCR_RESET TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(0<<TWSTO)|(0<<TWWC);

nach

//switched to the non adressed slave mode...
#define TWCR_RESET TWCR = (1<<TWEN)|(1<<TWIE)|(1<<TWINT)|(1<<TWEA)|(0<<TWSTA)|(1<<TWSTO)|(0<<TWWC);

war alles in Butter.

Gruß Frank

:: Ok, habe es jetzt korrigiert, aber noch nicht selbst getestet... Solle laut Datenblatt aber korrekt sein. mfg --[[Benutzer:Uwegw|uwegw]] 11:47, 12. Apr 2010 (CEST)

== Kelinigkeiten ==

Hallo,

ich habe den Code für ein Projekt vor 2 Jahren benutzt, jetzt habe ich nach dem Code gesucht um ein Update zu machen.

Die Oben genannten Probleme hatte ich damals auch - jetzt beim ersetzen des Moduls fällt mir folgendes auf:

- I2C_reg_Schreibschutz ist nicht definiert und kommt im Code auch nur einmal vor. Ich denke mal, dass es dafür sorgen soll, dass richtig adressiert worden ist, oder?

I2C_reg_Schreibschutz in twislave.h definieren ich denke das war als array gedacht?
I2C_reg_Schreibschutz sollte in der ini routine initialisiert werden... - dabei kann man gleich den Speicherbereich vorbeschreiben.
: Das war tatsächlich als Array gedacht, über das man den Schreibzugriff auf bestimmte Register sperren konnte. Wenn ich es mir recht überlege, ist diese Funktion recht überflüssig. Ich habe sie also erst mal entfernt. --[[Benutzer:Uwegw|uwegw]] 16:39, 2. Jul 2010 (CEST)

Ich würde auch die Interrupt aktivierung nicht in der Ini routine machen, sondern lieber ausserhalb, denn normalerweise müssen ja noch andere Sachen vorbereitet werden.

Mein Vorschlag für die Ini routine:

void init_twi_slave(uint8_t adr)
{
uint8_t i=0;<nowiki>
TWAR= adr; //Adresse setzen
TWCR &= ~(1<<TWSTA)|(1<<TWSTO);
TWCR|= (1<<TWEA) | (1<<TWEN)|(1<<TWIE);
buffer_adr=0xFF;
for(i=0;i<i2c_buffer_size;i++)
{
i2cdata[i]=0;
I2C_reg_Schreibschutz[i]=0;
}
}

Warum definierst Du i2cdata zweimal? Einmal im header reicht ....

Ansonsten vielen Dank, das ist sehr hilfreich...

Christian</nowiki>

Hallo Uwe,

ich setze mich gerade mit deinem Code in "twislave" auseinander. Ich habe folgende Anmerkungen:

Der Puffer wird mit "volatile uint8_t i2cdata[i2c_buffer_size+1];" deklariert. Warum das "+1" bei der Größe? Du fragst überall die Puffergrenze mit "...<i2c_buffer_size" ab. Damit würde "i2cdata[i2c_buffer_size]" nie angefasst werden.

Der Puffer wird sowohl in der .h- als auch in der .c-Datei deklariert. Die Deklaration in der .h-Datei wäre ausreichend.

'''init_twi_slave:'''

Hier steht "TWCR &= ~(1<<TWSTA) | (1<<TWSTO);". Durch ~(1<<TWSTA) sind bereits alle Bits bis auf TWSTA auf 1, also auch TWSTO. "| (1<<TWSTO)" wäre also unnötig. Meinst du etwas anderes?

Danach folgt "TWCR |= (1<<TWEA) | (1<<TWEN) | (1<<TWIE);". Diese Bits wurden bereits in der vorhergehenden Anweisung gesetzt. Diese Zeile müsste überflüssig sein.

sei() in der Initialisierungsroutine ist nicht gut! Wenn mehrere Hardwarekomponenten zu initialisieren sind (z.B. USART), kann es sein, dass diese bereits im unitialisierten Zustand oder bei der Initialisierung Interrupts auslösen. sei() gehört auf jeden Fall ins Hauptprogramm. Ggf. wäre eine Kommentarzeile mit dem Hinweis auf sei() angemessen.

'''ISR:'''
...
{ buffer_adr = 0; //Adresse auf Null setzen. Ist das sinnvoll? TO DO!
...

Ich denke, dass ist nicht sinnvoll. Besser ist es, buffer_adr auf 0xFF stehen zu lassen. Das setzen auf 0 bedeutet, dass bei einer offensichtlich fehlerhaften Ansteuerung ggf. gültiger Speicherbereich überschrieben würde. Das sollte nicht sein.

Die folgende Codefolge taucht in ähnlicher Form mehrfach auf:
{ if(buffer_adr < i2c_buffer_size)
{ i2cdata[buffer_adr] = data; //Daten in Puffer schreiben
}
buffer_adr++; //Buffer-Adresse weiter zählen für nächsten Schreibzugriff
...

Das bedingungslose Hochzählen des Pufferindex bedeutet, dass er bei genügend langen Übertragungssequenzen zunächst zu 0xFF (also ungültig) wird und dann zu 0x00 überläuft und wieder in gültige Indexbereiche kommt. Die Sequenz muss noch nicht einmal sehr lang sein, da man den Index durch die Addressierung kurz vor das Ende des Puffers positionieren kann. Besser wäre

{ if(buffer_adr < i2c_buffer_size)
{ i2cdata[buffer_adr++] = data; //Daten in Puffer schreiben
}
...

Eigentlich müsste man auch noch berücksichtigen, dass wenn der Index 254 errreicht wurde, weder weiter hochgezählt werden darf (würde zu 0xFF führen) noch ein weiteres Mal Daten gespeichert werden dürfen. Einfacher ist es, man begrenzt die max. Puffergröße auf 253 Byte.

case TW_ST_DATA_ACK: //0xB8 Slave Transmitter, Daten wurden angefordert
if (buffer_adr == 0xFF) //zuvor keine Leseadresse angegeben!
{ buffer_adr = 0;
}

Auch hier: Offensichtlich ein Fehlerzustand, der zu gültigen Daten führt. Wenn man diesen Fehler macht, sucht man ziemlich lange nach der Ursache. Kurz danach wird auf Datenanforderung außerhalb des Pufferbereichs mit dem Senden von 0x00 reagiert. Dies sollte man auch diesem Fehler machen. Anweisung also am besten streichen.

Apropos "lange suchen"... Ich bin schon etwas älter. Da könnte der Ausdruck "totsuchen" zur Realität werden :-)

Viele Grüße
RedBaron

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:58:13Z

RedBaron:

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.

<code>
 
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 
 
</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) 
<code>
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\>

</code>
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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:57:13Z

RedBaron:

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.

<code>
 
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 
 
</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) 
<code>
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) 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\>

</code>
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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:56:34Z

RedBaron:

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.

<code>

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

</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) 
<code>
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) 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\>

</code>
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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:55:53Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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) 
<code>
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) 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\>

</code>
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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:55:15Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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) 
<code>
a= 1/2: y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder y = (y + x) >> 1 (ist genauer)<br\>
a= 1/4: y = (y >> 2) * 3 + (x >> 2) y = ((y * 3) >> 2) + (x >> 2)
</code>

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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:54:35Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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\>
<code>
a= 1/2: y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder y = (y + x) >> 1 (ist genauer)<br\>
a= 1/4: y = (y >> 2) * 3 + (x >> 2) y = ((y * 3) >> 2) + (x >> 2)
<\code>

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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:53:54Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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\>
<c>
a= 1/2: y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder y = (y + x) >> 1 (ist genauer)<br\>
a= 1/4: y = (y >> 2) * 3 + (x >> 2) y = ((y * 3) >> 2) + (x >> 2)
<\c>

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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:53:07Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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\>
a= 1/2: y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder y = (y + x) >> 1 (ist genauer)<br\>
a= 1/4: y = (y >> 2) * 3 + (x >> 2) 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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:52:51Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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)
a= 1/2: y = (y >> 1) + (x >> 1) (vermeidet Überläufe) oder y = (y + x) >> 1 (ist genauer)<br\>
a= 1/4: y = (y >> 2) * 3 + (x >> 2) 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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:52:30Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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)
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) 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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:51:56Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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) 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) 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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:51:38Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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) 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) y = ((y * 3) >> 2) + (x >> 2)

a = 1/2
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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:51:06Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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) 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) y = ((y * 3) >> 2) + (x >> 2)

a = 1/2
t 0 1 2 3 4 5 6 7 8 9<br\>
x 0 0 50 50 50 50 50 50 40 50
y 0 0 25 37 43 46 48 49 45 47

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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:50:40Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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) 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) y = ((y * 3) >> 2) + (x >> 2)

a = 1/2
t 0 1 2 3 4 5 6 7 8 9
x 0 0 50 50 50 50 50 50 40 50
y 0 0 25 37 43 46 48 49 45 47

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.

Diskussion:Gleitender Mittelwert in C

2009-12-29T09:48:09Z

RedBaron:

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

y(t): neuer Schätzwert
y(t-1): alter Schätzwert
x: neuer Messwert
a: Gewicht im Bereich 0..1

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) 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) y = ((y * 3) >> 2) + (x >> 2)

a = 1/2
t x y
0 0 0
1 0 0
2 50 25
3 50 37
4 50 43
5 50 46
6 50 48
7 50 49
8 40 45
9 50 47

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.

Gleitender Mittelwert in C

2009-12-29T08:32:57Z

RedBaron: /* Weblinks */

Der gleitende Mittelwert, auch gleitender Durchschnitt genannt, wird verwendet, um zeitlich aufeinander folgende Reihen von Werten zu glätten; eben den Mittelwert über n aufeinader folgende Werte zu bilden.

{{Ausbauwunsch| viel mehr erklärender Text}}

== Verwendung ==
Um die Einwirkung von veränderlichen äußeren Einflüssen auf die Genauigkeit von Messungen zu reduzieren, wird häufig der Mittelwert über die letzten gemessenen Werte gebildet. Es ist dabei unerheblich, woher diese äußeren Einflüsse stammen, sei es z.B. aus Schwankungen der Versorgungsspannung oder hochfrequenten Störungen aus der Umgebung. Die Bildung eines gleitenden Mittelwertes hat jedoch wenig bis keinen Einfluß auf die Genauigkeit der Ergebnisse, wenn diese durch nahezu konstante äußere Einflüsse (wie z.B. das thermische Rauschen von Bauteilen) verfälscht werden.

Eine denkbare sinnvolle Anwendung: Ein Roboter ist mit einer größeren Solarzelle ausgerüstet und soll für diese die hellste Stelle in einer halbschattigen Umgebung (im Freien unter Laubbäumen) finden. Jede Positionsänderung kann eine gravierende Änderung der Zellenspannung bewirken.

== Beispiel ==
Hier ein Beispiel für die Auswirkungen auf eine Messung. Im Bild werden gestörte Messwerte in rot und die durch den gleitenden Mittelwert geglätteten Werte in grün dargestellt. Ein Nachteil bei der Glättung über viele Werte ist die langsame Reaktion auf Sprünge, wie am Anfang beim Sprung von 0 auf 50 zu sehen ist.

[[Bild:GleitenderMittelwert.png]]

== C-Code ==
Auf Optimierungen, inline-Funktionen etc. wurde vorerst zugunsten der Lesbarkeit verzichtet.
Für manche Anwendungen ist es Sinnvoll für den gleitenden Mittelwert einen anderen Datentyp als für die Einzelwerte vorzusehen. Z.B. kann der Mittelwert von ganzen Zahlen durchaus signifikante Nachkommastellen haben.

=== Header ===
;FloatingAverage.h

#ifndef FLOATING_AVERAGE_H
#define FLOATING_AVERAGE_H

#include <inttypes.h>

{{ccomment|Ueber wieviele Werte soll der gleitende Mittelwert berechnet werden?}}
{{ccomment|Zulaessige Werte 1..255}}
#define SIZE_OF_AVG 8

{{ccomment|Datentyp, ueber den der gleitende Mittelwert berechnet werden soll.}}
typedef uint16_t tFloatAvgType;
{{ccomment|typedef float tFloatAvgType;}}

{{ccomment|Wird nur intern fuer die Durchschnittsberechnung benutzt.}}
{{ccomment|Muss Zahlen fassen koennen, die SIZE_OF_AVG mal groesser als tFloatAvgType sind.}}
typedef uint32_t tTempSumType;
{{ccomment|typedef float tTempSumType;}}

{{ccomment|Die Struktur, in der die Daten zwischengespeichert werden}}
typedef struct
{
tFloatAvgType aData[SIZE_OF_AVG];
uint8_t IndexNextValue;
} tFloatAvgFilter;

{{ccomment|Initialisiert das Filter mit einem Startwert.}}
void InitFloatAvg(tFloatAvgFilter * io_pFloatAvgFilter,
tFloatAvgType i_DefaultValue);

{{ccomment|Schreibt einen neuen Wert in das Filter.}}
void AddToFloatAvg(tFloatAvgFilter * io_pFloatAvgFilter,
tFloatAvgType i_ui16NewValue);

{{ccomment|Berechnet den Durchschnitt aus den letzten SIZE_OF_AVG eingetragenen Werten.}}
tFloatAvgType GetOutputValue(tFloatAvgFilter * io_pFloatAvgFilter);

#endif

=== Quellcode ===
;FloatingAverage.c

#include "FloatingAverage.h"

void InitFloatAvg(tFloatAvgFilter * io_pFloatAvgFilter,
tFloatAvgType i_DefaultValue)
{
{{ccomment|Den Buffer mit dem Initialisierungswert fuellen:}}
for (uint8_t i = 0; i < SIZE_OF_AVG; ++i)
{
io_pFloatAvgFilter->aData[i] = i_DefaultValue;
}
{{ccomment|Der naechste Wert soll an den Anfang des Buffers geschrieben werden:}}
io_pFloatAvgFilter->IndexNextValue = 0;
}

void AddToFloatAvg(tFloatAvgFilter * io_pFloatAvgFilter,
tFloatAvgType i_NewValue)
{
{{ccomment|Neuen Wert an die dafuer vorgesehene Position im Buffer schreiben.}}
io_pFloatAvgFilter->aData[io_pFloatAvgFilter->IndexNextValue] =
i_NewValue;
{{ccomment|Der naechste Wert wird dann an die Position dahinter geschrieben.}}
io_pFloatAvgFilter->IndexNextValue++;
{{ccomment|Wenn man hinten angekommen ist, vorne wieder anfangen.}}
io_pFloatAvgFilter->IndexNextValue %= SIZE_OF_AVG;
}

tFloatAvgType GetOutputValue(tFloatAvgFilter * io_pFloatAvgFilter)
{
tTempSumType TempSum = 0;
{{ccomment|Durchschnitt berechnen}}
for (uint8_t i = 0; i < SIZE_OF_AVG; ++i)
{
TempSum += io_pFloatAvgFilter->aData[i];
}
{{ccomment|Der cast is OK, wenn tFloatAvgType und tTempSumType korrekt gewaehlt wurden.}}
tFloatAvgType o_Result = (tFloatAvgType) (TempSum / SIZE_OF_AVG);
return o_Result;
}

=== Anwendungsbeispiel ===
Hier folgt ein Beispiel, das die Anwendung in einem PC-Konsolen-Programm demonstriert

#include <stdio.h>
#include "FloatingAverage.h"

int main(void)
{
{{ccomment|Datenstruktur anlegen:}}
tFloatAvgFilter FilterVoltageBatt;

{{ccomment|initialisieren und mit 0 fuellen}}
InitFloatAvg(&FilterVoltageBatt, 0);

AddToFloatAvg(&FilterVoltageBatt, 100);
{{ccomment|jetzt steht 1 mal 100 und 7 mal 0 im Buffer:}}
printf("100/8 = %d\n", GetOutputValue(&FilterVoltageBatt));

AddToFloatAvg(&FilterVoltageBatt, 200);
{{ccomment|jetzt steht 1 mal 100, 1 mal 200 und 6 mal 0 im Buffer:}}
printf("300/8 = %d\n", GetOutputValue(&FilterVoltageBatt));

AddToFloatAvg(&FilterVoltageBatt, 300);
AddToFloatAvg(&FilterVoltageBatt, 200);
{{ccomment|jetzt steht 1 mal 100, 2 mal 200, 1 mal 300 und 4 mal 0 im Buffer:}}
printf("800/8 = %d\n", GetOutputValue(&FilterVoltageBatt));

return 0;
}

== Weblinks ==
* [http://de.wikipedia.org/wiki/Gleitender_Mittelwert Wikipedia - Gleitender Mittelwert]

[[Kategorie:Quellcode C]]