Discussion :

[d0n32]

Salut WinJérôme,
Oui bien sûr je me suis informé ! Bon, je n'ai pas trouvé le document auquel tu fais référence (et qui est assez clair, je te remercie), mais j'ai quand même lu pas mal de doc sur le sujet. C'est juste qu'en tapant les choses sous Matlab et en comparant avec ce que j'aimerais obtenir, j'ai un peu de mal à comprendre et interpréter clairement les choses. La théorie c'en est une, la pratique une autre Je pense somme toute avoir réussi à implémenter un CIC correct, mais d'après ce que j'ai pu lire, j'ai tout intérêt à implémenter derrière un FIR compensateur. Encore faut-il parvenir à trouver les bons coefficients !

[d0n32]

J'ai d'ailleurs cherché hier comment régler un FIR (coefficients, ordre, ...), sans grand succès malheureusement. Je dois pouvoir décimer d'un facteur 8, puis-je en tirer des conclusions quant à la réalisation de mon FIR ?
Je vais essayer de détailler un peu plus : j'ai décimé un signal via un CIC d'ordre 2. J'obtiens donc en sortie le signal d'entrée sous-échantillonné, et dont une partie des HF a été filtrée (normal, car le CIC joue en même temps le rôle de Passe bas).
J'envoie le signal de sortie du CIC vers un FIR, dont j'aimerais qu'il décime d'un facteur 8, et qu'il me débarasse une fois pour toute des HF qu'il pourrait rester dans mon signal.
La fonction d'un filtre CIC est de la forme d'un sinus cardinal au carré, avec des zéros toutes les fréquences entières. Dans mon cas(R=64, ordre=2), la fréquence de coupure du filtre CIC à -3dB est de 0.3 environ.
Je pense que je dois donc designer un FIR qui a pour fréquence de coupure la même que mon CIC, à savoir 0.3. Le mieux serait qu'il compense les pertes de gain de mon filtre CIC. J'ai donc construit mon FIR à la main :

Code :

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

1
2
3
f = [0 0.3184 0.3184 1]; m = [1 10^(3/20) 0 0];
coeffs = fir2(30,f,m);
fvtool(coeffs);

Quand j'applique le filtre au signal d'entrée

Code :

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

y4=filter(coeffs,1,y3);

, j'obtiens à peu près n'importe quoi : mon signal de sortie a un amplitude très faible, il est déphasé, et pas du tout filtré au niveau des HF.
Je n'arrive pas à repérer ce qui pourrait être faux.. Si vous avez une idée donc, je prends

[d0n32]

Je vais essayer de détailler un peu plus : j'ai décimé un signal via un CIC d'ordre 2. J'obtiens donc en sortie le signal d'entrée sous-échantillonné, et dont une partie des HF a été filtrée (normal, car le CIC joue en même temps le rôle de Passe bas).
J'envoie le signal de sortie du CIC vers un FIR, dont j'aimerais qu'il décime d'un facteur 8, et qu'il me débarasse une fois pour toute des HF qu'il pourrait rester dans mon signal.
La fonction d'un filtre CIC est de la forme d'un sinus cardinal au carré, avec des zéros toutes les fréquences entières. Dans mon cas(R=64, ordre=2), la fréquence de coupure du filtre CIC à -3dB est de 0.3 environ.
Je pense que je dois donc designer un FIR qui a pour fréquence de coupure la même que mon CIC, à savoir 0.3. Le mieux serait qu'il compense les pertes de gain de mon filtre CIC. J'ai donc construit mon FIR à la main :

Code :

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

1
2
3
4
f = [0 0.3184 0.3184 1];
m = [1 10^(3/20) 0 0];
coeffs = fir2(30,f,m);
fvtool(coeffs);

Quand j'applique le filtre au signal d'entrée

Code :

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

y4=filter(coeffs,1,y3);

, j'obtiens à peu près n'importe quoi : mon signal de sortie a un amplitude très faible, il est déphasé, et pas du tout filtré au niveau des HF.
Je n'arrive pas à repérer ce qui pourrait être faux.. Si vous avez une idée donc, je prends

[d0n32]

Une question de débutant :
Je trace des graphes sous Matlab, qui apparaissent en fonction d'une fréquence normalisée :


Uploaded with ImageShack.us
J'aimerais savoir : normalisée par rapport à quoi ? Le *pi entre parenthèse, c'est pour quoi ?

[d0n32]

Une n-ième question :

Code :

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

doc freqz

Je lis :

Algorithm


freqz calculates the frequency response for a filter from the filter transfer function Hq(z). The complex-valued frequency response is calculated by evaluating Hq(ej) at discrete values of w specified by the syntax you use. The integer input argument n determines the number of equally-spaced points around the upper half of the unit circle at which freqz evaluates the frequency response. The frequency ranges from 0 to radians per sample when you do not supply a sampling frequency as an input argument. When you supply the scalar sampling frequency fs as an input argument to freqz, the frequency ranges from 0 to fs/2 Hz.

Sauriez-vous comment faire pour spécifier la valeur de cette fréquence d'échantillonnage s'il vous plaît ? Je n'arrive pas à faire fonctionner la fonction freqz avec un input fe.. Merci !

[Invité]

Code :

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

help freqz

[d0n32]

Concernant la PLL et son filtre de boucle de fonction de transfert F(s) = Lead + Lag/s. Est-ce que cela signifie que si j'ai en entrée une erreur epsilon, je récupère en sortie une fréquence f(n)=Lead*eps(n) + Lag*esp(n-1) qui controle le VCO ensuite

C'est à peu près l'idée, la variation à l'entrée de ta PLL fait varier la fréquence modulatrice de sortie du VCO.

Pour revenir au filtre de boucle de la PLL, j'ai trouvé pas mal d'informations, mais je ne sais comment m'y prendre :
Ecrire en Matlab une ligne du type Lead*esp(n)+Lag*eps(n-1) est-il correct/pertinent, ou est-il préférable de créer un filtre de fonction de transfert F(s) = (Lead*s + Lag)/s et de l'appliquer au signal d'entrée ?
Ou y'a-t-il encore une meilleure technique ?
Merci

[d0n32]

Bonjour à tous !
Pour revenir sur le filtre CIC, qui décime d'un facteur R=64, je lis que sa fonction de transfert est : H(z)=[(1-z^-R)/(1-z^-1)]^N où N est l'ordre du filtre (n=2 dans mon cas). Désolé pour l'horreur, je ne sais pas comment utiliser le Latex ou autre pour faire quelque chose de joli !
Ma question est :
Je souhaiterais intégrer ce filtre dans Matlab, via par exemple

Code :

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

filter(b,a,x)

Pour ce faire, il faut que je détermine les vecteurs a et b à partir de la fonction de transfert du filtre. Je coince sur la théorie : puis-je développer "brutalement" l'expression et avoir :
(1+z^-128 -2*z^-64) / (1 + z^-2 -2*z^-1) et donc créer les vecteurs

Code :

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

1
2
3
 
a=[1 -2 1]
b=[1 0...0 -2 0...0 1]

ou dois-je m'y prendre autrement ?
D'avance, merci !

Ce que j'ai fait pour le moment :

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
%Filtrage+décimation(R=64) par CIC d'ordre 2
for k=1:nbpts   
 b=[ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
        0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
        0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
        0 0 0 -2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
        0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
        0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
        0 0 0 0 0 0 0 1];
    a=[1 -2 1];
 
    s_apcic(1,k)=filter(b,a,s_avcic(1,k));
    s_apcic(2,k)=filter(b,a,s_avcic(2,k));
    s_apcic=[s_apcic s_apcic(:,k)];
 
% Et ça continue
...
end

Un filtre, ça peut bien s'appliquer de cette façon non ? (comprendre, à "un point à la fois" )
Merci !

[d0n32]

Et étonnamment, ça ne marche pas !

J'ai aussi essayé cette solution, qui me parait meilleure :

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
if k==1
        num_cic=[ 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
            0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
            0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
            0 0 0 -2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
            0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
            0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ...
            0 0 0 0 0 0 0 1];
        den_cic=[1 -2 1];
        [numd_cic,dend_cic]=eqtflength(num_cic,den_cic);
        [A,B,C,D]=tf2ss(numd_cic,dend_cic);
        mn=size(A);
        x=zeros(mn(2),npts+1);
    end
    x(:,k+1)=A.*x(:,k)+B.*s_avcic(:,k);
    s_apcic(:,k)=C.*x(:,k)+D.*s_avcic(:,k);

mais je suis confronté à un problème de taille de vecteur : s_avcic est de taille 2x125000 alors que les matrices crééés via tf2ss sont plutôt de taille 127*125000..

[d0n32]

J'aimerais comprendre le fonctionnement des fonctions modulate et demod de Matlab. Si j'écris :

Code :

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

1
2
3
data_brutes = floor((rand(1,1e3)+0.5));
sig_mod = modulate(data_brutes,fi,fe,'pm');
sig_demod = demod(sig_mod,fi,fe,'pm');

, je n'obtiens pas la même chose pour sig_demod et data_brutes.. normal ?

[Invité]

Bonjour,

Connais-tu la définition du bruit blanc?
Je te conseille de regarder à nouveau le post #25
Essai plutôt de tester ces fonctions avec une sinusoïde

Code :

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

1
2
3
t = 0:1/fe:1;
fo = 200;
data_brutes = sin(2*pi*t*fo);

[d0n32]

Salut, et merci de ta réponse !
Je connais bien la notion de bruit blanc, mais là je ne pense pas que ce soit un critère qui entre en jeu. Les fonctions sont utilisées dans un cas idéal ici, il n'y a aucun bruit qui entre en jeu. Et comme mes données sont des séries de 0 et de 1, je ne vois pas l'utilité du sinus ici. Je pense avoir trouvé une solution, qui consiste en l'utilisation du bit rate (qui n'est pas défini dans les fonctions modulate et demod).

[Invité]

mais là je ne pense pas que ce soit un critère qui entre en jeu. Les fonctions sont utilisées dans un cas idéal ici, il n'y a aucun bruit qui entre en jeu

Petit rappel: le bruit blanc est défini par une constante sur tout le spectre.
Or lorsqu'il est question d'échantillonnage, on est toujours limité par Shannon.

data_brutes = floor((rand(1,1e3)+0.5));

Ce que tu construis ici est un genre de "bruit blanc carré", ne t'attends donc pas à pouvoir le reconstruire correctemment.

[d0n32]

Ce que j'ai fait du coup, pour éviter d'avoir un signal bruité, j'ai fait une hard decision, du genre :

Code :

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

1
2
3
4
5
 if sig > 0
 sig =0;
 else
 sig = 1; 
end

Et ça marche plutôt pas mal, je récupère le message à l'identique

[d0n32]

Bonjour,
Je souhaiterais calculer le taux d'erreur binaire pour une modulation de type FM en fonction du rapport signal à bruit. J'ai écrit le programme suivant :

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
60
61
62
63
64
65
66
67
68
 
function ber = ber_fm(SNR,br)
% Init
fe = 250e6;         %fréquence d'échantillonnage
fi = 70e6;          %fréquence porteuse
t_simu = 1e-3;      %temps de simulation
filtre_actif = 0;
 
% Mod
[phase data_brutes] = nco_FM(fe,br,t_simu);
sig_mod = modulate(data_brutes,fi,fe,'fm',2*pi*(br/fe));
S = fftshift(abs(fft(sig_mod)));
 
% Bruit
sig_filtre_in = awgn(sig_mod,SNR);
 
% Filtre
h_demod = generer_canal_FM(1);
filtre_actif = 1;
sig_filtre_out = filter(h_demod,1,sig_filtre_in);
 
% Demod
if filtre_actif == 1
    sig_demod = demod(sig_filtre_out(128:end),fi,fe,'fm',2*pi*(br/fe));
else
    sig_demod = demod(sig_mod,fi,fe,'fm',2*pi*(br/fe));
end
 
% Decision
for l = 0:br*t_simu-1
    if (l+1)*fe/br <= 249840
        aire(l+1) = sum(sig_demod(l*(fe/br)+1:(l+1)*fe/br))/(fe/br);
    end
    if l+1 <= 249840*br/fe
        if aire(l+1)>0.5
            sig_demod(l*fe/br+1:(l+1)*fe/br) = 1;
        else
            sig_demod(l*fe/br+1:(l+1)*fe/br) = 0;
        end
    end
end
 
% Corrections
if br == 10e6 || br == 12.5e6
    sig_demod(1:end-1) = sig_demod(2:end);
    sig_demod = sig_demod(1:249799);
end
 
% BER
compt = 0;
compt2 = 0;
for l = 0:br*t_simu-1
    if (l+1)*fe/br <= 249799
        aire1 = sum(sig_demod(l*(fe/br)+1:(l+1)*fe/br))/(fe/br);
        aire2 = sum(data_brutes(l*(fe/br)+1:(l+1)*fe/br))/(fe/br);
    end
    if aire1 ~= aire2
        compt = compt + 1;
    end
    compt2 = compt2 + 1;
end
 
ber = compt/compt2;
 
% figure
% plot(data_brutes(1:249873))
% hold on
% plot(sig_demod(1:249873),'r')

Mais les résultats obtenus pour différents SNR et bit rate ne sont pas cohérents avec les résultats théoriques..

J'ai fait la simulation avec le bout de code suivant :

Code :

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

1
2
3
4
5
for k = 0:18
    ber25(k+1) = ber_fm(k,25e6);
    ber10(k+1) = ber_fm(k,10e6);
    ber125(k+1)= ber_fm(k,12.5e6);
end

Voyez-vous où pourrait se trouver l'erreur s'il vous plait ?
Le filtre est un bête filtre passe bande dont je dispose.
Je me demande si le problème ne pourrait pas venir du bruit que j'ajoute, awgn ?
Merci d'avance

[d0n32]

Bonjour !
Toujours dans le cadre de la modulation FM,

Code :

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

doc modulate

me donne en partie

Code :

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

1
2
3
4
5
6
 
fm          Frequency modulation. Creates a sinusoid with instantaneous frequency that varies with the message signal x. 
 
y = cos(2*pi*fc*t + opt*cumsum(x)) cumsum is a rectangular approximation to the integral of x. modulate uses opt as the constant of frequency modulation. If opt is not present, modulate uses a default of
 
opt = (fc/fs)*2*pi/(max(max(x))) so the maximum frequency excursion from fc is fc Hz.

C'est la partie sur le opt qui m'intéresse : qu'est-ce qu'il signifie exactement, et comment dois-je le régler ?
Merci