Réaliser des filtres sous VHDL ( Spartan II)

[invitef849445b]

Bonjour,
Je suis une débutante dans la programmation vhdl, pour commencer j'allumais des leds et je faisais de la logique combinatoire pour me familiariser avec ce langague mais il m'est demander de faire des filtre (passe_bas, passe_haut, passe_band,RIF...) je n'ai aucune idée sur comment m'y prendre si quelqu'un a deja fait cela ou a deja croiser un site qui parle de ca, je suis preneuse de tous ce que vous avez sur la programmation des filtres en VHDL .
Merci beaucoup de votre future aide
-----

[micka_ch]

Bonjour,

J'ai déjà effectué ce genre de chose mais sur des Spartan 6 équipé de DSP Slice (hardware dédié pour la multiplication et l'accumulation). Je sais qu'il est possible de décrire des multiplications et des additions avec le langage VHDL et que cela devrait générer des multiplicateurs et additionneurs fonctionnelles mais bien moins performant. Par contre je ne connais pas la syntaxe.

Salutations

[jiherve]

Bonsoir,
il faut dejà choisir la topologie du filtre:
IIR ou FIR les implémentations seront différentes et chaque architecture présente avantages et inconvénients.
Pour un débutant je choisirait un FIR car il n'y a pas de problème de convergence du a des imprécision de calcul.
Le codage n'en est pas très difficile et l'avantage c'est qu'une fois le pipeline et les multiplieurs/additioneurs réalisés ainsi que le distributeurs de coeff on passe d'un type de filtre à un autre en changeant les coeff. il doit y avoir une aide la dessus dans l'IDE Xilinx.
JR

[mizambal]

hello. Savoir implémenter un CAN n'est-ce pas un pré-requis ?

[A voir en vidéo sur Futura]

[jiherve]

bonjour
un CAN avec un FPGA?
On peut faire un CNA par PWM mais pour un CAN ce n'est pas possible ,un FPGA c'est du numérique pur et dur,quoique la solution utilisée sur Propeller pourrait etre jouable mais avec une précision lamentable.
JR

[micka_ch]

Bonjour,

Peut-être que mizambal voulait dire "interfacer" un CAN externe plutôt que "implémenter".

Concernant les filtres, l'outil Xilinx CORE Generator propose un "wizard" FIR Compiler (Digital Signal Processing/Filters/FIR Compiler) pour aider à la synthèse de filtre numérique de type FIR.

Salutations

[mizambal]

Hello. bien vu ! Je me suis fait avoir par l’anglicisme : "to implement" = mettre en oeuvre (le sens en anglais), en effet je parlais bien de la partie hardware, donc le verbe "implémenter" est effectivement ambigu en français car plus souvent ils désigne du software , désolé j'y ferais gaffe la prochaine fois.

[invitef849445b]

Salut à tous,
merci de vos réponse, mais n'est il pas prudent de commencer avec déja un filtre passe bas avant le RIF???

[micka_ch]

Bonjour,

Est-tu au claire sur la théorie et la pratique du traitement du signal numérique et plus particulièrement sur la synthèse des filtres ?

Car un filtre passe-bas, passe-haut, passe-bande, en numérique, c'est une structure FIR ou IIR. En réalité il y a bien d'autres techniques de filtrage en numérique mais restons dans le basique.

Donc si tu veux commencé par le passe-bas, tu dois commencé par choisir la structure.

Salutations

[invitef849445b]

vhdl-pld.pdf
Voici mon sujet pour le filtre passe bas pour commencer. merci de votre future aide

[micka_ch]

Bonjour,

Ceci : n'est autre une filtre à réponse impulsionnelle infini (IIR)!

Dans ton cas b0 =1 et a1 = 0.5. Le détail du calcul est bien expliquer, où est-ce que tu bloque ?

Salutations

[invitef849445b]

pourquoi on fait ca???? x(7)&x(n)&0000000 ( 16 bits )

[micka_ch]

