Ein einfacher Glitch-Filter

Dieser sehr einfache Filter dient zu Unterdrückung von stochastischen (zufälligen) Messfehlern. Er zeichnet sich durch geringe Anforderungen an die CPU (Speicherbedarf und Rechenzeit) aus. Als Nachteil ist eine Verzögerung des Messsignals und eine komplexe Filtergleichung zu erwähnen. Für eine exakte mathematische Berechenbarkeit sind eventuell andere digitale Filter besser geeignet.

Bei der Messung von physikalischen Signalen kann es zu stochastischen Fehlern kommen, welche einen Regelkreis massiv beeinflussen, oder einen Durchschnittswert stark verfälschen können. Die Ursache dieser Messfehler sind umfangreich – am häufigsten treten aber „Leitungsfehler“ (z.B. Kurzschluss gegen Masse einer Signalleitung) und „Bit-Fehler“ auf. Gemeinsam ist diesen Fehlern, dass eine starke kurze Signaländerung auftritt.

Das obige Bild zeigt so eine Störung: ein sehr steiler Anstieg auf einen hohen Messwert. Ein klassischer PID Regler wird darauf sicherlich empfindlich reagieren.

Eine Abhilfe ist es die nachfolgende Regelstrecke "stabil" gegen solche Fehler zu machen - dies verlangsamt den Regler aber deutlich.

Als eine weitere einfache Abhilfe kann das Signal mit Hilfe eines "gleitenden Mittelwert" behandelt werden – der Fehler wird dabei über die Mittelung „reduziert“. Das so gefilterte Signal eilt dem Original-Signal um die Anzahl der Filterwerte nach – es erhöht sich somit auch die Gruppenlaufzeit der Regelstrecke. Bei der Auslegung der Regelstrecke muss darauf Rücksicht genommen werden.

Aber auch mit dieser Maßnahme zeigt sich immer noch ein deutlich überhöhter Wert mit einem steilen Anstieg.

Eine Verbesserung kann erreicht werden, wenn die Werte, welche zur Mittelung herangezogen werden, vor der Mittelwertberechnung auf Minima und Maxima überprüft werden, welche dann nicht zur Berechnung des Mittelwertes herangezogen werden.

Das folgende Bild illustriert dies: die Kurve „Smart Average“ gibt den Kurvenverlauf der gewählten Methode wieder.

Der Einfluss der Störung wird hier sichtlich minimiert ohne eine weitere Verschlechterung der Gruppenlaufzeit zu erzielen. Auch typische „Doppelfehler“ welche durch das „Zurückschwingen“ des Signals entstehen, können gut ausgefiltert werden.

Wichtig für die Auslegung des besprochenen Filters ist das physikalische System zu kennen. Können nur positive „Ausreißer“ vorkommen? Wie lange ist eine typische Störung? Diese Angaben führen dazu wie viel „Maximum/Minimum“ Werte ausgefiltert werden und ob nur „positive“, „negative“ oder beide Werte gefiltert werden müssen.

Beispiel

Der folgende Beispielcode zeigt eine mögliche Implementierung dieses Filters.

/************************************************************************/
/* helper functions                                                     */
/************************************************************************/
void data_filter_find_int_min_max(int16_t *data_array, uint16_t array_size, uint16_t *min_position, uint16_t *max_position)
{
    int16_t min_val, max_val;
    uint16_t    i;
    uint16_t    min_pos, max_pos;

    min_val = INT16_MAX;
    max_val = INT16_MIN;
    min_pos = 0;
    max_pos = array_size -1;

    /* first run to determine the max/min values */
    for (i=0; i<array_size; i++) {
        if (data_array[i]>max_val) {
            max_val = data_array[i];
            max_pos = i;
            } else if (data_array[i]<min_val) {
            min_val = data_array[i];
            min_pos = i;
        }
    }

    *min_position = min_pos;
    *max_position = max_pos;
}

/************************************************************************/
/* Simple Min-Max removing averaging filter                             */
/************************************************************************/
int16_t data_filter_mima_array_int(int16_t *data_array, uint16_t array_size)
{
    int32_t sum;
    uint16_t    i, min_pos, max_pos;

    sum = 0;

    data_filter_find_int_min_max(data_array, array_size, &min_pos, &max_pos);

    for (i=0; i<array_size; i++) {
        if ((i!=max_pos) && (i!=min_pos))
        {
            sum += (int32_t)(data_array[i]);
        }
    }
    sum /= (array_size-2);

    return (int16_t) sum;
}

Weitere Informationen zu diesem Thema:

• TU Dresden, Peter-Wolfgang Gräber Kapitel 6 Messfehler - PDF
• Lücker, Grundlagen Digitaler Filter, Springer Verlag, 1985
• Kammeyer/ Kroschel, Digitale Signalverarbeitung, Springer/Teubner, 1998
• Ihringer, Diskrete Mathematik,Springer/Teubner, 1999

Bei Fragen, Anregungen oder Feedback freuen wir uns über Ihre Nachricht.