Gleitender Mittelwert Arduino

[TobiasE]

Hallo,

ich möchte mit dem Arduino den gleitenden Mittelwert einer Datenreihe mithilfe von einem Array ausrechnen.
Es sind ca. 6000 Werte, wobei immer der Durchschnitt der letzten 255 Werte berechnet werden soll.
Da ich mich mit Arrays nicht so auskenne, bräuchte ich auch den Code dazu.

Vielen Dank für eure Hilfe.

Grüße
TobiasE

[TobiasE]

So,
hab es jetzt n paar Stündchen probiert und bin auf folgendes gekommen:

int werte[254];
int i,j = 0;
int summe;

void setup() {
Serial.begin(9600);
}

void loop() {
werte[i] = analogRead(0);
i++;
if(i = 255) {
i = 0;
}
delay(100);
durchschnitt();
summe = 0;
j = 0;

}

void durchschnitt() {
while(j < 255) {
summe += werte[j];
j++;
}
Serial.println(summe / 255);
}

Es gibt aber falsche Werte aus, die unmöglich stimmen können.
Wo ist der Fehler?

thx

[Peter(TOO)]

Hallo,

int werte[254];

Hat 254 Plätze, es sollten aber 255 sein!
In werte[255] steht ein Zufallswert.
Also
int werte[255];

Angesprochen wird das Array dann mit werte[0] bis werte[254]

Beim ersten Aufruf von durchschnitt() steht in summe auch ein Zufallswert.

Tipp:

#define BUFFER_SIZE 255
int werte[BUFFER_SIZE];


for (j=0; j < BUFFER_SIZE; j++)
{
  // mach was
}

Variante:

int werte[255];
#define BUFFER_SIZE (sizeof(werte) / sizeof(werte[0]) )

// sizeof(werte) liefert den Speicherplatz für das ganze Array in Bytes
// sizeof(werte[0]) liefert den Speicherplatz für ein einzelnes Array-Element in Bytes

// Die Klammer um den ganzen Ausdruck ist prinzipiell nicht nötig, kann aber schwer zu findende Bugs verhindern.
// z.B.
// #define BUFFER_SIZE sizeof(werte) / sizeof(werte[0])
// ++BUFFER_SIZE
// würde der Compiler nach
// (sizeof(werte)+1) / sizeof(werte[0]) 
// auflösen und eben nicht nach
// (sizeof(werte) / sizeof(werte[0]))+1

Das passt dann immer, auch wenn du die Array-Grösse mal ändern willst

MfG Peter(TOO)

[Thie]

...und du solltest auf deine "summe" Obacht geben.
Die ist bei dir wohl vom Type int, somit kann die auf den normalen Arduinos nur rund 32000 groß werden.
Deine summe kann aber bis zu 1023 * 255 = 260865 groß werden!
Dann halt lieber unsigned long für die summe nehmen, dann hat das Platz!

[HaWe]

außer, sein Arduino hat einen ARM Prozessor (Zero, Due), dann hat int von vornherein die Größe 32-bit. 8-)

[Sisor]

Und noch ein Klassiker im Code:

if(i = 255) { i=0; }

Es ist wohl gemeint:

if(i == 255) ...

Dieser Fehler verursacht, dass i erstmal auf 255 gesetzt wird. Damit ist i ungleich null, somit der Ausdruck in der Klammer wahr, und der Code i=0 wird ausgeführt. i ist also nachher immer null.
Tipp:
Bei 256 Werten ein Byte als Typ benutzen. Wenn der Wert dann 255 ist und um eins erhöht wird, fängts automatisch wieder bei null an.

[TobiasE]

Erstmal vielen Dank für die Hilfe.
Das ist der fertige Code:

int werte[255];
int i,j = 0;
unsigned long summe;

void setup() {
Serial.begin(9600);
}

void loop() {
werte[i] = analogRead(0);
i++;
if(i == 255) {
i = 0;
}
delay(100);
durchschnitt();
}

void durchschnitt() {
summe = 0;
j = 0;
while(j < 255) {
summe += werte[j];
j++;
}
float schnitt = summe / 255;
Serial.println(schnitt);
}

Klappt alles wie es soll!
Nach 25,5 Sekunden wird dann der korrekte Mittelwert angezeigt.
Danke nochmal

TobiasE

[HaWe]

warum delay(100) ? wenn das so sein muss, ok!
aber sonst: analogRead braucht nur ca. 1ms zum auslesen, und dafür wartet es von alleine!


- HaWe

- - - Aktualisiert - - -

ps
ein "gleitender Durchschnitt" geht aber anders ... und schneller.... und ganz ohne Arrays...!

[Peter(TOO)]

Hallo,

ein "gleitender Durchschnitt" geht aber anders ... und schneller.... und ganz ohne Arrays...!

Ohne Array?
Ich habe das immer mit einem Ringbuffer gemacht.


Pseudo Code:
Summe -= ringbuffer[oldest];
Summe += new_data;

ringbuffer[oldest] = new_data;
ringbuffer_index++;


MfG Peter(TOO)

[HaWe]

ja, Ringpuffer ist natürlich perfekt und auch perfekt auf die Stichprobengröße angepasst.

Angenähert geht es aber auch mit dem gleitenden Mittelwert per Lowpass-Filter, damit bekommt man bis auf ein paar unerhebliche Nachkommastellen das gleiche Ergebnis:

float ETA=0.95; // ETA anfangs festlegen, ggf. noch justieren, kann auch bei 0.90 oder 0.99 liegen=> rumprobieren!
Mittelwert = ETA*(Messwert) + (1-ETA)*Mittelwert;

Dann spart man sich die extrem langsamen Array-Operationen und den Speicher dafür. Allerdings sind es dann nicht exakt 255 Werte, die gemittelt werden, sondern nur größenordnungsmäßig was in der Art.
Aber:
man kann ja auch die obige Formel benutzen, und dabei bis 255 zählen,
dann den Mittelwert ablesen,
und dann wieder neu starten.
Aber: er gleitet, mit minimalem Aufwand.