1 2 / 3 / 2 1 1 0 : 2 5 P M /home/orimbato/TP_CNU/TP1_1.

m 1/2

clear;
close all;
%% Modulateur OFDM TP1
%ICI ON TRAVAILLE ON VECTEUR LIGNE
%% Paramètres:
B = 1 . 0 9 5 * 1 0 ^ 6 ; % bande occupée (−CP)
N = 1 2 8 ; % Nb de sous porteuses, ou FFT Size
S C S = 1 5 * 1 0 ^ 3 ; % espacement entre les sous porteuses
l = 2 ;%première indice de la fréquence active selon la figure 2
M = 4 ; % modulation QAM
Fs=1.92*10^6;
t=(0:N−1)/Fs;
rng(0);

%% 2)
%% a)sous−porteuses actives
C=(B/SCS)−1; % nb de sous porteuses actives (−1 à acause de DC)
%nb de symboles QAM à générer
ind_freq=[l:round(C/2)+1 (N−(round(C/2)+1−l):N)]; % selon figure2 on a C/2 actives positives,
%0 au milieu, C/2 actives negatives
%% b)symboles aléatoire
seq_ent=randsrc(1,C,[0:M−1]);
d=qammod(seq_ent,M);

%% c) IFFT
e(ind_freq)=d; %mettre les symboles sur les porteuses actives; % add zeros
s=ifft(e);
Ts=1/Fs;
Tu=N*Ts; %durée d’une symbole, et nombre de point

plot(t,real(s),’o−’), grid o n;

%% 3)
%% a) Nombre de points du CP
Tg_long=16.67*10^−6; % donnée par l’énoncé
Ng=round(Tg_long*Fs);
Perte_long=Ng/(Ng+N);

%CP court premier symbole Tg1,

Tg1=5.21*10^−6;
%CP court entre symbole Tg2,
Tg2=4.69*10^−6;
Ng1=round(Tg1*Fs);
Ng2=round(Tg2*Fs);
Perte_court= (Ng1+6*Ng2)/((Ng1+N)+6*(Ng2+N)); % 1 long et 6 court

%symbole OFDM Ng+N

%on preleve les Ng derniers echantillons
CP=s(N−Ng+1:N); %+1 à cause de l’indice Matlab
sg=[CP s]; % ajout du préfixe cyclique

%% b) Puissance
K = N + N g ; % longueur total du symbole OFDM avec OFDM

%puissance estimé
P=(1/K)*sum(sg.*conj(sg)); %1/K)*sum(abs(sg).^2) (5)

% puissance théorique
dk=qammod([0:3],M); %(valeur possible)
var_dk=(1/M)*sum(dk.*conj(dk));
p_th=C*var_dk*(1/N^2);
1 2 / 3 / 2 1 1 0 : 2 5 P M /home/orimbato/TP_CNU/TP1_1.m 2/2

%% c) Facteur d’Amplitude A
Pa_dbm=−30;
Pa_db=Pa_dbm−30;
A_dB=Pa_db−(10*log10(P));
A=10^(A_dB/20);

rg=A*sg; %signal avec puissance ajustée

s_test=transpose(rg); %avoir un vecteur colonne

verif_lte_symbol(s_test,1,1,M,Pa_db);
1 2 / 3 / 2 1 1 0 : 2 6 P M /home/orimbato/TP_CNU/TP1_2_frame.m 1/2

close all;
clear;
%% frame OFDM

%% paramètres
B = 1 . 0 9 5 * 1 0 ^ 6 ; % bande occupée (−CP)
N = 1 2 8 ; % Nb de sous porteuses, ou FFT Size
S C S = 1 5 * 1 0 ^ 3 ; % espacement entre les sous porteuses
l = 2 ;%première indice de la fréquence active selon la figure 2
M = 4 ; % modulation QAM
Fs=1.92*10^6;
t=(0:N−1)/Fs;
rng(0);

%préfixe cyclique
Tg_long=16.67*10^−6;
Ng=round(Tg_long*Fs);

%% 2)Génération d’une Frame LTE

%% 1) Symboles OFDM
Nt=120; % 6 symboles par slots,20 slots par frame
%% 2) frame
% frame=ones(C,Nt);

%% a) sous porteuses actives

C=(B/SCS)−1; % nb de sous porteuses actives, nb de symboles par slot

ind_freq=[l:round(C/2)+1 (N−(round(C/2)+1−l):N)];

%%

Nu=C;

%% donées à transmettre
% data=zeros(C,Nt);
%
% for i=1:Nt
% e_b=randsrc(1,Nu,[0:M−1]);
% d=qammod(e_b,M);
% d=d.’; %vecteur colonne
% data(:,i)=d;
% end
seq_ent=randsrc(C,Nt,(0:M−1)); %matrice de Nu*Nt
data=qammod(seq_ent,M);

%% trame
frame=zeros(N+Ng,Nt);
for k=1:Nt
d=data(:,k);
d=d.’;
e(ind_freq)=d; %entrée IFFT
s=ifft(e);
CP=s(N−Ng+1:N); %prefixe cyclique
sg=[CP s]; %vecteur ligne ajout préfixe cyclique
sg=sg.’; %ranger en vecteur colonne
frame(:,k)=sg;

end
frame=frame(:);
1 2 / 3 / 2 1 1 0 : 2 6 P M /home/orimbato/TP_CNU/TP1_2_frame.m 2/2

frame=frame.’; %vecteur ligne

%% ajustement de puissance
P=(1/length(frame))*sum(frame.*conj(frame));
Pa_dbm=−10;
Pa_db=Pa_dbm−30;
A_dB=−(10*log10(P));
A=10^(A_dB/20);

frame=A*frame;
verif_lte_frame(frame,1,2,M,Pa_db);

%% 5) DSP
1 2 / 3 / 2 1 1 0 : 2 6 P M /home/orimbato/TP_CNU/TP2_1.m 1/2

clear;
close all;
%% Démodulateur OFDM TP2
%ICI ON TRAVAILLE ON VECTEUR LIGNE
%% Paramètres:
B = 1 . 0 9 5 * 1 0 ^ 6 ; % bande occupée (−CP)
N = 1 2 8 ; % Nb de sous porteuses, ou FFT Size
S C S = 1 5 * 1 0 ^ 3 ; % espacement entre les sous porteuses
l = 2 ;%première indice de la fréquence active selon la figure 2
M = 4 ; % modulation QAM
Fs=1.92*10^6;
t=(0:N−1)/Fs;
rng(0);

%% Modulation
%sous−porteuses actives
C=(B/SCS)−1;
ind_freq=[l:round(C/2)+1 (N−(round(C/2)+1−l):N)]; % selon figure2 on a C/2 actives positives,
%0 au milieu, C/2 actives negatives
%symboles aléatoire
seq_ent=randsrc(1,C,[0:M−1]);
d=qammod(seq_ent,M);
%IFFT
e(ind_freq)=d; %mettre les symboles sur les porteuses actives; % add zeros
s=ifft(e);
Ts=1/Fs;
Tu=N*Ts; %durée d’une symbole, et nombre de point
%Nombre de points du CP
Tg_long=16.67*10^−6; % donnée par l’énoncé
Ng=round(Tg_long*Fs);
CP=s(N−Ng+1:N); %+1 à cause de l’indice Matlab
sg=[CP s]; % ajout du préfixe cyclique

%Puissance
K = N + N g ; % longueur total du symbole OFDM avec OFDM
%puissance estimé
P=(1/K)*sum(sg.*conj(sg)); %1/K)*sum(abs(sg).^2) (5)

%% c) Facteur d’Amplitude A
Pa_dbm=−10;
Pa_db=Pa_dbm−30;
A_dB=Pa_db−(10*log10(P));
A=10^(A_dB/20);

rg=A*sg;

%% 1 Génération de x(t)
%puissance du bruit
Pb_dbm=−100;
Pb_db=Pb_dbm−30;
Pb=10^(Pb_db/10);
%atténuation
k_db=−60;%20log(k)
k=10^(k_db/20);
SNR=Pa_dbm−Pb_dbm;

b=complex((sqrt(Pb/2))*randn(1,length(rg)),(sqrt(Pb/2))*randn(1,length(rg)));

%% 2)RSB
x=k*rg+b;
1 2 / 3 / 2 1 1 0 : 2 6 P M /home/orimbato/TP_CNU/TP2_1.m 2/2

RSB=k_db+Pa_db−Pb_db; %(20logk+10logPs−10logPb) k²Pa/Pb

%% 3 Démodulation seule
%% i) remove CP
x=x(length(CP)+1:length(x));
%% ii) FFT
y=fft(x);
%% iii) remove zeros
y_n=y(ind_freq);

%% 4) Information binaire/entiere
yn=y_n/(A*k); %symboles QAM démodulés
scatterplot(y_n), grid o n;

seq_est=qamdemod(yn,M); %séquence estimée

[Nberreur,SER]=symerr(seq_ent,seq_est);
[Nberreur_bit,BER]=biterr(de2bi(seq_ent),de2bi(seq_est));

%% 5)Estimation RSBout
%signal sans bruit
st=k*rg;
x_est=st(length(CP)+1:length(st));
x_k=fft(x_est);

%bruit seul
nn=b(length(CP)+1:length(st));
nn_k=fft(nn); %bruit en sortie de l’FFT

yn_k=x_k+nn_k;

%puissance en sortie de FFT

Pst=(1/length(x_k))*sum(x_k.*conj(x_k));
Pnn_k=(1/length(nn_k))*sum(nn_k.*conj(nn_k));

RSBout_th=(N/C)*10^(RSB/10);
RSBout=Pst/Pnn_k;

scatterplot(x_k/(A*k)),grid o n, title(’Signal sans bruit’) ;

scatterplot(nn_k),grid o n, title(’bruit’) ;
scatterplot(yn_k/(A*k)),grid o n, title(’Signal avec bruit’) ;
1 2 / 3 / 2 1 1 0 : 2 7 P M /home/orimbato/TP_CNU/TP2_2_frame.m 1/2

close all;
clear;
%% 6. démodulation frame OFDM

%% paramètres
B = 1 . 0 9 5 * 1 0 ^ 6 ; % bande occupée (−CP)
N = 1 2 8 ; % Nb de sous porteuses, ou FFT Size
S C S = 1 5 * 1 0 ^ 3 ; % espacement entre les sous porteuses
l = 2 ;%première indice de la fréquence active selon la figure 2
M = 4 ; % modulation QAM
Fs=1.92*10^6;
t=(0:N−1)/Fs;
rng(0);
Pa_dbm=−10;
Pa_db=Pa_dbm−30;

%préfixe cyclique
Tg_long=16.67*10^−6;
Ng=round(Tg_long*Fs);

%% 1) Trame LTE émise

%Symboles OFDM
Nt=120;
%sous porteuses actives
C=(B/SCS)−1; % nb de sous porteuses actives, nb de symboles par slot
ind_freq=[l:round(C/2)+1 (N−(round(C/2)+1−l):N)];
Nu=C;
% données à transmettre symbole QAM
seq_ent=randsrc(C,Nt,(0:M−1)); %matrice de Nu*Nt
data=qammod(seq_ent,M);
%trame
frame=zeros(N+Ng,Nt);
for k=1:Nt
d=data(:,k);
d=d.’;
e(ind_freq)=d; %entrée IFFT
s=ifft(e);
CP=s(N−Ng+1:N); %prefixe cyclique
sg=[CP s];
sg=sg.’;
frame(:,k)=sg;

end
frame=frame(:);
frame=frame.’;
%ajustement de puissance
P=(1/length(frame))*sum(frame.*conj(frame));
A_dB=Pa_db−(10*log10(P));
A=10^(A_dB/20);
frame=A*frame;

%% 2) Ajout du bruit
Pb_dbm=−100;
Pb_db=Pb_dbm−30;
Pb=10^(Pb_db/10);
%attenutaion
k_db=−60;
k=10^(k_db/20);
SNR=Pa_dbm−Pb_dbm;
b=complex((sqrt(Pb/2))*randn(1,length(frame)),(sqrt(Pb/2))*randn(1,length(frame)));
RSB=k_db+Pa_db−Pb_db;
1 2 / 3 / 2 1 1 0 : 2 7 P M /home/orimbato/TP_CNU/TP2_2_frame.m 2/2

x _ f r a m e = k * f r a m e + b ; %frame avec bruit

%% 3) Démodulation
frame_y=zeros(Nu,Nt);

%% démoduler chaque symbole dans le frame

frame_x=reshape(x_frame,[N+Ng,Nt]);
for i=1:Nt
x=frame_x(:,i);
x=x.’;
% x:vecteur ligne, ind_freq : vecteur ligne
x_g=x(Ng+1:length(x)); %enlever CP
y=fft(x_g);
y_n=y(ind_freq);
frame_y(:,i)=y_n.’;
end

%% info_binaire/reconstitué
y_frame=frame_y/(A*k);
y_frame=y_frame(:);
scatterplot(y_frame),grid o n;

seq_est=qamdemod(y_frame,M);
seq_ent=qamdemod(data(:),M); %s/f matrice
[Nberreur,SER]=symerr(seq_ent,seq_est);
[Nberreur_bit,BER]=biterr(de2bi(seq_ent),de2bi(seq_est));
1 2 / 3 / 2 1 1 0 : 2 8 P M /home/orimbato/TP_CNU/OFDM_CTM.m 1/2

%demodulation d’un symbole OFDM dans un CTM

close all;
clear;

%% parametres
B = 1 . 0 9 5 * 1 0 ^ 6 ; % bande occupée (−CP)
N = 1 2 8 ; % Nb de sous porteuses, ou FFT Size
S C S = 1 5 * 1 0 ^ 3 ; % espacement entre les sous porteuses
l = 2 ;%première indice de la fréquence active selon la figure 2
M = 4 ; % modulation QAM
Fs=1.92*10^6;
t=(0:N−1)/Fs;
rng(0);

%% canal
a=[0.04 −0.05 0.07 −0.21 −0.5 0.72 0.36 0 0.21 0.03 0.07]; %proakis a
b=[0.407 0.815 0.407]; %proakis b

%echos
rho=0.9*exp(1i*pi/4);
ao=1/sqrt(1+abs(rho)^2);
a1=rho/sqrt(1+abs(rho)^2);
echo=[ao a1];

%% 1) Symboles OFDM à la sortie du canal sans bruit

%% sous porteuses
C=(B/SCS)−1; % nb de sous porteuses actives, nb de symboles par slot
ind_freq=[l:round(C/2)+1 (N−(round(C/2)+1−l):N)]; % selon figure2 on a C/2 actives positives, 0 au
milieu, C/2 actives negatives

%% symboles aléatoires
seq_ent=randsrc(1,C,[0:M−1]);
d=qammod(seq_ent,M);

%%IFFT
e(ind_freq)=d; %mettre les symboles sur les porteuses actives; % add zeros
s=ifft(e);
Ts=1/Fs;
Tu=N*Ts;

%% Ajout du CP
Tg_long=16.67*10^−6;
Ng=round(Tg_long*Fs);
CP=s(N−Ng+1:N);

sg=[CP s];
rg=sg;
%rg=s; %sans CP
%% Canal
Cn=fft(a,N); % réponse fréquentielle du canal à écho
x=filter(a,1,rg);
%ajout du bruit

%% reception 1.
xg=x(length(CP)+1:length(x));
y=fft(xg);
y_1=y(ind_freq);
scatterplot(y_1),grid o n; %toutes infos sont perdues
1 2 / 3 / 2 1 1 0 : 2 8 P M /home/orimbato/TP_CNU/OFDM_CTM.m 2/2

%% egalisation
En=1./Cn;
zn=En.*y; %Egalisation
zn=zn(ind_freq);
scatterplot(zn),grid o n; % parfaitement reconstitué
1 2 / 3 / 2 1 1 0 : 0 1 P M /home/orimbato/TP_CNU_EXAM2020−2021/prog1.m 1/1

clear;
close all;
rng(0); %% génère toujour la meme séquence
%% paramètres
N = 1 0 0 0 ; %FFT Size
C = 7 0 0 ; % Sous porteuses actives
%Tu=(1/10^4);
Fs=10*10^6;
Ts=1/Fs;
l = 2 ; %indice après le DC
M = 1 6 ; % taille de la constellation
n=log2(M); %nombre de bit par symbole QAM
%% 0 Préliminaires
Tu=N*Ts;
delta_f=1/Tu;
Tg=Tu/10;
Ng=Tg/Ts;
N_ofdm=N+Ng;

%% indices de fréquence
ind_freq=[l:round(C/2)+1 (N−(round(C/2)+1−l):N)];
%bande de fréquence
B=C*(1/Tu);

%% symboles OFDM
% symboles QAM
e_b=randsrc(1,C,[0:M−1]);
d=qammod(e_b,M);

%ifft
e(ind_freq)=d; % entrée IFFT
s=ifft(e); %sortie IFFT

