Sensordatenauswertung mit Atmega328

Gast #6642764
Lesenswert?

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
Gast #6642767
Lesenswert?

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?
Gast #6642771
Lesenswert?

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.
Gast #6642826
Lesenswert?

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.
Gast #6642861
Lesenswert?

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
Gast #6642878
Lesenswert?

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?
Gast #6642881
Lesenswert?

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:
1
int main()
2
{
3
    // Anzahl der Messwerte
4
    #define WERTE 10
5
    int messwerte[WERTE];
6
    
7
    // hier Messwerte erfassen
8
    
9
    // Anzahl der zu untersuchenden Messwerte
10
    #define ANZAHL 3
11
    
12
    // Maximale Differenz innerhab der untersuchten Messwerte
13
    #define SCHWELLWERT 2
14
    
15
    for (int i=ANZAHL; i<WERTE; i++)
16
    {
17
        int min=messwerte[i];
18
        int max=messwerte[i];
19
        for (int j=1; j<ANZAHL; j++)
20
        {
21
            if (messwerte[i-j]<min)
22
            {
23
                min=messwerte[i-j];
24
            }
25
            if (messwerte[i-j]>max)
26
            {
27
                max=messwerte[i-j];
28
            }
29
        }
30
        if (max-min <= SCHWELLWERT)
31
        {
32
            // Stabilen Punkt ab Index i gefunden
33
        }
34
    }
35
}
Gast #6642892
Lesenswert?

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?
Gast #6642898
Lesenswert?

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.
#6642906
Lesenswert?

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.

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren