Implementierung FIR in C

[Walter T. (nicolas)]

Hallo zusammen,

ich habe ein FIR-System implementiert (Cortex M4F), das die Ableitung 
einer Zahlenreihe aus 64-Bit-Integer bilden soll. Quick & Dirty (siehe 
untenstehender Quelltext) funktioniert das auch.

Allerdings habe ich das Gefühl, dass es auch in C "schöner" geht, als 
z.B. die Koeffizienten bei jedem Aufruf neu zu berechnen.

Da die Ordnung N auf jeden Fall recht klein bleiben wird, könnte ich die 
lookup-table für die Koeffizienten auch explizit hinschreiben und per 
switch-case auswählen. Oder in der Status-Variablen hinterlegen. Oder 
die Schleife komplett ausschreiben und die Filterordnung per switch-case 
auswählen. Ich könnte mir das Umspeichern bei jedem Aufruf irgendwie 
sparen. Oder.

Wie macht man soetwas in C "richtig" und "schön" ?

#define DERIVATIVE_N_VALUES 5

typedef struct
{
    int64_t lastValues[DERIVATIVE_N_VALUES];
}
Diff64state_t;


/* Differenzierer fuer grosse Zahlen
 * Steigung der Ausgleichsgerade durch die Zahlenreihe u(z), u(z^-1), .... u(z^-n) */
float differentiate64(int64_t u, Diff64state_t *State)
{
    assert( State != NULL );

    // Letzte n Werte speichern, um die Ableitung zu bilden
    memmove( &(State->lastValues[1]), &(State->lastValues[0]), (DERIVATIVE_N_VALUES-1)*sizeof(int64_t));
    State->lastValues[0] = u;


    // FIR-Koeffizienten-Array bestuecken (erste Haelfte)
    // Das Koeffizienten-Array ist antisymmetrisch, deswegen wird nur ueber die Haelfte iteriert
    int n = DERIVATIVE_N_VALUES;
    float b[n];
    float c = 6.f/((float) ( n*(n*n-1) ) );
    for( int i = 0; i<n/2; i++ )
    {
        b[i] = c * ((float) (2*i - n + 1) );
    }


    // FIR
    // Die paarweise Differenz der Eingangswerte verhindert einen Ueberlauf, da fuer alle n
    // aufeinanderfolgende Werte sicher gilt: max(u(z^i)) - min(u(z^i)) < 2^16
    float d = 0.f;
    int64_t *v = State->lastValues;
    int64_t *w = State->lastValues + (DERIVATIVE_N_VALUES -1);
    for( int i = 0; i<n/2; i++ )
    {
        int32_t diff = *w-- - *v++;
        d += b[i] * ( (float) diff );
    }

    return d;
}

[Nop (Gast)]

Also das memcpy mit den vergangenen Werten kann man sich sparen, wenn 
man einen Ringbuffer nutzt.

Und die Werte für den Filter kann man in eine dedizierte Init-Funktion 
verschieben, wenn sie sich zwischen den Filter-Aufrufen normalerweise 
nicht ändern.

Man kann dann z.B. eine eigene Struktur haben für Ringbuffer und Filter, 
die man an die Filterfunktion als Zeiger übergibt.

[c-hater (Gast)]

Nop schrieb:

> Also das memcpy mit den vergangenen Werten kann man sich sparen, wenn
> man einen Ringbuffer nutzt.

Das ist nicht notwendigerweise effizienter. Hängt sehr stark von der 
Zielarchitektur ab, aber auch davon, wie großzügig man mit dem RAM 
umgehen kann. Und natürlich davon, wie groß die History des Filters sein 
muss.

Tendenziell wird der Ringpuffer umso interessanter, ja umfangreicher die 
History ist. Bei FIR (mit im Vergleich zu IIR tendenziell 
umfangreicherer History) dürfte aber wohl tatsächlich der Ringpuffer 
i.d.R. das Mittel der Wahl sein.

[Nop (Gast)]

c-hater schrieb:

> Das ist nicht notwendigerweise effizienter.

Bei einem Ringbuffer hat man natürlich den wrap-around, spart sich dafür 
aber eine Kopierschleife in selber Länge. Solange man als Buffergröße 
eine Zweierpotenz nimmt, ist der wrap-around lediglich ein &, was nur 
eine Instruktion ist.