Discussion :

[n3i8co]

Bonjour,

Je suis nouveau et je ne sais pas si je suis dans le bonne section.
Je dois réaliser un filtre RIF en C.
J'ai obtenu les coefficients de mon filtre avec labview mais je ne sais pas comment traiter ces coefficients.

Quelqu'un aurait une idée de code en C pour réaliser ceci?

Merci
N3i8co

[diogene]

Bonjour et bienvenue sur le forum,

En supposant que tu veux un calcul direct (sans passer par des algorithmes de convolution) :
Si tu as un filtre d'ordre N, on peut stocker les coefficients dans un tableau Coeff de N flottants.
Il faut mémoriser les N dernières valeurs entrées dans le filtre. On aura donc un tableau Entrees de N flottants pour les stocker.

Pour obtenir la sortie, il suffit de faire la somme des produits coeff[i] et Entrees[i]
L'ennui est que pour calculer la valeur suivante, il faut décaler d'un cran toutes les valeurs du tableau Entrees pour insérer en queue la nouvelle valeur avant de faire ce calcul. Cette opération est simple, mais peut être couteuse en temps d'exécution.

Schématiquement, pour un filtre à 4 coefficients, le contenu des tableaux et le résultat seront :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Coeff  : C3 C2 C1 C0
Entree : x0 X1 X2 X3 -> Y = C3*X0 + C2*X1 +C1*X2 + C0*X3
         X1 X2 X3 X4 -> Y = C3*X1 + C2*X2 +C1*X3 + C0*X4
         X2 X3 X4 X5 -> Y = C3*X2 + C2*X3 +C1*X4 + C0*X5
....

On peut éviter le décalage des données en considérant le tableau des entrées comme un tableau circulaire et faire la somme des produits Coeff[i]*Entree[(p+i)mod N] en plaçant la nouvelle valeur en Entree[p] et en incrémentant p modulo N entre chaque point. Schématiquement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
Coef   : C3 C2 C1 C0
Entree : x0 X1 X2 X3 -> Y = C3*X0 + C2*X1 +C1*X2 + C0*X3
         p
         x4 X1 X2 X3 -> Y = C3*X1 + C2*X2 +C1*X3 + C0*X4
            p
         X4 X5 X2 X3 -> Y = C3*X2 + C2*X3 +C1*X4 + C0*X5
               p       
         X4 X5 X6 X3 -> Y = C3*X3 + C2*X4 +C1*X5 + C0*X6
                  p
         X4 X5 X6 X7 -> Y = C3*X4 + C2*X5 +C1*X6 + C0*X7
         p
....

Autre variante si on veut aussi éviter le calculer le mod N de p+i. On prend des tableaux deux fois plus grands. On fait la somme des produits Coeff[i]*Entree[p+i] (i= 0..N-1) en plaçant la nouvelle valeur en Entree[p] et en Entree[p+N] et en incrémentant p modulo N entre chaque point. Schématiquement:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Coef   : C3 C2 C1 C0 C3 C2 C1 C0
Entree : x0 X1 X2 X3 -  -  -  -   -> Y = C3*X0 + C2*X1 +C1*X2 + C0*X3
         p
         x4 X1 X2 X3 X4 -  -  -   -> Y = C3*X1 + C2*X2 +C1*X3 + C0*X4
            p
         X4 X5 X2 X3 X4 X5 -  -   -> Y = C3*X2 + C2*X3 +C1*X4 + C0*X5
               p
         X4 X5 X6 X3 X4 X5 X6 -   -> Y = C3*X3 + C2*X4 +C1*X5 + C0*X6
                  p
         X4 X5 X6 X7 X4 X5 X6 X7  -> Y = C3*X4 + C2*X5 +C1*X6 + C0*X7
         p
         X8 X5 X6 X7 X8 X5 X6 X7  -> Y = C3*X5 + C2*X6 +C1*X7 + C0*X8
            p
....

[n3i8co]

Merci beaucoup,

Avec ça je devrais y arriver.

[khallou2007]

Bonjour à tous,
merci diogene pour ces clarifications !!
je débute avec les filtre, et là j'implémente un FIR en c,
juste j'ai voulais savoir si je suis dans le bon chemin ou non,
j'ai un fichier de valeurs (double), alors je fais la lecture de chaque nombre X et j'applique à ce dernière le filtrage, je rederige ensuite la sotie vers un fichier "resultat", mais j'obtiendrai un nombre de sortie presque le double de l'entré !! est c'est normal !!
voici le code en joint:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
int main()
{
 /////////////// lire le fichier
    int Indice,i=0;
    for (Indice = 0; Indice <=NB_COEF; Indice++) {
        coef[Indice] = 0.0625;
          }
	fichier = fopen("/home/khaled/these/log/Filtre/EDF_ATMI_CPU1.txt", "r");
	if(fichier == NULL){
		fprintf(stderr,"Le fichier n'existe pas !!!!!!!!!!!");
	}
	else
		fprintf(stderr,"Le fichier existe et est ouvert en lecture seule \n" );
 
      // ouverture le fichier des resultats Y
    fic = fopen("/home/khaled/these/log/Filtre/resultat.txt", "w"); // ouvrir en ecriture
    if(fic == NULL){
        fprintf(stderr,"Impossible d'ouvrir le fichier resultat.txt\n");
        exit(1);
        }
 
 
    while(fgets(ligne_lue, sizeof(ligne_lue), fichier)!=NULL)
    {
        fprintf(stderr,"\n Lecture....");
		 //fprintf(stderr,"\nchaine :%s",ligne_lue);
		fprintf(stderr,"\n le coef in while est %f",coef[14]);
		sscanf(ligne_lue,"%s",&datav);
		fprintf(stderr,"\n le data en caractere est %s",datav);
		data=strtod(datav, NULL);
 
		    /////le filtre
            // data: Signal d'entrée
            // y: Signal de sortie
 
        fprintf(stderr,"\n filtrage....");
        int n=0;
        double y=0;
        fprintf(stderr,"\n le data double est %f",data);
        x_buffer[ptr_x_buffer++] = data;
        ptr_x_buffer %= NB_COEF;
        fprintf(stderr,"\n le x_buffer est %f",x_buffer);
        //fprintf(stderr,"\n le coef est %f",coef);
        for( n = (NB_COEF-1) ; n >= 0 ; n-- )
        {
                y += coef[n] * x_buffer[ptr_x_buffer++];
                ptr_x_buffer %= NB_COEF;
            }
            fprintf(stderr,"\n le data filtré est %f",y);
 ////////////écrirure des données///////////
       fprintf(fic, "%f \n", y);
printf("les donnees ont ete stockees dans resultat.txt\n");
            ///////////
        }
        fclose(fichier);
 
 
return 0;
}