Sensordatenauswertung mit Atmega328

[Michael (Gast)]

Hallo,

ich bin auf der Suche nach einer Möglichkeit, aus einer Datenreihe von 
Sensorwerten herauszufinden, wann sich das Signal auf einen stabilen 
Wert einpendelt.
Konkret speichere ich aus einen Sensor Daten, von denen ich weiß, dass 
ca. die ersten 10 Werte nicht zu gebrauchen sind, weil an der Stelle die 
Werte exponentiell absteigen, dann sich aber nach einer bestimmten Zeit 
einpedendeln.
Für die Auswertung entscheidend ist aber, wann genau sie sich 
eingependelt haben. Leider ist der Zeitpunkt, also die Stelle im Array 
auch nicht immer reproduzierbar, wann sich der Wert eingeschwungen hat.

Wie geht man dann bei so etwas vor, wenn man die Datenreihe direkt im 
Atmega auswerten will und als Ergebnis den eingependelten Wert und den 
Zeitpunkt, nachdem er sich eingependelt hat, haben will.

Danke schon mal und viele Grüße
Michael

[Holger (Gast)]

Moin, nimm doch den Semiquartilsabstand. Ein Minimum musst Du halt 
festlegen.

Holger

[Michael (Gast)]

Gibt es hier vielleicht ein einfaches Verfahren, mit dem ich quasi die 
Abweichung des aktuellen Wertes mit den Nachbarwerten vergleiche, und 
falls dieser ausreichend niedrig ist, wüsste ich, dass der Wert kontant 
ist.

Gibt es dazu vielleicht schon ein standard Verfahren?

[Michael (Gast)]

Holger schrieb:
> Moin, nimm doch den Semiquartilsabstand. Ein Minimum musst Du halt
> festlegen.

Aber dadurch habe ich ja nur einen von ausschlägen befreiten Mittelwert, 
oder?

Die Werte sehen in etwa so aus:
[20],[10],[6],[4],[2],[2],[2].

Können aber auch so aussehen:
[15],[20],[6],[4],[3],[2],[2].

Im Array kann sich leider die Position des eingepednelten Wertes ändern.
Und leider ist er nicht immer bei 2.
Sicher ist nur, dass sich der Wert irgendwann stabilisiert und ich 
müsste eigentlich nur wissen wann, also an welcher Stelle des Arrays das 
passiert.

[Stefan F. (Gast)]

Michael schrieb:
> Sicher ist nur, dass sich der Wert irgendwann stabilisiert

Na definiere eine passende Bedingung, die programmierbar ist. Zum 
Beispiel: Von drei aufeianderfolgenden Werten ist die Differenz zwischen 
dem minimalen und dem maximalen Wert kleiner als 2.

[Michael (Gast)]

Stefan ⛄ F. schrieb:
> Na definiere eine passende Bedingung, die programmierbar ist. Zum
> Beispiel: Von drei aufeianderfolgenden Werten ist die Differenz zwischen
> dem minimalen und dem maximalen Wert kleiner als 2.

Ja klar, wenn es da keine andere Möglichkeit gibt, muss ich es so 
machen, aber ich dachte, dass es vielleicht einen Algorithmus gibt, den 
man da anwenden kann.

[Kevin M. (arduinolover)]

Michael schrieb:
> Gibt es hier vielleicht ein einfaches Verfahren, mit dem ich quasi die
> Abweichung des aktuellen Wertes mit den Nachbarwerten vergleiche,

Ja nennt sich Ableitung. Der Differenzenquotient ist nicht wirklich 
schwer zu implementieren.

[Wolfgang (Gast)]

Michael schrieb:
> Ja klar, wenn es da keine andere Möglichkeit gibt, muss ich es so
> machen, aber ich dachte, dass es vielleicht einen Algorithmus gibt, den
> man da anwenden kann.

Die Änderungsrate eines Signals erfährst du Differenzieren und festlegen 
eines Schwellwertes, ab der du die Änderung als ausreichend klein 
betrachtest. Das Differenzieren in Abtastsystemen ist die 
Differenzbildung aufeinander folgender Messwerte, wie von Stean F. 
beschrieben.

Das IST der Algorithmus

