Interconexión Entre Sistemas Móviles de 3ª Generación VI

Interconexión Entre Sistemas Móviles de 3ª Generación
VI. ANEXOS
VI-1. Códigos Matlab
En este segundo anexo se incluye todos los códigos Matlab que han sido utilizados
para obtener las simulaciones mostradas en este proyecto. Estos códigos son casos
particulares de algunas de esas simulaciones, ya que los valores que vienen indicados en
los mismos han sido variados en sucesivas ejecuciones de los ficheros de Matlab, con
objeto de obtener las distintas simulaciones (distintos números de usuarios, valores de
K, número de subportadoras,…) que son comentadas en este proyecto.
En las simulaciones hemos usado dos tipos de códigos ortogonales, los de
Hadamard y los OVSF, por tanto separaremos los distintos archivos de Matlab que usan
cada uno de estos códigos. Finalmente mostraremos el archivo de Matlab donde se
realizan las simulaciones para las fórmulas teóricas que nos proporciona el artículo de
investigación y que han sido usadas para su comparación con las curvas prácticas.
Antes de empezar con los códigos mencionados anteriormente mostraremos la
función Matlab rician_generator, la cual nos genera N valores aleatorios que siguen
dicha distribución, que usamos para representar el canal de desvanecimiento Rician y
que es usada por la mayoría de las funciones Matlab que se verán más adelante.
Debemos decir que esta función también nos genera la distribución Rayleigh cuando
damos al factor de Rician (K) el valor cero.
%=========================================================
% Generador de la distribución Rician
% K= Factor de Rician
%=========================================================
function rician=rician_generator(N_samples,K)
Noise=randn(2,N_samples);
mean_y=sqrt(2*K);
Noise(2,:)=Noise(2,:)+mean_y;
rician_temp=sqrt(Noise(1,:).^2+Noise(2,:).^2);
rician=rician_temp;
VI. ANEXOS
87
Interconexión Entre Sistemas Móviles de 3ª Generación
VI-1.1. Códigos Hadamard
function ber_snr_egc
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%% REPRESENTACION BER RESPECTO A SNR %%%%%%%%%%%%%%%
%%%%%%%%%%%% USANDO RECEPTOR EGC %%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
close all
clear all
N=16;
M=1e4;
K=2;
U=2;
H=hadamard(N);
%
%
%
%
Numero de portadoras ortogonales
Numero de datos (bits) por usuario
Elegimos Factor de Rician
Elegimos Numero de usuarios
% Generamos matriz de codigos hadamard (ortogonales)
%----- Usuario 1 -----------------------------------------------------datos1=sign(randn(1,M));
cod1=H(1,:);
del usuario 1
% Generamos vector de datos del usuario 1
% Cogemos la primera fila de matriz de hadamard como codigo
fading1=rician_generator(N,K);
siguen una distribucion de Rician
% Generamos un vector de numeros aleatorios que
codyric1=cod1.*fading1;
% Multiplico cada chip del codigo por el
desvanecimiento de la rama correspondiente
datos1c=datos1';
matrix=datos1c*codyric1;
multiplicado por el codigo
vect_s1=zeros(1,(N*M));
% Ponemos los datos como vector columna
% Cada fila de esta matriz tiene un dato de usuario
% Vector con los datos transmitidos
i=1;
for k=1:M
fila=matrix(k,:);
s1=ifft(fila);
for n=1:N
% Vector s1 posee N elementos
vect_s1(i)=s1(n);
i=i+1;
end
end
VI. ANEXOS
88
Interconexión Entre Sistemas Móviles de 3ª Generación
%-----Otros Usuarios -----------------------------------------------------for u=2:1:U
datos_u=sign(randn(1,M));
% Generamos vector de datos del usuario u
cod_u=H(u,:);
% Cogemos la segunda fila de matriz de hadamard como
codigo del usuario u
fading_u=rician_generator(N,K);
que siguen una distribucion de Rician
% Generamos un vector de numeros aleatorios
codyric_u=cod_u.*fading_u;
% Multiplico cada chip del codigo por el
desvanecimiento de la rama correspondiente
datos_uc=datos_u';
% Ponemos los datos como vector columna
matrix_u=datos_uc*codyric_u;
% Cada fila de esta matriz tiene un dato de
usuario multiplicado por el codigo
vect_s_u=zeros(1,(N*M));
vect_s_int=zeros(1,(N*M));
usuarios interferentes
% Vector con los datos transmitidos por usuario u
% Vector con los datos transmitidos por todos los
i=1;
for k=1:M
fila_u=matrix_u(k,:);
s_u=ifft(fila_u);
for n=1:N
% Vector s_u posee N elementos
vect_s_u(i)=s_u(n);
i=i+1;
end
end
vect_s_int=vect_s_int+vect_s_u;
end
% Suma de los dos usuarios (lo que sale al canal)
vect_s=vect_s1+vect_s_int;
%---------------------RECEPTOR EGC (multiplico en el receptor solo por el codigo)---------------%-----------------USUARIO 1--------------------------------------------------------------------cod1=H(1,:);
% Codigo de usuario 1
recibido=zeros(1,N);
% Vector recibido a la entrada del receptor por cada simbolo
enviado (se va solapando con cada simbolo de N elementos que llega)
VI. ANEXOS
89
Interconexión Entre Sistemas Móviles de 3ª Generación
rx_sum=zeros(1,M);
receptor antes del detector
z=0;
% Vector de simbolos recibidos despues de la suma en el
% Inicilizamos indices
for k=1:M
for i=1:N
recibido(i)=vect_s(i+z);
end
rec=fft(recibido);
sum=rec*cod1';
rx_sum(k)=sum/N;
% Dividimos entre N porque estamos sumando N elementos y
queremos volver a tener potencia unidad como al principio
z=z+N;
end
%%%%%%%%%%%%%% RUIDO
for j=0:15
No=10^(-(j/10));
% Valores de Eb/No en dB (siendo Eb=1)
% Distintos valores para No en unidades naturales
ruido=sqrt(N*No/2)*randn(1,N*M);
señal de informacion(ver articulo))
% Ruido que llega al receptor (lo separamos de la
cod1=H(1,:);
% Codigo de usuario 1
ruido_simb=zeros(1,N);
% Vector de ruido recibido a la entrada del
receptor por cada simbolo enviado (se va solapando)
rx_ruido_sum=zeros(1,M);
receptor y antes del detector
z=0;
% Vector de ruido despues de la suma en el
% Inicilizamos indices
for k=1:M
for i=1:N
ruido_simb(i)=ruido(i+z);
end
rec_ruido=fft(ruido_simb);
sum_ruido=rec_ruido*cod1';
rx_ruido_sum(k)=sum_ruido/N;
% Dividimos entre N porque estamos sumando N
elementos y queremos volver a tener potencia No/2 como al principio
z=z+N;
VI. ANEXOS
90
Interconexión Entre Sistemas Móviles de 3ª Generación
end
%%%%%%%%%%%% DETECTOR
rec_total=rx_sum+real(rx_ruido_sum);
del ruido
det=sign(rec_total);
error=0;
% Sumamos informacion (es real) y parte real
% Vector detectado
% Contador de errores
for i=1:M
if datos1(i)~=det(i);
error=error+1;
% Hallamos el numero de errores
end
end
ber(j+1)=error/M;
% Promediamos el numero de errores
end
figure
EbNo=0:15;
semilogy(EbNo,ber);
% Dibujamos el eje ‘y’ en escala logaritmica
xlabel('Eb/No(dB)'),ylabel('BER');
grid
function ber_snr_mrc
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%% REPRESENTACION BER RESPECTO A SNR %%%%%%%%%%%%%%%
%%%%%%%%%%%% USANDO RECEPTOR MRC %%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
close all
clear all
N=16;
M=1e4;
K=2;
U=16;
H=hadamard(N);
% Numero de portadoras ortogonales
% Numero de datos (bits) por usuario
% Factor de Rician
% Numero de usuarios
% Generamos matriz de codigos hadamard (ortogonales)
%----- Usuario 1 ------------------------------------------------------
VI. ANEXOS
91
Interconexión Entre Sistemas Móviles de 3ª Generación
datos1=sign(randn(1,M));
cod1=H(1,:);
del usuario 1
% Generamos vector de datos del usuario 1
% Cogemos la primera fila de matriz de hadamard como codigo
fading1=rician_generator(N,K);
siguen una distribucion de Rician
% Generamos un vector de numeros aleatorios que
codyric1=cod1.*fading1;
% Multiplico cada chip del codigo por el
desvanecimiento de la rama correspondiente
datos1c=datos1';
% Ponemos los datos como vector columna
matrix=datos1c*codyric1;
multiplicado por el codigo
% Cada fila de esta matriz tiene un dato de usuario
vect_s1=zeros(1,(N*M));
% Vector con los datos transmitidos
i=1;
for k=1:M
fila=matrix(k,:);
s1=ifft(fila);
for n=1:N
% Vector s1 posee N elementos
vect_s1(i)=s1(n);
i=i+1;
end
end
%-----Otros Usuarios -----------------------------------------------------for u=2:1:U
datos_u=sign(randn(1,M));
cod_u=H(u,:);
como codigo de usuario u
% Generamos vector de datos del usuario u
% Cogemos la segunda fila de matriz de hadamard
fading_u=rician_generator(N,K);
que siguen una distribucion de Rician
% Generamos un vector de numeros aleatorios
codyric_u=cod_u.*fading_u;
desvanecimiento de la rama correspondiente
% Multiplico cada chip del codigo por el
datos_uc=datos_u';
matrix_u=datos_uc*codyric_u;
usuario multiplicado por el codigo
vect_s_u=zeros(1,(N*M));
vect_s_int=zeros(1,(N*M));
los usuarios interferentes
VI. ANEXOS
% Ponemos los datos como vector columna
% Cada fila de esta matriz tiene un dato de
% Vector con los datos transmitidos por usuario
% Vector con los datos transmitidos por todos
92
Interconexión Entre Sistemas Móviles de 3ª Generación
i=1;
for k=1:M
fila_u=matrix_u(k,:);
s_u=ifft(fila_u);
for n=1:N
% Vector s_u posee N elementos
vect_s_u(i)=s_u(n);
i=i+1;
end
end
vect_s_int=vect_s_int+vect_s_u;
end
% Suma de los dos usuarios (lo que sale al canal)
vect_s=vect_s1+vect_s_int;
%---------------------RECEPTOR MRC (multiplico en el receptor por el codigo y por el
desvanecimiento correspondiente de cada rama)
%-----------------USUARIO 1--------------------------------------------------------------------%cod1=H(1,:);
% Codigo de usario 1
recibido=zeros(1,N);
% Vector recibido a la entrada del receptor por cada
simbolo enviado (se va solapando con cada simbolo de N elementos que llega)
rx_sum=zeros(1,M);
el receptor antes del detector
z=0;
% Vector de simbolos recibidos despues de la suma en
% Inicilizamos indices
for k=1:M
for i=1:N
recibido(i)=vect_s(i+z);
end
rec=fft(recibido);
sum=rec*codyric1';
rx_sum(k)=sum/N;
% Dividimos entre N porque estamos sumando N
elementos y queremos volver a tener potencia unidad como al principio
z=z+N;
VI. ANEXOS
93
Interconexión Entre Sistemas Móviles de 3ª Generación
end
%%%%%%%%%%%%% RUIDO
for j=0:15
No=10^(-(j/10));
% Valores de Eb/No en dB (siendo Eb=1)
% Distintos valores para No en unidades naturales
ruido=sqrt(N*No/2)*randn(1,N*M);
señal de informacion(ver articulo))
cod1=H(1,:);
% Ruido que llega al receptor (lo separamos de la
% Codigo de usuario 1
ruido_simb=zeros(1,N);
% Vector de ruido recibido a la entrada del receptor
por cada simbolo enviado (se va solapando)
rx_ruido_sum=zeros(1,M);
receptor y antes del detector
z=0;
% Vector de ruido despues de la suma en el
% Inicilizamos indices
for k=1:M
for i=1:N
ruido_simb(i)=ruido(i+z);
end
rec_ruido=fft(ruido_simb);
sum_ruido=rec_ruido*codyric1';
rx_ruido_sum(k)=sum_ruido/N;
% Dividimos entre N porque estamos sumando N
elementos y queremos volver a tener potencia No/2 como al principio
z=z+N;
end
%%%%%%%%%%%% DETECTOR
rec_total=rx_sum+real(rx_ruido_sum);
del ruido
% Sumamos informacion (es real) y parte real
det=sign(rec_total);
% Vector detectado
error=0;
% Contador de errores
for i=1:M
if datos1(i)~=det(i);
error=error+1;
VI. ANEXOS
%Hallamos el numero de errores
94
Interconexión Entre Sistemas Móviles de 3ª Generación
end
end
ber(j+1)=error/M;
% Promediamos el numero de errores
end
figure
EbNo=0:15;
semilogy(EbNo,ber);
% Dibujamos el eje ‘y’ en escala logaritmica
xlabel('Eb/No(dB)'),ylabel('BER');
grid
Como podemos observar estas dos últimas funciones (function ber_snr_egc y
function ber_snr_mrc) son muy parecidas y solo varían en la parte del receptor. A
continuación se representará la función Matlab ber_us_egc_k_reg donde representamos
la variación de la BER a medida que aumentamos el número de usuarios, para una SNR
fija y para distintos valores del factor de Rician K, usando un receptor EGC. La función
ber_us_mrc_k_reg representa lo mismo para un receptor MRC y no la mostraremos ya
que es similar a la anterior variando simplemente en el receptor de la misma forma que
vimos que variaba en function ber_snr_mrc respecto a function ber_snr_egc.
function ber_us_egc_k_reg
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%% MULTIPLES USUARIOS %%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%% MULTIPLES FACTORES K %%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%% RECEPTOR EGC %%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
close all
clear all
N=16;
U=16;
numero de subportadoras)
% Numero de subportadoras ortogonales
% Numero de usuarios (tiene que ser menor o igual que el
M=1e4;
c=['b','g','r','c','k'];
% Numero de datos (bits) por usuario
% Vector de colores
H=hadamard(N);
para cada usuario
% Generamos matriz de codigos hadamard (ortogonales), uno
VI. ANEXOS
95
Interconexión Entre Sistemas Móviles de 3ª Generación
y=1;
% Indice del vector de colores
figure
for K=0:2:8
% Factor K de la distribucion de Rician
vect_s=zeros(1,(N*M));
susarios)
% Vector con los datos transmitidos totales (los U
%----- Usuarios desde 1 a U -----------------------------------------------------for u=1:U
datos=sign(randn(1,M));
% Generamos vector de datos del usuario u
cod=H(u,:);
codigo de usuario u
% Cogemos la fila u de la matriz de hadamard como
fading=rician_generator(N,K);
siguen una distribucion de Rician
% Generamos un vector de numeros aleatorios que
codyric=cod.*fading;
% Multiplico cada chip del codigo por el
desvanecimiento de la rama correspondiente
datosc=datos';
% Ponemos los datos como vector columna
matrix=datosc*codyric;
multiplicado por el codigo
% Cada fila de esta matriz tiene un dato de usuario
vect_s_u=zeros(1,(N*M));
% Vector con los datos transmitidos de cada usuario
i=1;
for k=1:M
fila=matrix(k,:);
s_u=ifft(fila);
for n=1:N
% Vector s_u posee N elementos
vect_s_u(i)=s_u(n);
i=i+1;
end
end
if u==1
datos1=datos;
detector
cod1=cod;
% Guardo los datos del usuario 1 para luego usarlo en el
% Guardo el codigo del usuario 1 para el receptor EGC
end
% Suma de los usuarios (lo que sale al canal)
VI. ANEXOS
96
Interconexión Entre Sistemas Móviles de 3ª Generación
vect_s=vect_s+vect_s_u;
%---------------------RECEPTOR EGC (multiplico en el receptor por el codigo)
%-----------------USUARIO 1--------------------------------------------------------------------recibido=zeros(1,N);
% Vector recibido a la entrada del receptor por cada simbolo
enviado (se va solapando con cada simbolo de N elementos que llega)
rx_sum=zeros(1,M);
receptor antes del detector
z=0;
% Vector de simbolos recibidos despues de la suma en el
% Inicilizamos indices
for k=1:M
for i=1:N
recibido(i)=vect_s(i+z);
end
rec=fft(recibido);
sum=rec*cod1';
receptor)
% Uso codigo del usuario 1 (guardado en cod1 para usarlo en
rx_sum(k)=sum/N;
% Dividimos entre N porque estamos sumando N elementos y
queremos volver a tener potencia unidad como al principio
z=z+N;
end
%%%%%%%%%%%%%%%%%%%%%%%%% RUIDO
EbNo=10;
% Eb/No=10dB, como Eb=1 tenemos 1/No=10dB
No=10^(-(EbNo/10));
% Valor de No en unidades naturales
ruido=sqrt(N*No/2)*randn(1,N*M);
señal de informacion(ver articulo))
% Ruido que llega al receptor (lo separamos de la
ruido_simb=zeros(1,N);
% Vector de ruido recibido a la entrada del receptor
por cada simbolo enviado (se va solapando)
rx_ruido_sum=zeros(1,M);
antes del detector
z=0;
% Vector de ruido despues de la suma en el receptor y
% Inicilizamos indices
for k=1:M
for i=1:N
ruido_simb(i)=ruido(i+z);
VI. ANEXOS
97
Interconexión Entre Sistemas Móviles de 3ª Generación
end
rec_ruido=fft(ruido_simb);
sum_ruido=rec_ruido*cod1';
rx_ruido_sum(k)=sum_ruido/N;
% Dividimos entre N porque estamos sumando N
elementos y queremos volver a tener potencia No/2 como al principio
z=z+N;
end
%%%%%%%%%%%% DETECTOR
rec_total=rx_sum+real(rx_ruido_sum);
del ruido
% Sumamos informacion (es real) y parte real
det=sign(rec_total);
% Vector detectado
error=0;
% Contador de errores
for i=1:M
if datos1(i)~=det(i);
error=error+1;
% Hallamos el numero de errores
end
end
ber(u)=error/M;
% Promediamos el numero de errores
end
usu=1:U;
p = polyfit(usu,ber,3);
xg = linspace(1,U);
yg = polyval(p,xg);
semilogy(xg,yg,c(y))
% Ajuste polinomico (curva de regresion)
% Representamos en escala logaritmica
hold on
clear ber
legend('K=0, Rayleigh','K=2','K=4','K=6','K=8');
xlabel('NUMERO DE USUARIOS Caso EGC'),ylabel('BER');
y=y+1;
end
grid
VI. ANEXOS
98
Interconexión Entre Sistemas Móviles de 3ª Generación
VI-1.2. Códigos OVSF
Ahora vamos a representar las mismas funciones que en el apartado anterior, pero
ahora utilizando códigos ortogonales OVSF, los cuales vimos en la memoria. En primer
lugar mostraremos la función spread, la cual genera estos códigos OVSF, donde S
indica el factor de ensanchado y L la rama. Por tanto spread hace las labores que la
función hadamard hacía para los códigos anteriores.
Esta función spread será utilizada por el resto de funciones de este apartado:
•
ber_snr_egc_ovsf, en la cual representamos BER respecto a SNR para un
número fijo de usuarios y receptor EGC.
•
ber_snr_mrc_ovsf, idéntica a la anterior pero para receptor MRC.
•
ber_us_egc_ovsf, en la cual representamos la variación BER respecto al
número de usuarios para una SNR fija, distintas K y receptor EGC.
•
ber_us_mrc_ovsf, idéntica a la anterior pero para receptor MRC.
Estas cuatro funciones son muy similares a las vistas en el caso de los códigos de
Hadamard, con la diferencia de que debemos usar la función spread en vez de
hadamard, por tanto solamente mostraremos dos de ellas, que serán ber_snr_egc_ovsf
y ber_us_mrc_ovsf (ya que la representación de la BER respecto al número de
usuarios para receptor MRC fue la que no mostramos en el apartado anterior la
mostraremos en este).
function output=spread(S,L)
output=ones(1,S);
exp2=log(S)/log(2);
for(I=1:exp2)
a=power(2,(exp2-I));
exp1=floor(((L-1)/a));
for(j=1:floor(2^(I-1)))
output(floor(2^(I-1))+j)=output(j)*(-1).^exp1;
VI. ANEXOS
99
Interconexión Entre Sistemas Móviles de 3ª Generación
end
end
function ber_snr_mrc_ovsf
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%% RECEPTOR EGC %%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%% BER RESPECTO A SNR %%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%% CODIGOS OVSF %%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
close all
clear all
N=16;
M=1e4;
K=2;
U=16;
% Numero de portadoras ortogonales y factor de ensanchado SF
% Numero de datos (bits) por usuario
% Factor de Rician
% Numero de usuarios
%----- Usuario 1 -----------------------------------------------------datos1=sign(randn(1,M));
% Generamos vector de datos del usuario 1
cod1=spread(N,1);
% Cogemos primera rama de los codigos OVSF para
factor de ensanchado N como codigo del usuario 1
fading1=rician_generator(N,K);
siguen una distribucion de Rician
% Generamos un vector de numeros aleatorios que
codyric1=cod1.*fading1;
% Multiplico cada chip del codigo por el
desvanecimiento de la rama correspondiente
datos1c=datos1';
% Ponemos los datos como vector columna
matrix=datos1c*codyric1;
multiplicado por el codigo
% Cada fila de esta matriz tiene un dato de usu
vect_s1=zeros(1,(N*M));
% Vector con los datos transmitidos
i=1;
for k=1:M
fila=matrix(k,:);
s1=ifft(fila);
for n=1:N
% Vector s1 posee N elementos
vect_s1(i)=s1(n);
i=i+1;
end
VI. ANEXOS
100
Interconexión Entre Sistemas Móviles de 3ª Generación
end
%-----Otros Usuarios -----------------------------------------------------for u=2:1:U
datos_u=sign(randn(1,M));
% Generamos vector de datos del usuario u
cod_u=spread(N,u);
% Cogemos rama u como codigo de usuario u
fading_u=rician_generator(N,K);
que siguen una distribucion de Rician
% Generamos un vector de numeros aleatorios
codyric_u=cod_u.*fading_u;
desvanecimiento de la rama correspondiente
% Multiplico cada chip del codigo por el
datos_uc=datos_u';
matrix_u=datos_uc*codyric_u;
usuario multiplicado por el codigo
vect_s_u=zeros(1,(N*M));
vect_s_int=zeros(1,(N*M));
los usuarios interferentes
% Ponemos los datos como vector columna
% Cada fila de esta matriz tiene un dato de
% Vector con los datos transmitidos por usuario
% Vector con los datos transmitidos por todos
i=1;
for k=1:M
fila_u=matrix_u(k,:);
s_u=ifft(fila_u);
for n=1:N
% Vector s_u posee N elementos
vect_s_u(i)=s_u(n);
i=i+1;
end
end
vect_s_int=vect_s_int+vect_s_u;
end
% Suma de los dos usuarios (lo que sale al canal)
vect_s=vect_s1+vect_s_int;
%---------------------RECEPTOR EGC (multiplico en el receptor solo por el codigo)---------------%-----------------USUARIO 1--------------------------------------------------------------------cod1=spread(N,1);
VI. ANEXOS
% Codigo de usuario 1
101
Interconexión Entre Sistemas Móviles de 3ª Generación
recibido=zeros(1,N);
% Vector recibido a la entrada del receptor por cada
simbolo enviado (se va solapando con cada simbolo de N elementos que llega)
rx_sum=zeros(1,M);
el receptor antes del detector
z=0;
% Vector de simbolos recibidos despues de la suma en
% Inicilizamos indices
for k=1:M
for i=1:N
recibido(i)=vect_s(i+z);
end
rec=fft(recibido);
sum=rec*cod1';
rx_sum(k)=sum/N;
% Dividimos entre N porque estamos sumando N
elementos y queremos volver a tener potencia unidad como al principio
z=z+N;
end
%%%%%%%%%%%%%%%%% RUIDO
for j=0:15
% Valores de Eb/No en dB (siendo Eb=1)
No=10^(-(j/10));
naturales
% Distintos valores para No en unidades
ruido=sqrt(N*No/2)*randn(1,N*M);
la señal de informacion(ver articulo))
% Ruido que llega al receptor (lo separamos de
cod1=spread(N,1);
% Codigo de usuario 1
ruido_simb=zeros(1,N);
% Vector de ruido recibido a la entrada del
receptor por cada simbolo enviado (se va solapando)
rx_ruido_sum=zeros(1,M);
receptor y antes del detector
z=0;
% Vector de ruido despues de la suma en el
% Inicilizamos indices
for k=1:M
for i=1:N
ruido_simb(i)=ruido(i+z);
end
VI. ANEXOS
102
Interconexión Entre Sistemas Móviles de 3ª Generación
rec_ruido=fft(ruido_simb);
sum_ruido=rec_ruido*cod1';
rx_ruido_sum(k)=sum_ruido/N;
% Dividimos entre N porque estamos sumando
N elementos y queremos volver a tener potencia No/2 como al principio
z=z+N;
end
%%%%%%%%%%%% DETECTOR
rec_total=rx_sum+real(rx_ruido_sum);
del ruido
% Sumamos informacion (es real) y parte real
det=sign(rec_total);
% Vector detectado
error=0;
% Contador de errores
for i=1:M
if datos1(i)~=det(i);
error=error+1;
% Hallamos el numero de errores
end
end
ber(j+1)=error/M;
% Promediamos el numero de errores
end
figure
EbNo=0:15;
semilogy(EbNo,ber);
% Dibujamos el eje ‘y’ en escala logaritmica
xlabel('Eb/No(dB)'),ylabel('BER');
grid
function ber_us_mrc_ovsf
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%% MULTIPLES USUARIOS %%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%% MULTIPLES FACTORES K %%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%% RECEPTOR MRC %%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%% CODIGOS OVSF %%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
VI. ANEXOS
103
Interconexión Entre Sistemas Móviles de 3ª Generación
close all
clear all
N=16;
U=16;
numero de subportadoras)
% Numero de subportadoras ortogonales
% Numero de usuarios (tiene que ser menor o igual que el
M=1e4;
c=['b','g','r','c','k'];
% Numero de datos (bits) por usuario
% Vector de colores
y=1;
% Indice del vector de colores
figure
for K=0:2:8
% Factor K de la distribucion de Rician
vect_s=zeros(1,(N*M));
susarios)
% Vector con los datos transmitidos totales (los U
%----- Usuarios desde 1 a U -----------------------------------------------------for u=1:U
datos=sign(randn(1,M));
% Generamos vector de datos del usuario u
cod=spread(N,u);
usuario u
% Cogemos la rama u del codigo OVSF como codigo de
fading=rician_generator(N,K);
siguen una distribucion de Rician
codyric=cod.*fading;
rama correspondiente
datosc=datos';
% Generamos un vector de numeros aleatorios que
% Multiplico cada chip del codigo por el desvanecimiento de la
% Ponemos los datos como vector columna
matrix=datosc*codyric;
por el codigo
vect_s_u=zeros(1,(N*M));
% Cada fila de esta matriz tiene un dato de usu multiplicado
% Vector con los datos transmitidos de cada usuario
i=1;
for k=1:M
fila=matrix(k,:);
s_u=ifft(fila);
for n=1:N
% Vector s_u posee N elementos
vect_s_u(i)=s_u(n);
i=i+1;
end
end
VI. ANEXOS
104
Interconexión Entre Sistemas Móviles de 3ª Generación
if u==1
detector
receptor
datos1=datos;
% Guardo los datos del usuario 1 para luego usarlo en el
codyric1=codyric;
% Guardo el codigo y el canal Rician del usuario 1 para el
end
% Suma de los usuarios (lo que sale al canal)
vect_s=vect_s+vect_s_u;
%---------------------RECEPTOR MRC (multiplico en el receptor por el codigo y por el
desvanecimiento correspondiente de cada rama)
%-----------------USUARIO 1--------------------------------------------------------------------recibido=zeros(1,N);
% Vector recibido a la entrada del receptor por cada
simbolo enviado (se va solapando con cada simbolo de N elementos que llega)
rx_sum=zeros(1,M);
el receptor antes del detector
z=0;
% Vector de simbolos recibidos despues de la suma en
% Inicilizamos indices
for k=1:M
for i=1:N
recibido(i)=vect_s(i+z);
end
rec=fft(recibido);
sum=rec*codyric1';
% Uso codigo y desvanecimiento Rician del usuario 1
(guardado en codyric1 para usarlo en receptor)
rx_sum(k)=sum/N;
% Dividimos entre N porque estamos sumando N
elementos y queremos volver a tener potencia unidad como al principio
z=z+N;
end
%%%%%%%%%%%%%%%%% RUIDO
EbNo=10;
No=10^(-(EbNo/10));
ruido=sqrt(N*No/2)*randn(1,N*M);
señal de informacion(ver articulo))
VI. ANEXOS
% Eb/No=10dB, como Eb=1 tenemos 1/No=10dB
% Valor de No en unidades naturales
% Ruido que llega al receptor (lo separamos de la
105
Interconexión Entre Sistemas Móviles de 3ª Generación
ruido_simb=zeros(1,N);
% Vector de ruido recibido a la entrada del receptor por
cada simbolo enviado (se va solapando)
rx_ruido_sum=zeros(1,M);
antes del detector
z=0;
% Vector de ruido despues de la suma en el receptor y
% Inicilizamos indices
for k=1:M
for i=1:N
ruido_simb(i)=ruido(i+z);
end
rec_ruido=fft(ruido_simb);
sum_ruido=rec_ruido*codyric1';
rx_ruido_sum(k)=sum_ruido/N;
% Dividimos entre N porque estamos sumando N
elementos y queremos volver a tener potencia No/2 como al principio
z=z+N;
end
%%%%%%%%%%%% DETECTOR
rec_total=rx_sum+real(rx_ruido_sum);
del ruido
% Sumamos informacion (es real) y parte real
det=sign(rec_total);
% Vector detectado
error=0;
% Contador de errores
for i=1:M
if datos1(i)~=det(i);
error=error+1;
% Hallamos el numero de errores
end
end
ber(u)=error/M;
% Promediamos el numero de errores
end
usu=1:U;
p = polyfit(usu,ber,3);
xg = linspace(1,U);
yg = polyval(p,xg);
semilogy(xg,yg,c(y))
VI. ANEXOS
% Ajuste polinomico (curva de regresion)
% Representamos logaritmicamente
106
Interconexión Entre Sistemas Móviles de 3ª Generación
hold on
clear ber
legend('K=0, Rayleigh','K=2','K=4','K=6','K=8');
xlabel('NUMERO DE USUARIOS Caso MRC'),ylabel('BER');
y=y+1;
end
grid
VI-1.3. Teórica
En esta función representamos gráficamente la variación de la BER respecto al
número de usuarios, para distintos valores del factor de Rician K (si K = 0 estaremos en
el caso de desvanecimiento Rayleigh) y para los receptores MRC y EGC, partiendo de
las fórmulas teóricas simplificadas que nos proporciona el artículo del cual hemos
partido.
%=========================================================
%=========================================================
% Curvas Teoricas
% Rician y Rayleigh (K=0)
%=========================================================
%=========================================================
function teoricas
clear all
close all
c=['b','g','r','c','k'];
y=1;
M=16;
N=16;
Tb=1;
% Vector de colores
% Numero total de usuarios
% Numero de subportadoras
% Tiempo de bit
EbNo=10;
No=10^(-(EbNo/10));
% Tomamos Eb/No=10dB, como Eb=1 tenemos 1/No=10dB
% Valor de No en unidades naturales
%%%%%%%%%%%%%%%%%%% BER respecto a numero de usuarios para distintas K
%%%%%%%%%%%%%%%%%%%%
VI. ANEXOS
107
Interconexión Entre Sistemas Móviles de 3ª Generación
%%%%%%%%% EGC
figure
for K=0:2:8
% Factor de Rician
ganma=(pi/4)*((exp(-K))/(K+1))*(((1+K)*besseli(0,K/2)+K*besseli(1,K/2))^2);
fading= rician_generator(N,K);
p_i=((mean(fading))^2)/2;
p=N*p_i;
for u=1:M
% Aproxiamndo mediante aplicacion del teorema del limite central
Pe(u)=erfc(sqrt((ganma*p*Tb)/((2*(u/N)*(1-ganma)*p*Tb)+No)))/2;
end
usu=1:M;
semilogy(usu,Pe,c(y));
% Dibujamos en escala logaritmica
hold on
clear Pe
legend('K=0, Rayleigh','K=2','K=4','K=6','K=8');
xlabel('NUMERO DE USUARIOS'),ylabel('BER Caso EGC');
y=y+1;
end
grid
figure
%%%%%%%% MRC
y=1;
for K=0:2:8
ganma=(pi/4)*((exp(-K))/(K+1))*(((1+K)*besseli(0,K/2)+K*besseli(1,K/2))^2);
fading= rician_generator(N,K);
p_i=((mean(fading))^2)/2;
p=N*p_i;
for u=1:M
VI. ANEXOS
108
Interconexión Entre Sistemas Móviles de 3ª Generación
% Aproxiamndo mediante aplicacion del teorema del limite central
Pe(u)=erfc(sqrt((p*Tb)/(((u/N)*((4*K+2)/((K+1)^2))*p*Tb)+No)))/2;
end
usu=1:M;
semilogy(usu,Pe,c(y));
% Dibujamos en escala logaritmica
hold on
clear Pe
legend('K=0, Rayleigh','K=2','K=4','K=6','K=8');
xlabel('NUMERO DE USUARIOS'),ylabel('BER caso MRC');
y=y+1;
end
grid
VI. ANEXOS
109