% ajout préfixe cyclique

CP=s(N−Ng+1:N); %+1 à cause de l’indice Matlab
sg=[CP s]; % symbole OFDM

%% puissance
P=(1/(N_ofdm))*sum(sg.*conj(sg));
%facteur d’amplitude
Pa_dbm=0;

A_dB=Pa_dbm−30−(10*log10(P));
A=10^(A_dB/20);

r g = A * s g ;%symboles avec puissances reglées

rg=transpose(rg);
verif_ofdm(rg,1,1);
1 2 / 3 / 2 1 1 0 : 0 1 P M /home/orimbato/TP_CNU_EXAM2020−2021/prog2.m 1/2

clear;
close all;
rng(0); %% génère toujour la meme séquence
%% paramètres
N = 1 0 0 0 ; %FFT Size
C = 7 0 0 ; % Sous porteuses actives
Nu=C;
%Tu=(1/10^4);
Fs=10*10^6;
Ts=1/Fs;
l = 2 ; %indice après le DC
M = 1 6 ; % taille de la constellation
n=log2(M); %nombre de bit par symbole QAM

Nt=7*20;
%% 0 Préliminaires
Tu=N*Ts;
delta_f=1/Tu;
Tg=Tu/10;
Ng=Tg/Ts;
N_ofdm=N+Ng;

%% indices de fréquence
ind_freq=[l:round(C/2)+1 (N−(round(C/2)+1−l):N)];
%bande de fréquence
B=C*(1/Tu);

%% génerer les symboles dk pour un frame

eb=randsrc(C,Nt,(0:M−1)); %matrice de Nu*Nt
data=qammod(eb,M);

%% frame OFDM
% on fait passer chaque colonne de
frame=zeros(N_ofdm,Nt);
e=zeros(1,N);
for i=1:Nt
d=data(:,i);
d=transpose(d);% ramener en ligne
e(ind_freq)=d; %entrée IFFT
s=ifft(e);
CP=s(N−Ng+1:N); %prefixe cyclique
sg=[CP s]; %vecteur ligne ajout préfixe cyclique=d1.’; %revenir en ligne
sg=transpose(sg);
frame(:,i)=sg;
end
frame=frame(:); % transformer en vecteur colonne

%% ajustement de puissance
P=(1/length(frame))*sum(frame.*conj(frame));

Pa_dbm=0;
Pa_db=Pa_dbm−30
A_dB=−(10*log10(P));
A=10^(A_dB/20);

frame=A*frame;
verif_ofdm(frame,2,1);
1 2 / 3 / 2 1 1 0 : 0 1 P M /home/orimbato/TP_CNU_EXAM2020−2021/prog2.m 2/2
1 2 / 3 / 2 1 1 0 : 0 0 P M /home/orimbato/TP_CNU_EXAM2020−2021/prog3.m 1/2

clear;
close all;
rng(0); %% génère toujour la meme séquence
%% paramètres
N = 1 0 0 0 ; %FFT Size
C = 7 0 0 ; % Sous porteuses actives
Nu=C;
%Tu=(1/10^4);
Fs=10*10^6;
Ts=1/Fs;
l = 2 ; %indice après le DC
M = 1 6 ; % taille de la constellation
n=log2(M); %nombre de bit par symbole QAM

Nt=7*20;
%% 0 Préliminaires
Tu=N*Ts;
delta_f=1/Tu;
Tg=Tu/10;
Ng=Tg/Ts;
N_ofdm=N+Ng;

%% indices de fréquence
ind_freq=[l:round(C/2)+1 (N−(round(C/2)+1−l):N)];
%bande de fréquence
B=C*(1/Tu);

%% génerer les symboles dk pour un frame

eb=randsrc(C,Nt,(0:M−1)); %matrice de Nu*Nt
data=qammod(eb,M);

%% frame OFDM
frame=zeros(N_ofdm,Nt);
e=zeros(1,N);
for i=1:Nt
d=data(:,i);
d=transpose(d);% ramener en ligne
e(ind_freq)=d; %entrée IFFT
s=ifft(e);
CP=s(N−Ng+1:N); %prefixe cyclique
sg=[CP s]; %vecteur ligne ajout préfixe cyclique;
sg=transpose(sg); %revenir en ligne
frame(:,i)=sg;
end
frame=frame(:); % transformer en vecteur colonne