Car le produit des 2 nombres codés sur 8 bit nous donne un 16 bit donc on doit représenter x[n] sur 16 bit alors qu'il est initialement codé sur 8 bit.

Comme il est signé, on doit propager le signe. Exemple avec x[n]=-0.5:

-0.5 sur 8 bit (format Q0.7) : 1.100'0000
-0.5 sur 16 bit (format Q1.14) : 11.10'0000'0000'0000

[jiherve]

Bonjour
Il y a un truc qui me gêne dans le pdf c'est que l’équation donnée Yn = Xn+(Yn-1)/2 ne converge pas car à l'infini on devrait avoir Yn= Yn+Yn/2 ce qui n'est pas possible.
par contre avec Yn = Xn/2 + (Yn-1)/2 c'est bon, ceci dit il semble qu'il y ait une division par 2 cachée dans le X étendu !!!!!
Mais peut être me goure je ?
JR

[mizambal]

hello. Au lieu d'utiliser une multiplication par 0.5, ne serait-il pas plus simple ou rapide de faire un décalage d'un bit vers à droite ?

[micka_ch]

Bonjour
Il y a un truc qui me gêne dans le pdf c'est que l’équation donnée Yn = Xn+(Yn-1)/2 ne converge pas car à l'infini on devrait avoir Yn= Yn+Yn/2 ce qui n'est pas possible.

Je ne connais pas cette méthode pour étudier la stabilité mais par contre on a : H(z)=z/(z-0.5), donc 1 pôle à z1=0.5 ce qui veux dire stable car |z1|<1

[invitef849445b]

Pour être honnête j'ai déja la correction de ce sujet, mais justement je n'y rien compris, je me suis dis que c'est forcement plus simple que ca, c'est pour cela que j'ai publié sur le forum pour qu'on me guide et le faire moi même...

[jiherve]

Bonsoir,

Je ne connais pas cette méthode pour étudier la stabilité mais par contre on a : H(z)=z/(z-0.5), donc 1 pôle à z1=0.5 ce qui veux dire stable car |z1|<1

il n'est pas question de stabilité mais de convergence vers une valeur finie or l’équation Yn = Xn+(Yn-1)/2 devrait converger vers Xn si celui est constant(c'est un filtre basse bas) j'ai comme un doute!
par contre comme déjà écrit dans l’implémentation il y a une division par 2(cachée) de Xn, serait ce tombé en marche?
un passe bas IIR du premier ordre est toujours de la forme Yn = Xn*(1-k)+(Yn-1)*k.
C'est très facile à faire si les coeff sont du type k/2^n (k<2^n) car les multiplications se font par des entiers et la division finale de renormalisation est un décalage à droite ce qui dans un FPGA n'est qu'un remaping de la somme.
JR

[micka_ch]

Bonjour,

Si x[n] = C, alors la sortie converge vers la valeur 2*C. On peut le voir de 2 manières :
1. H(z)=Y(z)/X(z)=z/(z-0.5) -> Y(z)=H(z)*X(z), Valeur final quand z tend vers 1 : Y(z)=1/(1-0.5)*C=2*C
2. Saut unitaire à l'entrée : x[n]=C si n>=0, 0 sinon
y[0]=C
y[1]=C+C/2
y[2]=C+(C+C/2)/2=C+C/2+C/4
y[3]=C+C/2+C/4+C/8
y[n]=C*sum(1/2^i) avec i de 0 à n
y[inf]=C*(1+1/2+1/4+1/8+...)=2*C (série convergente vers 2)

Peut être que c'est voulu, en tout cas ce n'est pas "illégal".

"On utilise directement les opérations arithmétiques fournies dans les librairies. Ceci a l’avantage
d’être très compact au niveau du code mais présente l’inconvénient de générer une architecture assez
conséquente lors du routage. Nous verrons par la suite que pour réaliser des filtres d’ordre plus élevé, il nous
faudra utiliser une stratégie différente."

A mon avis le but de l'exercice était d'écrire sans réfléchir quelque chose dans le genre:

r_mult <= coeff * yn_1;
r_final <= x_etendu + r_mult;
yn <= r_final(14 downto 7);

