EL4005-1 Principios de Comunicaciones

Tarea n 3
Simulacin de un Sistema de Comunicacin Digital
en un canal AWGN

Integrantes:
-Csar Daz
-Esteban Montoya

Resultados

Modulacin BPSK

Figura 1.
Al comparar las curvas BER terica con simulada para la modulacin BPSK se obtuvo el grfico
mostrado en la figura 1 donde se aprecia que tienen un comportamiento similar sin embargo
cuando el SNR es mayor que 10dB comienzan a haber diferencias ms apreciables que para SNR
bajo 10 dB, lo cual indica que BPSK es una modulacin confiable para un canal con AWGN dada su
similitud

Modulacin QPSK

Figura 2.
Al comparar las curvas tericas y simuladas del BER para la modulacin QPSK se obtuvo el grfico
mostrado en la figura 2 donde se aprecia gran similitud entre ambas curvas lo que implica que esta
modulacin no se ve mayormente afectada por un canal con AWGN

Modulacin QAM

Figura 3.
En este caso la diferencia que se ve al comparar las curvas mostradas en la figura 3 es mucho
mayor a los casos antes vistos, esto se debe a que al agregar ruido gaussiano aditivo este tipo de
modulacin se ve mucho ms afectada que las anteriores y a que tericamente la probabilidad de
error de bit es baja.

Modulacin 16QAM

Figura 4.
Finalmente en el caso 16QAM se observa que la probabilidad de error es tan grande que es
despreciable el aporte del AWGN por los cual las curvas mostradas en la figura 4 son muy
similares.

Anexo
BPSK
SNR_db=-2:1:15;
SNR=10.^(SNR_db/10);
bits=100000;
BER=zeros(1,length(SNR_db)); %BER de la simulacin
for k=1:length(SNR)
x=(2*floor(2*rand(1,bits)))-1;
y=(sqrt(SNR(k))*x)+randn(1,bits);
BER(k)=length(find((y.*x)<0));
end
BER=BER/bits;
figure (1)
semilogy(SNR_db,BER,'r-<','linewidth',2.0);
hold on
semilogy(SNR_db,qfunc(sqrt(SNR)),'b-','linewidth',2.0); %BER terico
grid on
title('BER para Modulacin BPSK');
xlabel('E_b/N_0 [dB]');
ylabel('BER);
legend('Simulacin','Terica');

QPSK
SNR_db=-2:1:15;
SNR=10.^(SNR_db/10);
bits=100000;
BER=zeros(1,length(SNR_db)); %BER de la simulacin
Es=1; %Energa del simbolo
Eb=Es/2; %Energa por bit
BER_gray=zeros(size(SNR));
BER_teorico=zeros(size(SNR));
BER_teorico=0.5*erfc(sqrt(SNR)/sqrt(2)); %BER teorico
%Constelacin QPSK
Q_s=(1/sqrt(2))*[1+1j,-1+1j,-1-1j,1-1j];
for i=1:length(SNR)
N_error=0;
for h=1:bits
No=(1/sqrt(2))*(randn(1)+1j*randn(1)); %Generacin del ruido
r_n=unidrnd(length(Q_s));
Tx=Q_s(r_n); %Simbolos transmitidos
Rx=sqrt(SNR(i))*Tx+No; %Simbolos recibidos con ruido
%Anlisis de caso por caso entre simbolo enviado y detectado
if sign(real(Tx))==sign(real(Rx)) && sign(imag(Tx))==sign(imag(Rx))
N_error=N_error+0;
elseif sign(real(Tx))==sign(real(Rx)) && sign(imag(Tx))~=sign(imag(Rx))
N_error=N_error+1;
elseif sign(real(Tx))~=sign(real(Rx)) && sign(imag(Tx))==sign(imag(Rx))
N_error=N_error+1;
else
N_error=N_error+2;

end
end
BER_gray(i)=N_error/(2*bits);
end
figure (2)
semilogy(SNR_db,BER_gray,'r-<','linewidth',2)
hold on
semilogy(SNR_db,BER_teorico,'-b','linewidth',2)
grid on
title('BER para Modulacin QPSK');
xlabel('E_b/N_0 [dB]');
ylabel('Bit error rate');
legend('Simulacin','Terica');

MQAM
M=16;
k=log2(M);
bits=100000;
simbolos=bits/k;
hMod=modem.qammod(M); %Se crea el modulador M-QAM
hMod.InputType='Bit'; %Se aceptan bits como inputs
hMod.SymbolOrder='Gray';
hDemod=modem.qamdemod(hMod); %Se crea el demodulador M-QAM
x=randi([0 1],bits,1); %Arreglo de datos binarios aleatorios
tx=modulate(hMod,x); %onda transmitida (ya modulada)
SNR_db=-2:1:15;
SNR=10.^(SNR_db/10);
SNR_prima=SNR_db+10*log10(k); %SNR en el canal para M-QAM
rx=zeros(simbolos,length(SNR_prima)); %receptor
BER=zeros(length(SNR_prima),1);
for i=1:length(SNR_prima)
rx(:,i)=awgn(tx,SNR_prima(i),'measured'); %Se agrega el ruido AWGN
end
rx_demod=demodulate(hDemod,rx); %Demodulador
for i=1:length(SNR_prima)
[~,BER(i)]=biterr(x,rx_demod(:,i));
end
x=sqrt(3*k*SNR/(M-1));
BER_teorico=(4/k)*(1-1/sqrt(M))*(1/2)*erfc(x/sqrt(2)); %BER terico
figure(1)
semilogy(SNR_db,BER_teorico,'b-','linewidth',2);
hold on
semilogy(SNR_db,BER,'r-<','linewidth',2);
grid on;
title('BER para modulacin QAM');
xlabel('E_b/N_0 [dB]');
ylabel('BER');
legend('Terica','Simulacin');
axis([min(SNR_db) max(SNR_db) 1e-5 1])