Domanda da praticone su filtri passa basso FIR a MM.

[TardoFreak]

Domanda per chi usa o ha usato le librerie DSP per i micro.
Suppongo che per i flitri IIR e IFR i fattori vengano passati alle funzioni mediante codifica Q1.15 (così mi è sembrato di capire leggendo la scarsa documentazione della ST) anche perché mi pare sia più o meno uno standard per i DSP.
La domanda è: anche nel caso dei campioni si usa (di solito) questa codifica normalizzando i segnali da -1 a +1 ?

[dimaios]

Lo scalamento è preferibile anche se non obbligatorio in tutti i contesti.
In passato invece quando si lavorava in virgola fissa era assolutamente un must.

[TardoFreak]

Le librerie DSP per l' STM32 accettano come parametri degli short integer e quindi è praticamente scontato che siano codificati Q1.15 anche perché l' esecuzione dura troppo poco.
A rigor di logica anche i campioni dovrebbero esserlo perché vengono moltiplicati per i fattori e quindi, per non mischiare carciofini sott' olio con marmitte catalitiche anche loro devono avere la stessa codifica.
Almeno penso, visto che più o meno tutto il mondo dei micro usa matematica a virgola fissa.

[dimaios]

Attenzione! L' STM34F4 è un floating point ovvero un Cortex M4 che prevede una Single precision floating point unit IEEE 754 compliant.
La libreria gestisce il calcolo in emulazione intera se non trova l'FPU sul micro altrimenti lo sfrutta aumentando notevolmente le performance.
Guarda questo per un confronto. Nel medesimo sito trovi molti spunti interessanti ed informazioni utili.
Posseggo una STM32F4-DISCOVERY sulla quale sto tentando di installare FreeRTOS e devo dire che come velocità di elaborazione è decisamente sorprendente.

[TardoFreak]

Hotrovato i sorgenti della libreria del STM32F1xx che riporto qui.

Codice: Seleziona tutto

/* for block FIR module */
typedef struct {
  uint16_t *h;
  uint32_t nh;
} COEFS;

/* IIR filter in C */
void iir_biquad_stm32(uint16_t *y, uint16_t *x, int16_t *IIRCoeff, uint16_t ny);

/**
  * @brief  Canonique Form of 8th order IIR filter, factorized in
  *   4 biquads sections in series.
  * @param y: Output array .
  * @param x: Input array
  * @param IIRCoeff: IIR Filter Coefficients, an array of 20 shorts
  * @param ny: the number of output samples
  * @retval : None
  */
void iir_biquad_stm32(uint16_t *y, uint16_t *x, int16_t *IIRCoeff, uint16_t ny)
{
  uint32_t i;
  uint32_t w1_2 = 0, w1_1 = 0, w1;
  uint32_t w2_2 = 0, w2_1 = 0, w2;
  uint32_t w3_2 = 0, w3_1 = 0, w3;
  uint32_t w4_2 = 0, w4_1 = 0, w4;

  /** Canonic form **/
  /* 1st section */
  for (i=0; i<ny-2; i++)
  {
    w1 = x[2+i] - IIRCoeff[0]*w1_1 - IIRCoeff[1]*w1_2;
    y[2+i] = (IIRCoeff[2]*w1 + IIRCoeff[3]*w1_1 + IIRCoeff[4]*w1_2);
    w1_2 = w1_1;
    w1_1 = w1;
  }

  /* 2nd section */
  for (i=0; i<ny-2; i++)
  {
    w2 = y[2+i] - IIRCoeff[5]*w2_1 - IIRCoeff[6]*w2_2;
    y[2+i] = (IIRCoeff[7]*w2 + IIRCoeff[8]*w2_1 + IIRCoeff[9]*w2_2);
    w2_2 = w2_1;
    w2_1 = w2;
  }

  /* 3rd section */
  for (i=0; i<ny-2; i++)
  {
    w3 = y[2+i] - IIRCoeff[10]*w3_1 - IIRCoeff[11]*w3_2;
    y[2+i] = (IIRCoeff[12]*w3 + IIRCoeff[13]*w3_1 + IIRCoeff[14]*w3_2);
    w3_2 = w3_1;
    w3_1 = w3;
  }

  /* 4th section */
  for (i=0; i<ny-2; i++)
  {
    w4 = y[2+i] - IIRCoeff[15]*w4_1 - IIRCoeff[16]*w4_2;
    y[2+i] = (IIRCoeff[17]*w4 + IIRCoeff[18]*w4_1 + IIRCoeff[19]*w4_2);
    w4_2 = w4_1;
    w4_1 = w4;
  }

}

Ehm ... mi sembra fin troppo facile come funzione, mi sarei aspettato qualcosa di più ...tosto.

Quello che non riesco a capire è la codifica dei coefficienti. Così, a naso, mi sembra una Q15 o qualcosa del genere anche perché coefficienti interi con short int non ce li vedo in un filtro IIR. Non penso che uno dei coefficienti possa valere, chessò, 5798 per esempio.

Qualcuno saprebbe spiegarmi, se ha tempo e voglia, come interpretare e capire come sono codificati e come vengono trattati i coefficienti?

[DirtyDeeds]

Non penso che uno dei coefficienti possa valere, chessò, 5798 per esempio.

Why not?

Quel filtro fa delle operazioni su interi, la scalatura è "a carico tuo".

[dimaios]

Prova a leggere questo thread sul sito della ST.
Per quanto riguarda il formato Q e' spiegato bene qui.

[TardoFreak]

Capito.
- Trasformo il coefficiente in formato Q15 moltiplicandolo per 2^15. Questo in fase di setup del filtro, non durante l' esecuzione).

- Dentro il filtro moltiplico il fattore (16 bit) per il campione (16 bit) ottenendo un risultato a 32 bit
- Divido il risultato per 2^15 (shift a destra di 15 posizioni)
- Aggiorno
- Vivo felice.