Documentos de Académico
Documentos de Profesional
Documentos de Cultura
PROYECTO
OFDM
ESTUDIANTES:
Edwin Quispe Ortiz
Rodrigo Uruchi
ASIGNATURA:
Procesamiento Digital De Señales
DOCENTE:
Sylvain Damien Lesage
1. INTRODUCCIÓN
OFDM es un metodo de codificacion digital de datos en frecuencias con
multiples portadoras. OFDM ha sido desarrollado en un ambiente popular
para comunicación digital de banda ancha, utilizado en aplicaciones como
transmision de television y audio digital, acceso a internet DSL (por su sigla
en inglés Digital Suscriber Line), redes inalambricas y redes de
comunicaciones moviles 4G.
𝑇0 +𝑡
∫ 𝑓1 (𝑡) ∗ 𝑓2 (𝑡)𝑑𝑡 = 0
𝑇0
Donde:
𝑓1 y 𝑓2 son las frecuencias de las subportadoras que se encuentran
ortogonales durante el tiempo T donde la separación es 1/T que es el
mínimo para que estas sean ortogonales.
Los datos se dividen en varios flujos o canales en paralelo, uno para cada
subportadora. Y cada subportadora se modula con una técnica
convencional como QAM o PSK a velocidades bajas. Los flujos de datos
que se consiguen con similares a una modulación
OFDM necesita menos ancho de banda que FDM para transportar la misma
cantidad de información, lo que se traduce en mayor eficiencia espectral.
Además de una alta eficiencia espectral, un sistema de OFDM como
WiMAX es más resistente a RNE medio ambiente. Puede ser eficiente y
superar las interferencias de frecuencia selectiva de desvanecimiento
causado por múltiples porque la igualación se hace en un subconjunto de
sub-compañías aéreas en lugar de una sola compañía aérea más amplia.
El efecto del ISI (Inter Symbol Interference) se suprime en virtud de un
período más largo símbolo del paralelo OFDM sub-portadoras de un único
sistema de soporte y el uso de un prefijo cíclico (CP).
Fig. 4. Se muestra una serie de portadoras ortogonales
3. DATOS
Los datos que se utilizaran seran por medio de una simulacion en MatLab.
Se utilizara el archivo de sonido ‘handel’, sonido precargado en el programa
4. CRITERIOS DE EVALUACIÓN
Se trabajará sobre la implementacion de un algoritmo para poder simular el
funcionamiento de una transmision por OFDM, asi se podra verificar como
es que funciona éste. Entonces se trabajará sobre la creacion de un
algoritmo en la plataforma MatLab.
5. SOLUCIÓN
Se trabajará en crear un algoritmo de implementacion de transmision
OFDM en MatLab. Asi podremos simular como es que trabaja la tecnologia
ADSL y principalmente DMT.
La implementación será de la siguiente manera:
Cuantificacion
Asignacion de Bits
c. Mapeo de Constelacion
En el proceso del mapeo de la constelación, los flujos de datos de B-
bits son asignados en un único valor complejo en la constelación.
Esto es similar a la Modulacion por Amplitud de Cuadratura (QAM),
porque la IFFT de estas muestras son representadas por valores
proporcionales del eje real en el caso de la amplitud y la fase es
representada con valores del eje complejo.
d. Reflejo/IFFT y des-reflejo/FFT
Asi como la conversión Serie/Paralelo, el reflejo es sencillo en su
principio y su implementación, y es esencial para DMT. Necesitamos
que se transmita una señal con valores reales, pero después del
mapeo de constelación, los bloques tienen valor complejo. El
proceso de reflejo asegura que la señal transmitida tenga valores
reales tomando en cuenta el hecho que la IFFT (Transformada
Rapida Inversa de Fourier) de un vector conjugado es real. En
nuestro sistema, el reflejo le da simetría a cada bloque. En el
proceso del reflejo, cada bloque es volteado cerca, conjugado y
ubicado al final del bloque original. Hay algunos puntos mas finos.
Sin embargo, si la longitud del bloque antes del reflejo es ‘M’, el
elemento M+1 del bloque reflejado toma cualquier valor real (en
nuestro caso lo reemplazamos con cero) mientras que el elemento
M+2 toma el valor del elemento M-1, luego el elemento M+3 toma el
valor del elemento M-2 y asi sucesivamente hasta completar reflejar
los M elementos, en total tendríamos 2M elementos. También el
primer elemento en ningún bloque no puede tener un valor complejo;
debe ser puesto artificialmente a un valor real. Esto es porque el
primer punto de cualquier bloque corresponde a una frecuencia de
cero después de la IFFT. Si este elemento es complejo, el resultado
del vector, creado por la IFFT, tendrá una compensación compleja y
por lo tanto será complejo también. Aunque esto seria una fuente de
error, asumimos que el receptor conoce correctamente los primeros
elementos de cada bloque, eliminando este error.
Fig. 10. Se muestra un bloque (longitud original de 128 elementos)
de puntos de constelación después del reflejo (solo magnitudes). La
porción reflejada esta mostrada en azul
e. Prefijo Ciclico
En una transmisión OFDM se pueden dar dos formas de
interferencia:
g. Ecualizacion y aproximación
a. Run.m
Es el archivo principal que llama a las funciones que emulan los
bloques de un sistema de transmisión DMT ADSL, el código es el
siguiente.
load handel
y=y(1:S); %señal de entrada, se tomaran las primeras 256 muestras
x=a2d(y,B); %conversor analogico a digital incluyendo cuantificacion
z=constmap(x,M); %Constelacion para el mapeo de la señal digital x
a=series2parallel(z,F); %conversor de serie a paralelo
b=mirror(a);
c=ifft(b);
d=cyclicpad(c,N);
e=matlaberr(parallel2series(d));
aN = randn(length(conv(e,s)),1)*noise;
f=channel(e,s,aN,sN);
f=f(1:length(e));
g=series2parallel(f,2*F+N);
h=decyclicpad(g,N);%
k=fft(h);
m=filterchannel(k,s);
n=demirror(m);
n(1,:)=a(1,:);
o=parallel2series(n);
p=approximate(o,M);
q=deconstmap(p,M);
r=d2a(q,B);
figure(1)
stem(y/max(abs(y)));title('SEÑAL DE ENTRADA');
xlabel('Muestras'); ylabel('Amplitud');
axis([1 S -1 1]);
grid on
figure(2)
stem(d2a(x,B));
title('ENTRADA CUANTIFICADA');
xlabel('Muestras'); ylabel('Amplitud');
axis([1 S -1 1]);
grid on
%
figure(3)
plot(real(M(:,length(M(1,:)))),imag(M(:,length(M(1,:)))),'.b');
grid on
title('MAPA DE CONSTELACION');
xlabel('Real'); ylabel('Imaginario');
axis([-1.5 1.5 -1.5 1.5]);
%
figure(4)
Q=length(d(:,1));
stem(1:Q-N,matlaberr(d(1:Q-N,1)),'b');ylabel('Prefijo ciclico añadido');
title('PREFIJO CICLICO AÑADIDO');
xlabel('Muestras'); ylabel('Amplitud');
hold
stem(1:N,matlaberr(d(1:N,1)),'r');
stem(Q-N+1:Q,matlaberr(d((Q-N+1):Q,1)),'r');
hold;
%
%
figure(5)
stem(e);
title('ENTRADA CON ISI - ICI ');
xlabel('Muestras'); ylabel('Amplitud');
Q=2*(2*F+N);
stem(1:Q/2,e(1:Q/2));
hold
stem(Q/2+1:Q,e(Q/2+1:Q),'g');
stem(Q/2-L/2+1/2:Q/2+L/2,s,'r');
hold;
%
figure(7)
plot(real(o),imag(o),'*r');
hold;
plot(real(M(:,length(M(1,:)))),imag(M(:,length(M(1,:)))),'.b');
title('PUNTOS DE CONSTELACION RECIBIDOS');
xlabel('Real'); ylabel('Imaginario');
hold;
grid;
axis([-1.5 1.5 -1.5 1.5]);
figure(6)
stem(fftshift(abs(fft(s,256))));
title('FUNCION DE TRANSF. DEL CANAL DE Tx');
xlabel('Muestras'); ylabel('Amplitud');
axis([0 2*F 0 1]);
%
figure(8)
stem(f);title('SALIDA DEL CANAL');
xlabel('Tiempo'); ylabel('Amplitud');
%
figure(9)
stem(h);title('PREFIJO CICLICO EXTRAIDO');
xlabel('Muestras'); ylabel('Amplitud');
%
figure(10)
stem(fftshift(abs(1./fft(s,256))));
title('FUNC. DE TRANSF. DEL ECUALIZADOR');
xlabel('Frecuencia'); ylabel('Amplitud');
%
figure(11)
stem(r);
title('SEÑAL RECIBIDA/CUANTIFICADA');
xlabel('Tiempo'); ylabel('Amplitud');
%
figure(12)
stem(1:128,abs(b(1:length(b)/2,1)),'m')
hold
stem(129:256,abs(b(length(b)/2+1:length(b),1)),'k')
hold
title('REFLEJO');
xlabel('Muestras'); ylabel('Amplitud');
ps=(norm(e))^2;
pn=(norm(aN))^2;
snr=10*log10(ps/pn);
biterr=sum(abs(x-q));
b. A2d.m
Esta función es la conversora de datos analógicos a digitales.
function y = a2d(x,b)
% a2d(x) – convierte a tiempo discreto, una señal analogica a
% un flujo de bits (b bits por muestra)
% x – señal original
% b – numero de bits por muestra
N = length(x);
qinterval = 2*max(abs(x))/((2^b)-1);
if b<=1;
for i=1:N
if x(i)<=0
bits(i)=0;
else
bits(i)=1;
end
end
else
q = quant(x-min(x),qinterval);
bits=zeros(N*b,1);
for k=0:((2^b)-1)
u=dec2bin(k);
for i=1:length(u)
w(i)=str2num(u(i));
end
v=[zeros((b-length(w)),1)',w];
p(k+1,:)=v;
end
for i=0:N-1
for k=0:((2^b)-1)
if q(i+1)==k*qinterval
bits(b*i+1:b*i+b)=p(k+1,:);
break
else
end
end
end
end
y=bits;
c. Constmap.m
Es la función que realiza el mapeo en la constelación
function y = constmap(x,M)
% constmap(x) –mapa de constelacion para el flujo de bits (2
bits/simbolo)
% x – flujo de bits
m=length(M(1,:))-1;
N = length(x);
newN=m*round(N/m);
x=x(1:newN);
for i=1:m
newvector(:,i)=x(i:m:newN-(m-i));
end
alpha=zeros(newN/m,1);
for i=1:newN/m
for k=1:length(M(:,1))
if (newvector(i,:)==M(k,1:m))
alpha(i)=M(k,m+1);
break
else
end
end
end
y=alpha;
d. Series2parallel.m
Es la función que convierte el flujo de bits de serie a paralelo
function y = series2parallel(x,N)
L=length(x);
q=floor(L/N);
newvec=zeros(N,q);
for i=1:q
newvec(1:N,i)=x((1+(i-1)*N):i*N);
end
y=newvec;
e. Mirror.m
f. Cyclicpad.m
Es la función encargada del prefijo cíclico
function y=cyclicpad(X,L)
N=length(X(:,1));
Y=[X(N-L+1:N,:);X];
y=Y;
g. Matlaberr.m
Es la función encargada de añadir error al flujo de bits.
function y = matlaberr(X)
R=length(X(1,:));
L=length(X(:,1));
for m=1:R
for n=1:L
if abs(real(X(n,m)))<.000001
a=0;
else
a=real(X(n,m));
end
if abs(imag(X(n,m)))<.000001
b=0;
else
b=imag(X(n,m));
end
X(n,m)=a+j*b;
end
end
y=X;
h. Channel.m
Es el código encargado del canal de transmisión
function y=channel(x,h,aN,sN)
a=conv(x,h);
N=length(a);
w=a+aN;
m=max(abs(x));
for k=1:sN
w(round(abs(randn(1,1))*(N-1))+1)=m;
end
y=w;
i. Decyclicpad.m
Es la función encargada de quitar el prefijo cíclico
function y=decyclicpad(X,L)
N=length(X(:,1));
Y=X(L+1:N,:);
y=Y;
j. Filterchannel.m
Es la función encargada de emular el filtro pasa bajo a causa del
canal.
function y=filterchannel(X,h)
N=length(X(:,1));
W=length(X(1,:));
H=fft(h,N);
invH=1./H;
for k=1:W
y(:,k)=invH.*X(:,k);
end
y;
k. Demirror.m
Es la función encargada de quitar el reflejo de la información en el
símbolo.
function y = demirror(X)
R=length(X(1,:));
L=length(X(:,1));
if rem(L,2)==1
y=[ones(1,R);X(1:L/2,:)];
else
y=X(1:L/2,:);
end
l. Approximate.m
Es la función encargada de la aproximación de puntos a la
constelación.
function y = approximate(x,M)
% approximate(x,M) – aproxima un simbolo con ruido x con símbolos validos
% en M
% x – vector de simbolo con ruido
% M – matriz que representa el mapa de constelacion
for i=1:N
mindist=100;
symnum=0;
for k=1:L
if abs(a(k)-x(i))<=abs(mindist)
mindist=abs(a(k)-x(i));
alpha(i)=a(k);
else
end
end
end
y=alpha;
m. Deconstmap.m
Se encarga de quitar el mapeo de bits del símbolo.
function y = deconstmap(x,M)
% deconstmap(x) – mapa de constelacion en el simbolo (2 bits/symbol)
% x - bitstream
y=bits;
n. D2a.m
Función encargada de la conversión digital a analógica de la señal.
function y = d2a(x,b)
% d2a(x) convierte el flujo de bits (b bits por muestra) de tiempo
discreto,
% a una señal analogica
% x – flujo de bits
% b – numero de bits por muestra
x=x';
N = length(x);
L=floor(N/b);
qinterval = 2/(2^b-1);
if b<=1;
for i=1:N
if x(i)==0
sig(i)=-1;
else
sig(i)=1;
end
end
else
sig=zeros(L,1);
for k=0:((2^b)-1)
u=dec2bin(k);
w=zeros(1,length(u)); % conversion a binario
for i=1:length(u)
w(i)=str2num(u(i));
end
v=[zeros((b-length(w)),1)',w];
p(k+1,:)=v; % p es un vector de binaries para un interval de #’s
end
if b~=4
else
for i=0:L-1
%%for k=1:b
if x(1+i*b)==0
if x(2+i*b)==0
if x(3+i*b)==0
if x(4+i*b)==0
sig(i+1) = -1;
else
sig(i+1) = qinterval*1-1;end
else
if x(4+i*b)==0
sig(i+1) = qinterval*2-1;
else
sig(i+1) = qinterval*3-1;end; end
else
if x(3+i*b)==0
if x(4+i*b)==0
sig(i+1) = qinterval*4-1;
else
sig(i+1) = qinterval*5-1;end
else
if x(4+i*b)==0
sig(i+1) = qinterval*6-1;
else
sig(i+1) = qinterval*7-1;end; end; end
else
if x(2+i*b)==0
if x(3+i*b)==0
if x(4+i*b)==0
sig(i+1) = qinterval*8-1;
else
sig(i+1) = qinterval*9-1;end
else
if x(4+i*b)==0
sig(i+1) = qinterval*10-1;
else
sig(i+1) = qinterval*11-1;end; end
else
if x(3+i*b)==0
if x(4+i*b)==0
sig(i+1) = qinterval*12-1;
else
sig(i+1) = qinterval*13-1;end
else
if x(4+i*b)==0
sig(i+1) = qinterval*14-1;
else
sig(i+1) = qinterval*15-1;end; end; end; end
end
end
end
y=sig;
o. Constbuilder
Función encargada de la construcción de la constelación.
function y = constbuilder(N)
b=ceil(log2(N));
p=zeros(N,b);
for k=0:(N-1)
u=dec2bin(k);
w=zeros(1,length(u));
for i=1:length(u)
w(i)=str2num(u(i));
end
v=[zeros((b-length(w)),1)',w];
p(k+1,:)=v;
end
n=0:N-1;
if N<=16
a=exp(j*2*pi/N.*n');
M=[p,a];
else
a=exp(j*2*pi/16.*(0:15)');
if N<=24
b=0.5*exp(j*2*pi/(N-17).*(0:N-17)');
M=[p,[a;b]];
else
b=0.66*exp(j*2*pi/8.*(0:8)'+j*pi/16);
if N<=32
c=0.33*exp(j*2*pi/(N-26).*(0:N-26)');
M=[p,[a;b;c]];
else
a=exp(j*2*pi/N.*n');
M=[p,a];
end
end
end
if N==16
a=[.354+.354*j;sqrt(2)/2;sqrt(2)/2*j;-.354+.354*j;-
sqrt(2)/2*j;.354-.354*j;-.354-.354*j;-sqrt(2)/2];
b=exp(j*2*pi/8.*(0:7)');
M=[p,[a;b]];
else
end
y=matlaberr(M);
7. CONCLUSIONES Y SUGERENCIAS
Se logro lo que se quería lograr, una simulación de una transmisión
OFDM en DMT ADSL. Utilizando 256 portadoras.
El proceso fue satisfactorio
8. REFERENCIAS
http://cnx.org/contents/513c5788-0900-4745-ab70-
4597a1a791a2@3/DMT:_Implementation
DSL Advances, Prentice Hall
OFDM simulation using Matlab, Guillermo Acosta
Discrete Multitone Technology for 100G Ethernet, Toshiki Tanaka
DSL Transmission, Technische Universitat Hamburg-Harburg
Sistemas de transmission por fibra optica basados en OFDM, Raul
Nieto Freire
The benefits of Discrete Multi-Tone Modulation for VDSL systems,
Ikanos
Simulaciones en Matlab
Introduction to Digital Subscriber Line Technolgy, Concord
OFDM and DMT Systems, Cambridge