%% ajustement de puissance
P=(1/length(frame))*sum(frame.*conj(frame));

Pa_dbm=0;
Pa_db=Pa_dbm−30;
A_dB=Pa_db−(10*log10(P));
A=10^(A_dB/20);

frame=A*frame;

%%a) Signal reçu

%atténuation k
k_db=−80;
k=10^(k_db/20);
1 2 / 3 / 2 1 1 0 : 0 0 P M /home/orimbato/TP_CNU_EXAM2020−2021/prog3.m 2/2

%puissance du bruit
Pb_dbm=−95;
Pb_db=Pb_dbm−30;
Pb=10^(Pb_db/10);

%bruit
b=complex((sqrt(Pb/2))*randn(1,length(frame)),(sqrt(Pb/2))*randn(1,length(frame)));
b=transpose(b); %vecteur colonne

%signal
x=k*frame+b;

verif_ofdm(x,3,1)

%% b) signal DSP signal

x_sans_bruit=k*frame;

[B,V]=pwelch(b,[256],[128],[1024],Fs,’centered’) ;

[X_sans_bruit,V2]=pwelch(x_sans_bruit,[256],[128],[1024],Fs,’centered’) ;
%
figure,
plot(V,10*log10(B)), grid o n, hold o n %V2 and V
plot(V2,10*log10(X_sans_bruit),’linewidth’,2),title("Spectres du signal et du bruit") ,
xlabel(’Hz’) ,
legend(’bruit’,’signal’)

SNR_th=((Pa_dbm−30)+k_db−(Pb_dbm−30))+10*log10(N)−10*log10(Nu); %RSBout=RSB*(N/Nu)
RSB=Pa*k/Pb;

%SNR_estim regarder courbe et faire la différence entre les 2

%% c)Démodulateur
frame_x=reshape(x,[N+Ng,Nt]); %pour avoir une matrice
frame_y=zeros(C,Nt);
for i=1:Nt
x=frame_x(:,i);
x_g=x(Ng+1:length(x)); %enlever CP
y=fft(x_g);
y_n=y(ind_freq);
frame_y(:,i)=y_n;
end
frame_y=frame_y/(A*k); %trame recue
yn=frame_y(:);
scatterplot(yn),grid o n, title(’Symboles QAM reconstitués’); %constellation

seq_est=qamdemod(yn,M); %matrice symbole reconstitué

seq=qamdemod(data(:),M); %car data est s/f matricielle

[Num,Rat]=symerr(seq,seq_est);
1 2 / 3 / 2 1 1 0 : 2 5 P M /home/orimbato/TP_CNU_EXAM2020−2021/prog4.m 1/1

%r_tot % recue apres trajet multiples

%canal donnée par la fonction signal_modeA
clear;
close all;

%% paramètres
N = 1 0 0 0 ; %FFT Size
C = 7 0 0 ; % Sous porteuses actives
Nu=C;
%Tu=(1/10^4);
Fs=10*10^6;
Ts=1/Fs;
l = 2 ; %indice après le DC
M = 1 6 ; % taille de la constellation
n=log2(M); %nombre de bit par symbole QAM

%Nt=7*20;
%% 0 Préliminaires
Tu=N*Ts;
delta_f=1/Tu;
Tg=Tu/10;
Ng=Tg/Ts;
N_ofdm=N+Ng;

%indice de fréquence
ind_freq=[l:round(C/2)+1 (N−(round(C/2)+1−l):N)];

%% canal et signal recu

load(’signal_modeA.mat’) ;

Cn=fft(canal,N);
En=1./Cn;
En=transpose(En); %car tout est en vecteur ligne ici
Nt=length(r_tot)/(N+Ng); %nombre de symbole OFDM

%% démodulation
frame_r_tot=reshape(r_tot,[N+Ng,Nt]); %pour avoir une matrice
frame_y=zeros(C,Nt);
x=0;
for i=1:Nt
x=frame_r_tot(:,i);
x=x(Ng+1:length(x)); %enlever CP
y=fft(x);

z=En.*y; % égalisation fréquentielle

y_n=z(ind_freq);
frame_y(:,i)=y_n;
end
yn=frame_y(:);
scatterplot(yn); %constellation
seq_est=qamdemod(yn,M); %matrice symbole reconstitué

%show_image(’image.jpg’,seq_est,M);