De voir l’abominable schéma et ensuite réfléchir et utiliser les puissances de 2.

[jiherve]

bonjour,
en effet on peut mettre du gain, j'y suis si peu habitué que je n'y avais pas pensé , ce n'est pas très utile, mais ce n'est pas ce qui est codé car x étendu = x(7)&X&"0000000" le & étant la concaténation Xn est donc subrepticement divisé par 2; On retombe alors sur la forme simple Yn = Xn/2+(Yn-1)/2 filtre ayant un gain de un ce qui est prudent si l'on ne veut pas se faire c..r à gérer la virgule au delà du raisonnable.
Dans la pratique on fera Yn = (Xn+Yn-1)>>1 ,quoiqu'il en soit il y aura troncature.
JR

[micka_ch]

x étendu = x(7)&X&"0000000"

Cette manipulation permet de passer du format Q1.7 au format Q2.14. Ceci est nécessaire car on multiplie deux 8bit au format Q1.7 (coeff*y(n-1)), le résultat est est un 16bit au format Q2.14. Donc si on veux y additionner x(n), il faut d'abord le convertir.

Petit exemple :

x = -0.5, ou 0xC0 en Q1.7
coef=0.5, ou 0x40 en Q1.7
y = 0.25, ou 0x20 en Q1.7

y*coef = 0.125, ou 0x0800 en Q2.14
x_e = -0.5, ou 0xE000 en Q2.14

res = x_e + y*coef = -0.375, ou 0xE800 en Q2.14

[jiherve]

Bonsoir
pour moi cet exemple est ambiguë.
Mais tes remarques sont justes car effectivement il suppose implicitement un codage en complément à deux 1.7 au vu de la valeur de 0,5 , je lis mais interprète à ma sauce erronée en l’occurrence.
Donc sujet clos.
JR

[invitef849445b]

