%Program de simulare modelare/transmisie pe canal/demodulare pentru un

%semnal 32-PSK.alpha 0.5 Iordache Marius

clear all;
close all;

%*************************************************************************
****************************************
%modulatorul
%*************************************************************************
****************************************

%generarea datelor sau citire din 'inputdata.txt'

sprintf('\n+++++ Modulatorul: generarea datelor si modularea in BB +++++\n');

tipdata=input('\nAlegeti tipul de citire al datelor de intrare:\n1-din fisier de intrare;\n2-

generate aleator\n');
if tipdata==1,
N=input('\nNumarul de simboluri ');
elseif tipdata==2
N=input('\nNumarul de simboluri :');
else sprintf('\nAlegere incorecta. Sirul se va genera aleator\n');
N=input('\nNumarul de simboluri :');
end;

switch tipdata
case 1,
fid=fopen('inputdata.txt');
[y]=fscanf(fid,'%f');
x=reshape(y(1:5*N),5,N);
x=x';
st=fclose(fid);
case 2,
x=randint(N,5);
otherwise,
%sprintf('\nAlegere incorecta. Sirul se va genera aleator\n')
x=randint(N,5);
end

tempx=[];
for i=1:N,
temp(1:5)=x(i,1:5);
tempx(1+5*(i-1):5*i)=temp;
end;

figure(1), stem(tempx),title('Semnalul de date')

sprintf('Apasati orice tasta pentru a continua')
pause
close (figure(1))

k=3;
sprintf('\nSe vor introduce automat %i simboluri pentru sincronizarea de tact;se transmit
N+3=%i simboluri',k,(N+3))
x=[0,0,0,0,0;0,1,1,1,1;0,0,0,0,0;x]; %3, [1,j,1], simboluri pentru sincronizarea de tact

%generarea componentei in faza/cuadratura pentru constelatia in cod Gray

semnal=zeros(1,(N+k)); %semnal=[faza;cuadratura]

for i=1:(N+k),
if x(i,:)== [0,0,0,0,0],
semnal(i)=1;
end
if x(i,:)== [0,0,0,0,1],
semnal(i)=exp(j*2*pi/32);
end
if x(i,:)== [0,0,0,1,0],
semnal(i)=exp(j*2*2*pi/32);

end
if x(i,:)== [0,0,0,1,1],
semnal(i)=exp(j*3*2*pi/32);
end
if x(i,:)== [0,0,1,0,0],
semnal(i)=exp(j*4*2*pi/32);
end
if x(i,:)== [0,0,1,0,1],
semnal(i)=exp(j*5*2*pi/32);
end
if x(i,:)== [0,0,1,1,0],
semnal(i)=exp(j*6*2*pi/32);
%5
end
if x(i,:)== [0,0,1,1,1],
semnal(i)=exp(j*7*2*pi/32);
end

if x(i,:)== [0,1,0,0,0],
semnal(i)=exp(j*8*2*pi/32);
end
if x(i,:)== [0,1,0,0,1],
semnal(i)=exp(j*9*2*pi/32);
end
if x(i,:)== [0,1,0,1,0],
semnal(i)=exp(j*10*2*pi/32);
end
if x(i,:)== [0,1,0,1,1],
semnal(i)=exp(j*11*2*pi/32);
end
if x(i,:)== [0,1,1,0,0],
semnal(i)=exp(j*12*2*pi/32);
end
if x(i,:)== [0,1,1,0,1],
semnal(i)=exp(j*13*2*pi/32);
end
if x(i,:)== [0,1,1,1,0],
semnal(i)=exp(j*14*2*pi/32);
end
if x(i,:)== [0,1,1,1,1],
semnal(i)=exp(j*15*2*pi/32);
end
if x(i,:)== [1,0,0,0,0],
semnal(i)=exp(j*16*2*pi/32);
end
if x(i,:)== [1,0,0,0,1],
semnal(i)=exp(j*17*2*pi/32);
end
if x(i,:)== [1,0,0,1,0],
semnal(i)=exp(j*18*2*pi/32);
end
if x(i,:)== [1,0,0,1,1],
semnal(i)=exp(j*19*2*pi/32);
end
if x(i,:)== [1,0,1,0,0],
semnal(i)=exp(j*20*2*pi/32);
end
if x(i,:)== [1,0,1,0,1],
semnal(i)=exp(j*21*2*pi/32);
end
if x(i,:)== [1,0,1,1,0],
semnal(i)=exp(j*22*2*pi/32);
end
if x(i,:)== [1,0,1,1,1],
semnal(i)=exp(j*23*2*pi/32);
end
if x(i,:)== [1,1,0,0,0],
semnal(i)=exp(j*24*2*pi/32);
end
if x(i,:)== [1,1,0,0,1],
semnal(i)=exp(j*25*2*pi/32);
end
if x(i,:)== [1,1,0,1,0],
semnal(i)=exp(j*26*2*pi/32);
end
if x(i,:)== [1,1,0,1,1],
semnal(i)=exp(j*27*2*pi/32);
end
if x(i,:)== [1,1,1,0,0],
semnal(i)=exp(j*28*2*pi/32);
end
if x(i,:)== [1,1,1,0,1],
semnal(i)=exp(j*29*2*pi/32);
end
if x(i,:)== [1,1,1,1,0],
semnal(i)=exp(j*30*2*pi/32);
end
if x(i,:)== [1,1,1,1,1],
semnal(i)=exp(j*31*pi/32);
end
 end

figure(1),subplot(2,1,1), stem(real(semnal)), title('Realul din formula exp(j*k*2*pi/32), unde

k=1,...32. Primii 3 sunt cei de sincronizare')
subplot(2,1,2), stem(imag(semnal)), title('Imaginarul din formula exp(j*k*2*pi/32),
unde k=1,...,32. Primii 3 sunt cei de sincronizare'),scatterplot(semnal), title('Constelatia de
semnal') %constelatia generata

sprintf('Apasati orice tasta pentru a genera semnalul purtator SSRC(radical din cosinus-
ridicat) si semnalul modulat BB(banda de baza)')
pause
close (figure(1))
close (figure(2))

%generarea semnalului radical din cosinus ridicat

ratabit=input('\nIntroduceti rata de esantionare :');
alpha=0.6; %roll-off factor
rata=5*ratabit %a unui simbol, pentru 3biti(=1 simbol)*ratabit=numarul de biti pentru 1
simbol
Tb=1; %perioada de bit
T=5*Tb; %perioada de simbol, T=Ts=3Tb
pas=T/rata; %perioada de simbol/numarul de biti pentru 1 simbol
p=5; %g trunchiat la 2p perioade de simbol, (-pTs,pTs);va rezulta la decodare rc
trunchiat la (-2pTs,2pTs)
t=[-p*T+pas:pas:p*T];
g=4*alpha*(cos((1+alpha)*pi*t/T)+pi*(1-alpha)*sinc((1-alpha)*t/T)/(4*alpha))./
(pi*sqrt(T)*(1-16*alpha*alpha*t.*t/(T*T)));
figure(2),stem(t/T,g),title('Semnalul purtator radical din cosinus ridicat'),grid
sprintf('Apasati orice tasta pentru a continua')
pause
close (figure(2))

%modularea

%2p-1 deoarece se merge din 2p in 2p pentru fiecare simbol, iar -1

%pentru ca se merge de la 0 la N+k-1, nu de la 1 la N+k
m=zeros(1,(N+k+2*p-1)*rata); %m=[fazamod;cuadraturamod]
%se introduce o intarziere suplimentara de 3T (corespunde
%semnalului de sincronizare)
for i=1:(N+k), %i din simbol in simbol

m((1+rata*(i-1)):(rata*(2*p+i-1)))=m((1+rata*(i-1)):(rata*(2*p+i-1)))+semnal(i)*g;
end
sprintf('\nNumarul de perioade de simbol pentru reprezentarea semnalului modulat(maxim
%i):',(k+N+2*p-1))
n=input('');
%figure(2), subplot(2,1,1), stem([2*p:n-2*p+2*p], real(semnal)), grid
% hold on
figure(2), subplot(2,1,1),
plot([1:n*rata]/rata,real(m(1:(n*rata))),'r')
 hold off

%figure(2), subplot(2,1,2), stem([p:n-p], imag(semnal)), grid

% hold on
figure(2), subplot(2,1,2), plot([1:n*rata]/rata),grid
imag(m(1:(n*rata)));
hold off

figure(3),subplot(2,1,1),plot([1:n*rata]/rata,real(m(1:(n*rata))),'b'),title('Realul semnalului
modulat'),grid
hold on
figure(3),subplot(2,1,2),plot([1:n*rata]/rata,imag(m(1:(n*rata))),'b'),title('Imaginarul
semnalului modulat'),grid
hold on
sprintf('Apasati orice tasta pentru a continua')
pause

%*************************************************************************
************************************
%modelarea canalului
%*************************************************************************
************************************
sprintf('\n+++++ Canalul: efectul asupra datelor +++++\n');
display('Canalul de transmisiune')
tipdata=input('\nAlegeti tipul de zgomot:\n1-fara zgomot\n2-din fisierul de intrare
"noise.txt";\n3-AWGN;\n');
switch tipdata
case 1,
mnoisy=m;
case 2,
fid=fopen('noise.txt','r+');
[yn]=fread(fid,'float');
mnoisy=m'+yn(1:2:(2*length(m)-1))+j*yn(2:2:2*length(m));
mnoisy=mnoisy';
st=fclose(fid);
case 3,
SNR=input('Introduceti SNR(dB)=')
q=0;
for i=1:length(m)
q=q+(abs(m(i)))^2;

end
sigma2=q*(10^(-SNR/10))/length(m);
mnoisy=m+sigma2*randn(size(m))+j*sigma2*randn(size(m));
otherwise,
sprintf('\nAlegere incorecta. Se va considera cazul fara zgomot');
mnoisy=m;
end

figure(3),subplot(2,1,1),plot([1:n*rata]/rata,real(mnoisy(1:(n*rata))),'r'),title('Faza modulata
afectata de zgomot')
%title('Realul semnalului modulat. Albastru semnalul fara zgomot, Rosu semnalul afectat de
zgomot')
hold off
figure(3),subplot(2,1,2),plot([1:n*rata]/rata,imag(mnoisy(1:(n*rata))),'r'),title('Cuadratura
modulata afectata de zgomot')
hold off
sprintf('Apasati orice tasta pentru a continua')
pause
%close (figure(3))

%*************************************************************************
****************
%demodulatorul
%*************************************************************************
****************
sprintf('\n+++++ Demodulatorul: recuperarea datelor +++++\n');

mrec=conv([g(length(g)),g],mnoisy)*T/rata; % filtrarea sgn receptionat cu srrc=>rc

%figure(4),subplot(2,1,1),stem([1:length(mrec)]/rata,real(mrec)),title('Realul semnalului
filtrat (albastru), cu rosu semnalul real'),grid
%hold on
%figure(4), subplot(2,1,1), stem([2*p:n-2*p+2*p], real(semnal), 'r'),
%grid
%hold off
%figure(4),subplot(2,1,2),stem([1:length(mrec)]/rata,imag(mrec)),title('Imaginarul semnalului
filtrat (albastru), cu rosu semnalul real'),grid
hold on
%figure(4), subplot(2,1,2), stem([2*p:n-2*p+2*p], imag(semnal), 'r'),
%grid
%hold off
figure(4),subplot(2,1,1),stem([1:length(mrec)]/rata,real(mrec)),grid,title('Faza filtrata')
figure(4),subplot(2,1,2),stem([1:length(mrec)]/rata,imag(mrec)),grid,title('Cuadratura filtrata')

rc=conv([g(length(g)),g],g)*T/rata;
figure(5),stem([1:length(rc)]/rata,rc),title('Semnalul cosinus ridicat'),grid

%sincronizarea
tipdata=input('Alegei:\n1-sincronizare ideala;\n2-circuit de sincronizare:\n');

mdemod=[1,j,1];
switch tipdata

case 1,
rataest=rata; %rata estimata
Nest=N; %N estimat
for i=(k+1):(Nest+k)

mdemod=[mdemod,(mrec(rataest*(2*p+i-1))-mdemod(i-3)*rc((2*p+3)*rataest)-mdemod(i-
2)*rc((2*p+2)*rataest)-mdemod(i-1)*rc((2*p+1)*rataest))];
end

case 2,
 %se aplica criteriul MP tinandu-se cont de faptul ca semnalul este
%codat Gray
i1=1;
while abs(real(mrec(i1))-1)>=0.1
i1=i1+1;
end
%i1 %aprox.primul maxim din comp.faza

i2=1;
while abs(imag(mrec(i2))-1)>=0.1
i2=i2+1;
end
%i2 %aprox.primul maxim din
comp.cuadratura

rataest=i2-i1;
int=round(rataest/5);

[m1,i11]=min(abs(real(mrec((i1-int):(i1+int)))-1));
%prima val aprox=1 din comp.faza
[m2,i21]=min(abs(imag(mrec((i2-int):(i2+int)))-1));
%primul maxim din comp.cuadratura
i1=i1-int+i11-1;
i2=i2-int+i21-1;
rataest=i2-i1;
int=floor(rataest/5);

[m3,i31]=min(abs(real(mrec((i2-int):(i2+int)))));
%primul min de dupa primul max din comp.faza
[m4,i41]=min(abs(imag(mrec((i1-int):(i1+int)))));
%ultimul min de dinainte de primul max din comp.cuadratura
i3=i2-int+i31-1;
i4=i1-int+i41-1;
rataest=floor((i2-i1+i3-i4)/2);
ratabit_est=floor(rataest/3)
rataest=ratabit_est*3;

%esantionarea la momentul optim pentru detectia de

prag
count=(2*p+k)*rataest;
while count<=(length(mrec)-2*p*rataest+1)

mdemod=[mdemod,(mrec(count)-mdemod(length(mdemod)-2)*rc((2*p+3)*rataest)-
mdemod(length(mdemod)-1)*rc((2*p+2)*rataest)-
mdemod(length(mdemod))*rc((2*p+1)*rataest))];
count=count+rataest;
end
Nest=count/rataest-k-2*p

end

%detectia de prag
close(figure(5))
figure(5), scatterplot(mdemod)
xest=zeros((Nest+k),5); %decodarea:xest este secventa binara recuperata
unghiest=round((angle(mdemod))/(2*pi/32));
for i=1:(Nest+k)
if unghiest(i)==0,
xest(i,:)= [0,0,0,0,0];
elseif unghiest(i)==1,
xest(i,:)= [0,0,0,0,1];
elseif unghiest(i)==2,
xest(i,:)= [0,0,0,1,0];
elseif unghiest(i)==3,
xest(i,:)= [0,0,0,1,1];
elseif unghiest(i)==4,
xest(i,:)= [0,0,1,0,0];
elseif unghiest(i)==5,
xest(i,:)= [0,0,1,0,1];
elseif unghiest(i)==6,
xest(i,:)= [0,0,1,1,0];
elseif unghiest(i)==7,
xest(i,:)= [0,0,1,1,1];
elseif abs(unghiest(i))==8,
xest(i,:)= [0,1,0,0,0];
elseif unghiest(i)==9,
xest(i,:)= [0,1,0,0,1];
elseif unghiest(i)==10,
xest(i,:)= [0,1,0,1,0];
elseif unghiest(i)==11,
xest(i,:)= [0,1,0,1,1];
elseif unghiest(i)==12,
xest(i,:)= [0,1,1,0,0];
elseif unghiest(i)==13,
xest(i,:)= [0,1,1,0,1];
elseif unghiest(i)==14,
xest(i,:)= [0,1,1,1,0];
elseif unghiest(i)==15,
xest(i,:)= [0,1,1,1,1];
elseif unghiest(i)==-15,
xest(i,:)= [1,0,0,0,0];
elseif abs(unghiest(i))==-14,
xest(i,:)= [1,0,0,0,1];
elseif unghiest(i)==-13,
xest(i,:)= [1,0,0,1,0];
elseif unghiest(i)==-12,
xest(i,:)= [1,0,0,1,1];
elseif unghiest(i)==-11,
xest(i,:)= [1,0,1,0,0];
elseif unghiest(i)==-10,
xest(i,:)= [1,0,1,0,1];
elseif unghiest(i)==-9,
xest(i,:)= [1,0,1,1,0];
elseif unghiest(i)==-8,
xest(i,:)= [1,0,1,1,1];
 elseif unghiest(i)==-7,
xest(i,:)= [1,1,0,0,0];
elseif unghiest(i)==-6,
xest(i,:)= [1,1,0,0,1];
elseif unghiest(i)==-5,
xest(i,:)= [1,1,0,1,0];
elseif unghiest(i)==-4,
xest(i,:)= [1,1,0,1,1];
elseif unghiest(i)==-3,
xest(i,:)= [1,1,1,0,0];
elseif unghiest(i)==-2,
xest(i,:)= [1,1,1,0,1];
elseif unghiest(i)==-1,
xest(i,:)= [1,1,1,1,0];
elseif unghiest(i)==0,
xest(i,:)= [1,1,1,1,1];

end
end

tempx=[];
for i=1:N,
temp(1:5)=x(i,1:5);
tempx(1+5*(i-1):5*i)=temp;
end;

tempxest=[];
for i=1:Nest,
temp(1:5)=xest(i,1:5);
tempxest(1+5*(i-1):5*i)=temp;
end;

figure(6), subplot(2,1,1), stem(tempx),title('Semnalul binar de date (albastru transmis, rosu

receptionat)')
subplot(2,1,2), stem(tempxest,'r')

%*************************************************************************
********************
%numaratorul de erori
%*************************************************************************
********************
Nmin=min(N,Nest);
[nerr,Perr]=biterr(x((k+1):(Nmin+k),:),xest((k+1):(Nmin+k),:))

1.Introducere Teoretica

1.1. Schema bloc a simulatorului

Simulatorul se referă la un semnal modulat 32PSK, cu cosinus ridicat, cu
coeficientul   0.5 şi rata de vizualizare   5Tb ,100Tb  .

date x(t) 1 K1 date

MOD DEMOD EVALUARE
2 estimate REZULTAT

+
n(t)
AFISARE

Fig. 1.1 Schema bloc a simulatorului

1.2.Explicarea schemei bloc a simulatorului

Semnalele
date – datele generate folosind codul Gray
x(t) – semnalul modulat
date estimate – la ieşirea din demodulator
n(t) – zgomotul de tip ZAGA (alb, gaussian, aditiv, de medie nulă).

Blocurile principale
MOD - modulatorul
DEMOD – demodulatorul
EVALUARE REZULTAT + AFISARE – poate furniza şi numărul de erori

Comutatorul K1
K1 => 1 – simulare în absenţa zgomotului
K1 => 2 – simulare în prezenţa zgomotului (simulează canalul real cu
erori)

2.Modulatorul
2.1.Schema bloc a modulatorului
 I t
m
Ts
aIn
n g(t)
Tb Ts
+ x(t)
S/P MOD
{an} DECOD 
NUM
4 -
g(t)
aQn
m
Qt

Fig. 2.1 Schema bloc a modulatorului

2.2 Explicarea schemei
Semnalele
{an} – date seriale binare, date de intrare în simulator
Tb – perioada de bit
n – faza ce corespunde unei combinaţii de 5 biţi de la intrare
2
n  n , n   0,31
32
Ts – perioada de simbol Ts =5Tb
aIn, aQn – semnalele modulate numeric
aIn  cos n 
aQn  sin n 
Blocurile
S/P – convertor serie/paralel
DECOD – decodificator atribuie unui cuvânt de la intrare o anumită fază.
MOD NUM – modulaţie numerică
g(t) – realizează filtrarea (se lucrează cu pas de eşantionare fix, ceea ce
implică un timp de simulare mai mare). Filtrarea se implementează cu o
convoluţie cu funcţia pondere. Funcţia g(t) este impulsul radical din
cosinus ridicat, având expresia de mai jos.
cos1   t / TS   sin1   t / TS  4t / TS 
1
g t   4

 TS 1  16 2t 2 / TS 
3.Demodulatorul
 3.1.Schema bloc a demodulatorului

^
aIn
FTJ
mI(t)+… ^
k
x(t)

y(t)=x(t)+n(t)

mQ(t)+…
FTJ
^
aQn

Fig. 3.1.Schema bloc a demodulatorului

3.2.Explicarea schemei
x(t) – semnalul modulat
y(t) - semnalul modulat plus zgomotul (ZAGA)
Simulatorul permite realizarea demodulării în cazul unui canal ideal (fără
zgomot) sau în cazul unui canal real (cu zgomot)
Prin înmulţirea cu cos(ct), sin(ct) separ componentele în fază şi în
cuadratură. Apoi trec printr-un filtru adaptat impulsului şi eşantionez (de
fapt eşantionez un semnal gata eşantionat, ceea ce înseamnă decimare sau
interpolare). Pe o perioadă de simbol este necesar un singur simbol pentru
detecţia datelor. Acesta trebuie selectat la momentul optim (sau îl generez
prin interpolare). Urmează o estimare a lui aIn, aQn , o detecţie de prag (o
regiune de decizie). Faza semnalului recepţionat o evaluez cu un
^
^ aQn
  ^
comparator de fază. n  arctg ^      aIn 
aIn  

Decizia
 ^ ^
Dacă n   n  n   n  n 2
2  2  după decizie.
4 4 4 4 4
Asociez valoarea de mai sus pentru tot domeniul haşurat.

Im{m(t)}

Re{m(t)}

Fig. 3.2.Decizia

In continuare se va incerca o simulare pentru o serie de date introduse de la tastatura:

Se alege generarea aleatoare a datelor(2)
Numarul de simboluri 30.
Rata de esantionare:25
Numarul de perioade de esantionare:25
aleg tipul de zgomot AWGN,RSZ 15dB

Semnalul este afectatde zgomot:

Aleg in continuare circuit de sincronizare ideala:
Se obtine in final:

nerr =

19

Perr =

0.1267

Psk este un proces de modulare prin intermediul careia semnalul de intrare,sub forma
binara,shifteaza faza la iesire la una determinata de un numar fix.Semnalul poate fii scris sub
forma:

Vo(t) = .2S Sin [.ot + ]

i = 1, 2,... M
-Ts/2 . t . Ts/2

unde S este nivelul mediu de putere, M= 2 N

N este numarul de biti necesari pentru a cuantiza M

Mai jos este prezentata o varianta de principiu a demodulatorului PSK:

Jos este prezentata variatia functiei de transfer H(jf) si dependenta de 

O performanta a demodulatorului o constitue rata erorii de bit(bit error rate) care este definita ca
BER = NE/NT, fiind definita ca complementara functiei de eroare.Tinand cont si de zgomotul total
se poate estima eroarea.

Schema tipica pentru masurarea erorii este:

Modulare:
Principala metoda de evaluare a unei transmisiuni digitale o constitue masurarii erorii de
bit ,ceea ce este de fapt o ratie a numarului de biti receptionati eronati in raport cu toti bitii
trimisi.
Cand se vorbeste despre eroarea debit trebuie luate in considerare doua tipuri de semnal:
-cel codat ,in care numai bitii curenti sunt importanti,putandu-se accepta oeroare de bit mare
atata timp cat informatia poate fii decodata.Rata de eroare de bit informational este mai mica
decat cea a semnalului codat adica:
 BERbit inf ormatie  BERbiticodati
-semnal necodat,neexistand codare astfel incat toti bitii sunt importanti.
Atata timp cat semnalele sunt codata trebuie facuta diferenta intre eroarea de bit a semnalului
receptionat codat sau eroarea bitilor de informatie.

In continuare voi prezenta o caracterizare teoretica a senmnalului binar afectat de

zgomot.Graficele arata aceleasi trasaturi ca in cazul simularii cerute:

Transmisiune digitala neafectata de zgomot.

Transmisiune afectata de zgomot(zgomotul este considerat a fi aleator)

Efectul zgomotului asupra unui simbol este evidentiat in figurile urmatoare:

.
In fugura de mai sus observam 2 simboluri,un 0 si un 1 cu forma transmisa si cu rezultatul
obtinut in urma adaugarii zgomotului aleator.
 In figura de mai sus simbolurile ajung sub diferite forme de distorsiune la receptor.Prin
compararea amplitudinii receptorul ia decizia.
Schema de mai jos reprezinta metoda de baza a evaluarii erorii:

Se mai poate face si o comparatie referitoare la eroarea de bit in functie de diferitele tipuri de
modulatie PSK: