1

Laboratorio 3 de Comunicaciones
Analgicas & Digitales.
Dayana Moreno Bedoya, Estudiante Ingeniera de Telecomunicaciones, Universidad
de Medelln.

Resumen
Este documento contiene la simulacin en matlab de un sistema de comunicaciones con interferencia
inter simblica (ISI) basado en modulacin de amplitud por cuadratura 4QAM y luego se aplica el
algoritmo de Viterbi para analizar y comparar las probabilidades de error.
Palabras Clave
Algoritmo de Viterbi, Interferencia Inter Simblica (ISI), QAM, Matlab, Sistema de Comunicacin.
I. INTRODUCCIN
uando smbolos consecutivos se transmiten sobre un canal por una modulacin lineal (tales como
ASK, QAM, etc.), la respuesta al impulso (o equivalentemente la respuesta en frecuencia) del
canal provoca que un smbolo transmitido se extienda en el dominio del tiempo. Esto causa
interferencia entre smbolos debido a que los smbolos transmitidos previamente afectan el smbolo
recibido actualmente, reduciendo as la tolerancia al ruido.

Para una decisin ptima de que smbolo fue transmitido realmente el Sr. Andrew J Viterbi describe
un esquema para reducir la complejidad a niveles ms manejables, el algoritmo de Viterbi
proporciona una manera eficaz de encontrar la secuencia de estados ms probables en el mximo
sentido de probabilidad a posteriori de un proceso que se supone es un proceso de Markov de tiempo
discreto de estados finitos. Tales procesos pueden ser subsumidos bajo el marco estadstico general
de la teora de decisin compuesta.

Simulacin de sistemas de comunicacin con ISI

Se busca simular un sistema de comunicaciones donde el canal discreto equivalente est dado por:
P[n] = [n] + 0.8 [n-1]
La salida del canal de comunicaciones sin ruido O[n], est dado por:

[] = P[k] + A [n k]
=0

Las observaciones ruidosas son:

q[n] = O[n] + W[n]

2
Donde W[n] son realizaciones de una variable aleatoria Gaussiana de media cero y varianza N0/2. A
partir de lo anterior se pide lo siguiente:

Simular un sistema de Comunicaciones con ISI

%Simulacion Canal ISI

clc
clear all
close all
N = 1000000;
Eb_N0_dB = 0:2:30; %Relacin Seal a Ruido
Alpha = [1+i 1-i -1+i -1-i];%Alfabeto 4QAM
Es = 2; % Energa de Smbolo
Eb = Es/2; %Energa de Bit
B(1)= 1+j;

randinf = randsrc (N,1,Alpha); %Matriz Aleatoria

info = [randinf [B(1); randinf(1:end-1)]];
p=[1; 0.8]; %Vector de modelo de canal
infonoiseless=info*p;
decoded = zeros(N,1);
for k = 1:length(Eb_N0_dB)
N0 = Eb/(10^(Eb_N0_dB(k)/10));
noisy = sqrt(N0/2)*randn(N,1) +i*sqrt(N0/2)*randn(N,1);
q = infonoiseless + noisy;
decoded(find(
decoded(find(
decoded(find(
decoded(find(

real(q)>=
real(q)>=
real(q)<=
real(q)<=

0
0
0
0

&
&
&
&

imag(q)>=
imag(q)<=
imag(q)>=
imag(q)<=

0))
0))
0))
0))

error(k)= sum(randinf~=decoded)/N;
end
%Grafico las probabilidades de error
figure
semilogy(Eb_N0_dB,error,'m.-');
hold on
grid on
legend('ISI 4QAM');
xlabel('Es/No, dB')
ylabel('Symbol Error Rate')
title('Error Probability Curve for 4-QAM ISI')

=
=
=
=

1 + i;
1 - i;
-1 + i;
-1 - i;

Fig.1. Curva de Error de Probabilidad ISI

El canal discreto equivalente es P[n], usar una constelacin 4QAM, el objetivo es simular el
comportamiento de la probabilidad de error empleando un decisor sin memoria (similar al
usado en la prctica anterior) y compararlo con un detector de secuencias de mxima
verosimilitud empleando el algoritmo de Viterbi.

%-----------------------Funcin Viterbi------------------------------%
function error = Viterbi(SNR,M)
Alpha = [1+j 1-j -1+j -1-j]; %Alfabeto 4QAM
rand_inf=randsrc(16,1,Alpha); %Smmbolos Aleatorios
p=[1; 0.8]; %Matriz del EDC
Es = 2; % Energa de simbolo 4QAM
Eb = 1; % Energa de Bit 4QAM
infomatrix=[rand_inf [1+j;rand_inf(1:end-1)]; 1+j rand_inf(end)];
Onoiseless=infomatrix * p; %Matriz de smbolos sin ruido
%Adicin del ruido
N0 = Eb/(10^(SNR/10));
noise = sqrt(N0/2)*randn(17,1) +i*sqrt(N0/2)*randn(17,1);
q= Onoiseless + noise;
%Viterbi
R1=(abs(q(1)-M(:,1))).^2;
R2=(abs(q(2)-M)).^2;
R3=(abs(q(3)-M)).^2;

4
R4=(abs(q(4)-M)).^2;
R5=(abs(q(5)-M)).^2;
R6=(abs(q(6)-M)).^2;
R7=(abs(q(7)-M)).^2;
R8=(abs(q(8)-M)).^2;
R9=(abs(q(9)-M)).^2;
R10=(abs(q(10)-M)).^2;
R11=(abs(q(11)-M)).^2;
R12=(abs(q(12)-M)).^2;
R13=(abs(q(13)-M)).^2;
R14=(abs(q(14)-M)).^2;
R15=(abs(q(15)-M)).^2;
R16=(abs(q(16)-M)).^2;
R17=(abs(q(17)-M)).^2;

