Durchschnitt dynamisch berechnen

[Magnus (Gast)]

Hallo,
ich möchte die die Anzahl von Impulsen/Minute dynamisch bestimmen.
Ich habe einen Impulsgeber der Werte zwischen 0 und 120 Impulse pro 
Minute ausgibt (Durchschnitt bei etwa 60).
Für den Durchschnittswert möchte ich jede Sekunde auslesen können, 
wieviele Impulse in den letzten 60 Sekunden aufgezeichnet wurden. Ich 
hätte dies, mit einem Stack gelöst, der die millis() der Impulse 
speichert, sowie seine Größe. Immer bei einer Abfrage würden dann alle 
Elemente, die älter als 60 Sekunden sind gelöscht und die große 
zurückgeben.

Leider habe ich keine Erfahrung mit ADT auf Mikrocontrollern, sowie mit 
OOP auf Mikrocontrollern

[Magnus (Gast)]

Ich meinte natürlich Solange statt Stack

[sid (Gast)]

Das geht nur wenn Du wirklich 60 verschiedene Werte speicherst,
sonst weisst Du nach n paar sekunden nichtmehr was zu löschen wäre..

wenn Du sicher bsit, dass kein Aktueller Wert grösser sein kann als 127.
DANN (und nur dann) kannst Du mit nur 4bit pro Wert auskommen,
also 30byte 240bit

bei jedem speichervorgang überschreibst du schlicht die folgenden 4 bit 
mit deinem gelesenen Wert (mod 240 quasi wie ein endlos magnet band)
und merkst Dir nur die position.
(bei 240bit reicht dann ein byte [255] für die zeigerposition)

Dann machst Du eine volle rotation (liest 60 mal 4bit)
und errechnest den Durchschnitt

und sobald ein neuer Wert eintrudelt, überschreibst Du die nächsten vier 
bit,
der Zeiger rückt um vier vor (immer mod 240 natürlich)
usw usf

[Walter K. (walter_k488)]

Magnus schrieb:
> sowie mit
> OOP auf Mikrocontrollern

was willst du mit OOP?

[Dergute W. (derguteweka)]

Moin,

Da wuerd' ich einfach eine Datenbank in der Cloud dazu hernehmen. Und in 
Java ein paar Front/Back/Obendrueber- und von 
HintendurchdieBrustinsAuge-Ends schreiben.

Duck&Wech
WK

[A. S. (Gast)]

Der naive Ansatz: Array von 60 Zahlen, element 0 kommt jede Sekunde der 
aktuelle Wert rein, und davor wird Elemente 58 nach 59 verschoben, 57 
nach 58, ... 0 nach 1.

Danach alle 60 aufsummieren.

Zweite Verbesserung: memmove.

Dritte Verbesserung: ringbuffer

Vierte: nicht immer neu aufsummieren, sondern neuen wert zum 
Summenzähler addieren, ältesten subtrahieren.

Und dann, ... ja dann stellst Du fest, dass so ein Mittelwert meist 
wenig hilfreich ist.

[foobar (Gast)]

volatile uint8_t pulses;

void
pulse_irq() // interrupt context
{
    pulses++;
}

static uint8_t
get_pulses() // get number of pulses since last call
{
    // Instead of resetting pulses (needs atomic read-and-clear)
    // remember the last value and take the difference to now.
    static uint8_t last;

    uint8_t x = pulses;
    x -= last;
    last += x;
    return x;
}

static uint8_t
get_pulse_avg() // returns pulse average over last 60 calls
{
    static uint8_t history[60];
    static uint8_t pos;
    static uint16_t avg;

    uint8_t x = get_pulses();

    avg -= history[pos];
    avg += x;
    histoy[pos++] = x;
    if (pos == 60)
        pos = 0;

    return avg / 60;
}

void
every_second()
{
    printf("pulse average: %d\n", get_pulse_avg());
}

[Weg mit dem Troll ! Aber subito (Gast)]

Vergiss den Murks. Dafuer verwendet man einen tiefpass. Wie zB 
beschrieben unter : https://www.ibrtses.com/embedded/exponential.html 
Dabei nimmt der Anteil des aktuellen Wertes am Mittelwert mit der Zeit 
exponentiell ab.

[foobar (Gast)]

Der gleitende Mittelwert über 60s ist halt ein extremer (FIR-)Tiefpass, 
der nur langfristige Änderungen durchlässt.  Mit einem exponentiellen 
(IIR-)Tiefpass wie unter werden eher die Flanken "runder".  Was man 
braucht ist Anwendungssache.

Zum Vergleichen/Rumexperimentieren:

volatile uint8_t pulses;

void
pulse_irq() // interrupt context
{
    pulses++;
}

static uint8_t
get_pulses() // get number of pulses since last call
{
    // Instead of resetting pulses (needs atomic read-and-clear)
    // remember last value and take the difference to now
    static uint8_t last;

    uint8_t x = pulses;
    x -= last;
    last += x;
    return x;
}

static uint8_t
avg_60(uint8_t x) // returns average of x over last 60 calls
{
    static uint8_t history[60];
    static uint8_t pos;
    static uint16_t avg;

    avg -= history[pos];
    avg += x;
    history[pos++] = x;
    if (pos == 60)
        pos = 0;
    return avg / 60;
}

static uint8_t
avg_exp(uint8_t x) // returns exponential average of x
{
    static int avg;

    avg += ((int)x * 4 - avg + 1) / 2;
    return avg / 4;
}

void
every_second()
{
    uint8_t p = get_pulses();

    printf("pulses: %d, 60s-average: %d, exp-average: %d\n", p, avg_60(p), avg_exp(p));
}

// test
int
main(int argc, char **argv)
{
    int x = 0;

    for (int i=0; i < 70; ++i)
    {
        pulses += 50 + 50*sin(x++ * .2);
        //pulses += 50 + 3*(x++%8 < 2);
        every_second();
     }

     return 0;
}