Bonjour à tous,
j'ai bien lu ce que vous avez tous écris, je vous remercie beaucoup car j'y vois un peu plus claire.
comme je vous ai dis j'ai la solution de ce sujet, je vous la partage car personnellement je truc que c'est beaucoup plus compliqué que ce que je pensais ( en tous cas c'est mon avis de débutante peut être que vous sa passe crème ) bref je vous le joins et j'attends vos commentaires svp
Filtre (1).zip

[invitef849445b]

Ce que je ne comprend pas dans le programme que je vous ai envoyé c'est déjà pourquoi il y a un sous programme de ce séquenceur ( je ne comprends pas à quoi il sert).
ensuite je ne comprends pas ce que signifie ces deux lignes:

		elsif ecrit'event and  ecrit='1' then
		     coef0 := conv_std_logic_vector((conv_signed(conv_integer(par),8) * conv_signed(conv_integer(x_data),8)),16);-------
			coef1 := conv_std_logic_vector((conv_signed(conv_integer(par),8) * conv_signed(conv_integer(x1_data),8)),16);---------

et pour finir ca non plus je ne comprens pas ce que c'est ces zzzz

ECRI_DAT:
	B_DATA <= y_data when ecrit = '0' else "ZZZZZZZZ"; --------------

[micka_ch]

Bonjour,

coef0 := conv_std_logic_vector((conv_signed(conv_integer(par),8) * conv_signed(conv_integer(x_data),8)),16);

Pour effectuer une multiplication avec * en VHDL, qui est défini dans NUMERIC_STD on doit convertir les STD_LOGIC_VECTOR en SIGNED.

-- Id: A.16
function "*" (L, R: SIGNED) return SIGNED;
-- Result subtype: SIGNED((L'LENGTH+R'LENGTH-1) downto 0)
-- Result: Multiplies two SIGNED vectors that may possibly be of
-- different lengths.

Ce qui est effectué ici c'est
1. Conversion de par et x_data en entier
2. Conversion de du résultat de 1. en signé
3. Multiplication de par et x_data (converti en signed)
4. Reconversion du résultat en STD_LOGIC_VECTOR.

B_DATA <= y_data when ecrit = '0' else "ZZZZZZZZ";

Ceci est l'implémentation typique d'un buffer tri-state, permettant la gestion d'un bus de données bi-directionnel.

Effectivement c'est assez compliqué pour un débutant. Par contre ce code ne correspond pas à la donnée vhdl-pld-3.pdf ??!!??

Le filtre implémenter dans SX_FPBAS1.vhd est : y[n]=x[n]/2+x[n-1]/2 (une moyenne des 2 derniers échantillons, effet passe-bas)
Le filtre décrit dans vhdl-pld-3.pdf : y[n]=x[n]+y[n-1]/2 (un filtre IIR passe-bas)

Il y a un manque de cohérence entre la donnée et la solution.

Salutations

[invitef849445b]

Merci pour votre réponse j'y vois de plus en plus claire, mais c'est vraiment la correction de ce sujet, la personne m'ayant donner le sujet a fait une gaffe en m'ajoutant la correction -_- mais comme je ne suis pas un tricheuse je voulais le faire moi même, intriguée je jette un coup d'oeil ensuite je réalise que personnellement je n'aurais jamais fait ca, je n'y aurais jamais pensé car il y'a plein de chose que j'ai appris seulement avec vous sur ce forum :/ .
encore une question, je ne comprends pas pourquoi il y a un sous programme séquenceur??? je ne sais pas à quoi il sert

[micka_ch]

Le composant "Seq_AdDa" ?

C'est la logique nécessaire pour accéder au convertisseur AD/DA (interface avec le AD7569 de la carte de dev).

Si cela peut aider, voici une implémentation "quick & dirty" du filtre ainsi qu'une simulation basique non-exhaustive :

----------------------------------------------------------------------------------
-- First order LPF filter IIR implementation y[n]=x[n]+a1*y[n-1]
----------------------------------------------------------------------------------
library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity LPF is
    Port ( x : in  STD_LOGIC_VECTOR (7 downto 0);
			  a1 : in STD_LOGIC_VECTOR (7 downto 0);
           y : out  STD_LOGIC_VECTOR (7 downto 0);
           clk : in  STD_LOGIC;
           rst : in  STD_LOGIC);
end LPF;

architecture Behavioral of LPF is

	signal x_e : signed(15 downto 0);
	signal res : signed(15 downto 0);
	signal a1s : signed(7 downto 0);
	signal ys  : signed(7 downto 0);

begin

	p_filt : process(clk,rst)
	begin
		if rst = '1' then
			res <= (OTHERS=>'0');
		elsif rising_edge(clk) then
			res <= x_e + ys*a1s;
		end if;
	end process p_filt;

	x_e <= signed(x(7) & x & "0000000");
	a1s <= signed(a1);
	ys <= res(14 downto 7);
	y <= std_logic_vector(ys);

end Behavioral;

[invitef849445b]

Salut,
désolée pour mon looong absence, comme je me suis remise au travail ce matin , j'ai changé le programme de la dernière fois afin d’implémenter ce filtre là y[n]=x[n]+y[n-1]/2, euuuh juste une question qui a peut être l'aire bête, dites moi, c'est à quel moment on donne la fréquence de coupure d'un filtre passe bas ???
et merci pour l'exliquation du séquenceur, je vois beaucoup mieux maintenant

[inviteb9f49292]

c'est à quel moment on donne la fréquence de coupure d'un filtre passe bas ???

Quand tu conçois le filtre, tu cherches en fait des coefficients qui réalisent au plus prêt le gabarit spectral de ton filtre idéal. Donc les coefficients a et b "contiennent" la ou les fréquences de coupure, et tout le reste puisque ton filtre est défini sans ambiguité par ses coeff. Si tu joues avec MATLAB, par exemple la fonction "butter" te donnera les coeff d'un filtre type Butterworth en fonction de l'ordre et de la fréquence de coupure désirée.

[jiherve]

Bonjour,
Précision : les fréquences de coupure dépendent des coefficient ET surtout de la fréquence échantillonnage/traitement.
JR