%Clculo de mtricas por nodos

%Metrica1
Metrica(:,1) = R1;
a(:,1)= R1';
b(:,1)=ones(4,1);
%Metrica2
for ii=1:4
Metrica(:,ii) = R1 + R2(ii,:)';
end
[a(:,2) b(:,2)]=min(Metrica);
%Metrica3
for ii=1:4
Metrica(:,ii) = a(:,2) + R3(ii,:)';
end
[a(:,3) b(:,3)]=min(Metrica);
%Metrica4
for ii=1:4
Metrica(:,ii) = a(:,3) + R4(ii,:)';
end
[a(:,4) b(:,4)]=min(Metrica);
%Metrica5
for ii=1:4
Metrica(:,ii) = a(:,4) + R5(ii,:)';
end
[a(:,5) b(:,5)]=min(Metrica);
%Metrica6
for ii=1:4
Metrica(:,ii) = a(:,5) + R6(ii,:)';
end
[a(:,6) b(:,6)]=min(Metrica);
%Metrica7
for ii=1:4
Metrica(:,ii) = a(:,6) + R7(ii,:)';

5
end
[a(:,7) b(:,7)]=min(Metrica);
%Metrica8
for ii=1:4
Metrica(:,ii) = a(:,7) + R8(ii,:)';
end
[a(:,8) b(:,8)]=min(Metrica);
%Metrica8
for ii=1:4
Metrica(:,ii) = a(:,8) + R9(ii,:)';
end
[a(:,9) b(:,9)]=min(Metrica);
%Metrica10
for ii=1:4
Metrica(:,ii) = a(:,9) + R10(ii,:)';
end
[a(:,10) b(:,10)]=min(Metrica);
%Metrica11
for ii=1:4
Metrica(:,ii) = a(:,10) + R11(ii,:)';
end
[a(:,11) b(:,11)]=min(Metrica);
%Metrica12
for ii=1:4
Metrica(:,ii) = a(:,11) + R12(ii,:)';
end
[a(:,12) b(:,12)]=min(Metrica);
%Metrica13
for ii=1:4
Metrica(:,ii) = a(:,12) + R13(ii,:)';
end
[a(:,13) b(:,13)]=min(Metrica);
%Metrica14
for ii=1:4
Metrica(:,ii) = a(:,13) + R14(ii,:)';
end
[a(:,14) b(:,14)]=min(Metrica);
%Metrica15
for ii=1:4
Metrica(:,ii) = a(:,14) + R15(ii,:)';
end
[a(:,15) b(:,15)]=min(Metrica);
%Metrica16
for ii=1:4
Metrica(:,ii) = a(:,15) + R16(ii,:)';
end

6
[a(:,16) b(:,16)]=min(Metrica);
%Metrica17
for ii=1:4
Metrica(:,ii) = a(:,16) + R17(ii,:)';
end
[a(:,17) b(:,17)]=min(Metrica);
%Camino de menor mtrica acumulada
pos(18)=1;
for k=17:-1:2;
pos(k)=b(pos(k+1),k);
end
decoded=Alpha(pos(2:end));
error= sum(decoded(1:16).'~=rand_inf);

%-----------------------Programa Principal------------------------------%
%Algoritmo de Viterbi
clear all
close all
clc
Alpha = [1+j 1-j -1+j -1-j]; %alfabeto 4QAM
Eb_N0_dB = 0:2:20; %Relacion seal a ruido
N = 50000;
sym_error = 0; %Inicializar el error

for i=1:4
for j=1:4
M(i,j)= Alpha(i) + Alpha(j)*0.8;
end
end
for m = 1:length(Eb_N0_dB)
for k=1:N
error = Viterbi(Eb_N0_dB(m), M); %Llamo la funcion Viterbi
sym_error = sym_error + error;
end
errorsim(m) = sym_error/(16*N);
N0= 1/(10^(Eb_N0_dB(m)/10));
theory(m)= qfunc(2.66*(sqrt(2)/sqrt(N0))); %Viterbi Teorico
end
%Grafico las probabilidades de error
figure
semilogy(Eb_N0_dB,theory,'b.-');
hold on
semilogy(Eb_N0_dB,errorsim,'mx-');
grid on
axis([0 9 10^-20 1])

7
legend('Theory', 'Simulation');
xlabel('Es/No, dB')
ylabel('Symbol Error Rate')
title('Error Probability Curve for 4-QAM Viterbi')

Fig.2. Curva de Error de Probabilidad con Viterbi

Fig.3. Curva de Error de Probabilidad con Viterbi Simulada y Terica

8
II. CONCLUSIONES

Gracias a la simulacin de las curvas de error de probabilidad, es notable que cuando se

aplica Viterbi la probabilidad de error presente en un canal con interferencia inter simblica
disminuye notablemente.
Aunque el mtodo de Viterbi puede llegar a ser tedioso cuando se realiza tericamente,
matlab ofrece opciones que nos permiten iterar y acortar el proceso de ejecucin humana
de este mtodo, cabe mencionar que el procesamiento computacional requiere un tiempo
aproximado entre 10 y 15 minutos para hacer cada iteracin, dado el nmero tan grande
de muestras que se le asign al cdigo.
Se puede apreciar que Algoritmo de Viterbi permite la transmisin de datos segura a travs
de la correccin de errores y el mensaje original se puede recuperar con precisin y sin
ningn ruido.