[Michael (Gast)]

Wolfgang schrieb:
> Die Änderungsrate eines Signals erfährst du Differenzieren und festlegen
> eines Schwellwertes, ab der du die Änderung als ausreichend klein
> betrachtest. Das Differenzieren in Abtastsystemen ist die
> Differenzbildung aufeinander folgender Messwerte, wie von Stean F.
> beschrieben.

Achso, ich glaube, ich hab's verstanden.
Ich nehm die Einzelwerte (y) und die Zeitkonstante (x) und wenn das 
Ergebnis
unter einen Schwellwert liegt, dann bleibt der Wert konstant.
(yi−yi+1) / (xi−xi+1)

So habt ihr es gemeint, oder?

[Stefan F. (Gast)]

Michael schrieb:
> (yi−yi+1) / (xi−xi+1)

Ich bin jetzt keine Mathe Genie, aber meinen Vorschlag erkenne ich darin 
nicht wieder. Für meinen Vorschlag musst du eine Schleife Programmieren, 
die von jeweils 3 Messwerten den höchten mit dem niedrigsten vergleicht.

Ich dachte dabei an so etwas:

int main()
{
    // Anzahl der Messwerte
    #define WERTE 10
    int messwerte[WERTE];
    
    // hier Messwerte erfassen
    
    // Anzahl der zu untersuchenden Messwerte
    #define ANZAHL 3
    
    // Maximale Differenz innerhab der untersuchten Messwerte
    #define SCHWELLWERT 2
    
    for (int i=ANZAHL; i<WERTE; i++)
    {
        int min=messwerte[i];
        int max=messwerte[i];
        for (int j=1; j<ANZAHL; j++)
        {
            if (messwerte[i-j]<min)
            {
                min=messwerte[i-j];
            }
            if (messwerte[i-j]>max)
            {
                max=messwerte[i-j];
            }
        }
        if (max-min <= SCHWELLWERT)
        {
            // Stabilen Punkt ab Index i gefunden
        }
    }
}

[Michael (Gast)]

Stefan ⛄ F. schrieb:
> Ich bin jetzt keine Mathe Genie, aber meinen Vorschlag erkenne ich darin
> nicht wieder. Für meinen Vorschlag musst du eine Schleife Programmieren,
> die von jeweils 3 Messwerten den höchten mit dem niedrigsten vergleicht.

Woher weiß denn der µC, welcher Wert der höchste oder niedrigste ist?

[Michael (Gast)]

Sorry, hab den Code in deiner Antwort übersehen.

[Stefan F. (Gast)]

Michael schrieb:
> Woher weiß denn der µC, welcher Wert der höchste oder niedrigste ist?

Programmieren. Siehe meinen Vorschlag den ich gerade eingefügt habe. Da 
ist aber eine Zeile falsch, es muss heissen:

> for (int i=ANZAHL-1; i<WERTE; i++)

[Erwin D. (Gast)]

Michael schrieb:
> Stefan ⛄ F. schrieb:
>> Ich bin jetzt keine Mathe Genie, aber meinen Vorschlag erkenne ich darin
>> nicht wieder. Für meinen Vorschlag musst du eine Schleife Programmieren,
>> die von jeweils 3 Messwerten den höchten mit dem niedrigsten vergleicht.
>
> Woher weiß denn der µC, welcher Wert der höchste oder niedrigste ist?

Er weiß es nicht von alleine, deshalb sollst du ja das Programm so 
schreiben, wie es Stefan empfohlen hat.

[Felipe A. (felipea)]

Tach,

ich würde es ebenfalls mit der Ableitung angehen bzw. mit dem Delta - 
beides möglich. Dazu die Werte und Zeitpunkte entsprechend in Arrays 
ablegen.

Wenn man nun feststellt, dass das Delta bzw. die Steigung stagniert, 
gibt man den Zeitpunkt und Messwert aus. Nun will man aber ja wissen, 
wann der Zustand erreicht wurde. Dazu kann man ja rückwirkend auf die 
Daten schauen. Entweder, indem du dafür ebenfalls eine Auswertung 
schreibst oder dir die Daten ges. ausgeben lässt und diese selbst 
schnell identifizierst.