Bonjour tout le monde;

je souhaite implémenter un filtre en treilles  (Lattice filtre) en C, si quelqu'un peut m'aider ou me donner une idée , ça sera génial! comme expliqué ci dessous

-
Edité par madani2 21 juin 2017 à 17:24:31

Pfouuu! La transformée en z, ça remonte à loin pour moi. Si mes souvenir sont bons, les blocs z-1 sont des retards. Donc à chaque échantillonnage, tu vas recalculer toutes les nouvelles valeurs à partir de tes échantillons, ce qui va te donner la valeur de ta sortie.

Au coup suivant, tu refais la même chose, les échantillons ayant progressé d'un cran vers la droite.

-
Edité par zoup 21 juin 2017 à 18:17:01

bonjour zoup

Merci pour ta réponse, justement la difuculté est bien là, z-1 représente un retard, mais comment peux je le programmer? je sais qu'on peut prendre a chaque fois l'echantillion précédents mais pour les M premiers echantillons ça me donnera des valeurs négative puisque si i = 0 alors i-1 =-1 et la je n'ai pas déechantillion a -1.

Merci

je ne comprend pas ton problème de valeur négative. Au départ, tu est dans la phase transitoire et tes états ne sont pas tous définis en effet. Il suffit de leur donner une valeur initiale arbitraire, logiquement 0.

Ma question c'est que comment programmer le retard z-1
Merci

Ca n'est pas à proprement parler un retard, ce temps correspond à la période d'échantillonnage. Donc, à chaque nouvelle acquisition d'un x[n], tu lances ton calcul pour trouver y[n]

-
Edité par madani2 27 juin 2017 à 11:56:31

Tu n'aurais pas une erreur de syntaxe ligne 25, genre une virgule à la place d'un point-virgule?

-
Edité par zoup 23 juin 2017 à 19:17:52

Bonjour zoup;

C'est bon j'ai réussi a l'implémenter Merci beacoup pour ton aid.
j'ai compilé et testé et ça marche bien, maintenant je suis entrain d'implémenter le Lattice IIR filter, si t'as une idée je n'arrive pas à comprendre quoi donner comme valeur pour gN-1(n).

-
Edité par madani2 26 juin 2017 à 14:18:59

madani2 a écrit:

 si t'as une idée je n'arrive pas à comprendre quoi donner comme valeur pour gN-1(n).

Bin c'est l'échantillon précédent de gN(n)

zoup a écrit:

madani2 a écrit:

 si t'as une idée je n'arrive pas à comprendre quoi donner comme valeur pour gN-1(n).

Bin c'est l'échantillon précédent de gN(n)

d'accord, mais c'est quoi alors la valeur de  gN(n) ?, je ne sais pas comment initialiser gN(n)

-
Edité par madani2 26 juin 2017 à 17:27:19

???

regarde le schéma, c'est pourtant clair:les gi[n] sont calculés à partir des gi-1[n] et des fi-1[n]

oui ça c'est bien claire apparemment tu n'as pas compris ma question !
ce que je ne comprends pas est la première valeur de g, il est claire que fN=x(n) mais comment initialiser gN pour que je puisse continuer les calculs ! d'après le shéma g0 = Y mais Y c'est la sortie ! donc on ne peut pas la calculer sans passer par g meme !

Il me semble déjà avoir parlé du "problème" de la phase transitoire, tu as oublié?

Je n'ai pas bien compris ce concepte , merci en tout cas pour ton aide

Quel concept?

le voila mon code, mais ça marche pour un seul étage:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>


void Lattice_IIR(float *input,float *output ,float *parkor_coefficient,int nb_coefficient, int block_size)

{

	int i,j;
	float *f_in;
	f_in=malloc(block_size*sizeof(float));
	float *g_in;
	g_in=malloc(block_size*sizeof(float));
	float *g_out;
	g_out=malloc(block_size*sizeof(float));

	for (i=0;i<block_size;i++)
		{
		f_in[i]=input[i];
		g_in[i]=input[i];
		}

	for (j=nb_coefficient;j>0;j--)
		{
	
			for (i=block_size-1;i>=0;i--)
				{
					
				g_in[i]=g_in[i-1];
				
				
				
				output[i] = f_in[i] - parkor_coefficient[j]*g_in[i];
				printf("%f\n",output[i]);
				
				g_out[i] = output[i]*parkor_coefficient[j] + g_in[i];
				printf("%f\n",g_out[i]);
				
				}
				for(i=0;i<block_size;i++)
					{
					f_in[i]=output[i];
					g_out[i]=g_in[i];	
						if(j==1)
						{
							g_out[i]=output[i];	
						} 
					}
	
				
		}


}

-
Edité par madani2 28 juin 2017 à 10:25:39

Ça pourra sans doute aider -> ICI

Je ne comprends pas la différence entre block_size et nb_coefficient.

Je trouve que ta fonction fait trop de chose. Quel est le problème à résoudre? A chaque nouvel échantillon x[n], il faut recalculer y[n] à en tenant compte des états précédents des gi et mettre à jour les nouveaux états après calcul.

Il faut donc passer en paramètre:

- le nouvel échantillon

- le tableau des états antérieurs

- le tableau des états coefficients

- le nombre d'états

et retourner la nouvelle valeur de y calculée dans ta fonction, le tableau des états étant mis à jour

Le block_size est la langeur de mon signal donc le nombre d'échantillons, et nb_coeffcients correspond au nombre de coefficient qui donc le nombre des étage possèdant mon filtre. Dans mon programme j'ai essayé d'abord, de calculé la sortie y(n) pour un seul étage et réinjecter la sortie a l'entrée pour calculer a nouveau au fure à mésure   de nombre d'étages que j'ai.

Je pense qu'il serait préférable de faire comme je te l'ai indiqué pour bien décomposer le problème. Rien ne t'empêche ensuite de faire une fonction contenant tous les échantillons qui appellerait dans une boucle la fonction que je te propose.

Merci pour tes réponses.

-
Edité par madani2 7 juillet 2017 à 15:29:20