Código de filtro digital

[julian403]

Hola, he estado trabajando con filtros digital y me encontré con la buena ayuda del filter solution (hace poco me di cuenta que también sintetiza filtros digitales)

Como entrada tengo un array de 10 valores tipo float. El problema que como entrada para el filtro tengo 2 variabls tipo float (invar y *states). Entiendo que el array de 10 valores tiene que ser pasado a través del puntero *states pero ¿para qué es invar?

El filtro es pasabajo y el código es el siguiente:

float DigFil(invar, states)
float invar, *states;
/******************************************************************************/
/* Filter Solutions Version 2015                 Nuhertz Technologies, L.L.C. */
/*                                                            www.nuhertz.com */
/*                                                            +1 602-279-2448 */
/* 4th Order Low Pass Butterworth                                             */
/* Bilinear Transformation with Prewarping                                    */
/* Sample Frequency = 50.00 KHz                                               */
/* Standard Form                                                              */
/* Arithmetic Precision = 4 Digits                                            */
/*                                                                            */
/* Pass Band Frequency = 10.00 KHz                                            */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* Input Variable Definitions:                                                */
/* Inputs:                                                                    */
/*   invar    float       The input to the filter                             */
/*   *states  float       Pointer to array holding the filter states          */
/*                        (Minimum array dimension: 4)                        */
/*                                                                            */
/* Option Selections:                                                         */
/* Standard C;   Externally Initialized;   External States;   Optimized;      */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* This software is automatically generated by Filter Solutions               */
/* no restrictions from Nuhertz Technologies, L.L.C. regarding the use and    */
/* distributions of this software.                                            */
/*                                                                            */
/******************************************************************************/

{
    float sumnum=0.0, sumden=0.0;  int i=0;
    static float znum[3] = {
        4.658e-02,
        .1863,
        .2795
    };
    static float zden[4] = {
        3.012e-02,
        -.1827,
        .68,
        -.7821
    };
    sumnum = sumden = 0.0;
    for (i=0;i<4;i++){
        sumden += states[i]*zden[i];
        sumnum += states[i]*znum[i<3?i:4-i];
        if (i<3) states[i] = states[i+1];
    }
    states[3] = invar-sumden;
    sumnum += states[3]*znum[0];
    return sumnum;
}

 

[chclau]

invar es la entrada al filtro, states incluye informacion que determina como se comporta el filtro

 

[D@rkbytes]

Trabajar con filtros digitales sobre procesos de señal es algo muy común y generalizado.
Si lees la referencia que se hace sobre la variable "invar", dice lo siguiente:
/* invar float The input to the filter
O sea, una variable con punto flotante que es la entrada de datos para el filtro. (Contendrá los datos a procesar)
Por lo tanto, invar es una variable sobre la cual estarán basados los subsecuentes cálculos del filtro.

 

[julian403]

He implementado el código pero obtengo una salida bastante extraña, el valor que retorna la función crece con cada llamado.

private double DigFil(double invar)
{
    double sumnum, sumden;  int i=0;

    double [] znum = {0.0000002442, 0.000002442, 0.00001099, 0.0000293,0.00005127, 0.00006153 };
    double [] zden = { 0.03845, -0.508, 3.045, -10.91, 25.92, -42.64, 49.28, -39.55,21.12,-6.789 };

    sumnum = sumden = 0.0;
    for (i=0;i<10;i++){
        sumden += states[i]*zden[i];
        sumnum += states[i]*znum[i<6?i:10-i];
        if (i<9) states[i] = states[i+1];
    }
    states[9] = invar-sumden;
    sumnum += states[9]*znum[0];
    return sumnum;
}

Defino el vector states en el constructor de la clase, inicializandolo a con todos valorees nulos y la siguiente función se llama cada vez que el adc obtiene un cambio:

double functionADC{ 

float [] values = event.values; //Acá obtengo los valores del ADC
double valor;
valor = DigFil((double) values[0]);
this.tv1.setText("X = " + String.format("%.1f",(float)valor));
this.tv2.setText("X = "+String.format("%.1f",values[0]));

}

 

[D@rkbytes]

He implementado el código pero obtengo una salida bastante extraña, el valor que retorna la función crece con cada llamado.

Una variable que debe incrementarse dentro de una rutina, primero debe ponerse a cero.

 

[juanma2468]

Una variable que debe incrementarse dentro de una rutina, primero debe ponerse a cero.

A que variable te refieres? No veo cual seria la que hay que iniciar en cero?

 

[D@rkbytes]

states[] No se muestra la inicialización de vectores.
Y aquí se puede ir acumulando:
if (i<9) states = states[i+1];

 

[julian403]

No lo he mostrado pero a states lo inicié en cero en el constructor de la clase princial

float [] states = {0,0,0,0,0,0,0,0,0,0}

Pero como es un atributo de la clase, no se lo paso a la función. Con respecto a states solamente lo inicializo, veo que la función del filtro se encarga de modificarlo.

 

[D@rkbytes]

Por ser un arreglo global, es preferible ponerlo a cero dentro de la rutina.
Con un bucle for es sencillo.

 

[julian403]

Hola, estoy implementando FFT en Java y el código que hice es el siguiente:

El vector valoresGrafica tiene una dimensión de 1024. El problema es que obtengo una salida plana ¿que estoy haciendo mal? por cierto, no lo trabajo en la forma compleja ya que, bueno java no trabaja con números complejos.

public void fft() {
    double sum;
    double sumR=0;
    double sumIm=0;
 for(int i=0;i<1024;i++) {
     for (int j = 0; j < 1024; j++) {

         sumR=sumR+ (double) valoresGrafica[j]*Math.cos(-2* 3.1415* j *i* (1/1024));
         sumIm=sumIm+(double) valoresGrafica[j]*Math.sin(-2* 3.1415* j *i* (1/1024));
     }
     sum=Math.sqrt(Math.pow(sumR,2)+Math.pow(sumIm,2));
     fft[i]=((float) sum)/(1024);
     sumR=0;
     sumIm=0;
    
 }
 }

saludos.

Creo que el error está en el factor (1/1024) ya que no es periódica. Si elimino ese valor obtengo un array bastante bueno. Pero tiene mucho componente en continua. Pero obtengo bastante componente en continua

 

[Dr. Zoidberg]

En la web deben haber muchos paquetes de calculo de la FFT. Mejor si buscas...la ultima FFT que escribi en Fortran fue hace mas de 30 años.

 

[DOSMETROS]

Fortram 4 con compilador Watford