Anda di halaman 1dari 22

RESULTADOS DE LA EJECUCION DE UN PROGRAMA PARA MOSTRAR

EL PROCESAMIENTO Y GENERACION DE SEÑAES EN UN SISTEMA DE


MODULACION OFDM
A continuación, se mostrar los resultados obtenidos, por secciones,
%------1-------2-------3-------4-------5-------6-------7-------8
% OFDM Simulation
%
clc; clear; close all;
%
% Parametros de un sistema OFDM basico
% - eleccion de valores predeterminados o eleccion de valores del usuario
%
fprintf ('Programa de analisis de OFDM\n\n');
defaults = input('Para usar parametros por defecto: ingrese "1", en caso
contrario ingrese "0": ');
%
if defaults == 1
IFFT_bin_length = 1024; % No de bin IFFT para la Tx, No de bin FFT para Rx
carrier_count = 200; % numero de portadoras
bits_per_symbol = 2; % bits por simbolo
symbols_per_carrier = 50; % simbolos por portadora
SNR = 10; % relacion de señal a ruido en un canal (dB)
else
IFFT_bin_length = input('IFFT bin length = ');
carrier_count = input('carrier count = ');
bits_per_symbol = input('bits per symbol = ');
symbols_per_carrier = input('symbols per carrier =');
SNR = input('SNR = ');
end

En la figura 1, se muestra el resultado de ejecutar la primera sección, para la elección “1” para
valores por defecto. Se muestran los valores por defecto.

En la siguiente sección se calculan otros parámetros para la modulación OFDM, Ver figura 2.
%%
% Parametros derivados
%
baseband_out_length = carrier_count * symbols_per_carrier * bits_per_symbol;
carriers = (1:carrier_count) + (floor(IFFT_bin_length/4) -
floor(carrier_count/2));
conjugate_carriers = IFFT_bin_length - carriers + 2;
%

En la siguiente sección se genera una señal de 1 y 0, obtenidos aleatoriamente. En la ventana


de memoria de Matlab se muestra este nuevo vector. Ver figura 3. A manera de ejemplo, se
muestran algunos valores.
%%
% TRANSMISOR >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
%
% Generacion de una señal de salida binaria aleatoria:
% - una fila de numeros aleatorios uniforme (entre 0 y 1)
% - this will be the baseband signal which is to be transmitted.
%
baseband_out = randi([0 1],1,baseband_out_length);

ACAJAHUARINGA 1
>> baseband_out(1,1:10)

ans =

1 0 1 0 0
1 0 1 1 0

Figura 1 Variables creadas en la Figura 2 Variables creadas en la Algunos valores


primera seccion. segunda seccion.

%%
% Convierte a enteros 'modulo N' donde N = 2^bits_per_symbol
% - esto define cuántos estados puede representar cada símbolo
% - primero, haz una matriz con cada columna representando bits
% - consecutivos de la secuencia de entrada y la cantidad de
% bits en una columna igual al de bits por símbolo
% - luego, para cada columna, multiplique cada valor de fila
% por el poder de 2 que representa y agrega todas las filas
% - por ejemplo: input 0 1 1 0 0 0 1 1 1 0
% bits_per_symbol = 2
% convert_matrix = 0 1 0 1 1
% 1 0 0 1 0
%
% modulo_baseband = 1 2 0 3 2
%
convert_matrix = reshape(baseband_out, bits_per_symbol,
length(baseband_out)/bits_per_symbol);
for k = 1:(length(baseband_out)/bits_per_symbol)
modulo_baseband(k) = 0;
for i = 1:bits_per_symbol
modulo_baseband(k) = modulo_baseband(k) +
convert_matrix(i,k)*2^(bits_per_symbol-i);
end
end

>> convert_matrix(1:2,1:10)

ans =
1 1 0 0 1 1 1 0 1 0
0 0 1 1 0 0 0 1 1 0

>> modulo_baseband(1,1:10)

ans =
2 2 1 1 2 2 2 1 3 0

Figura 3 Algunos valores de la matrices creadas

ACAJAHUARINGA 2
%%
% Conversión de serie a paralelo
% - convierte el flujo serial modulo N en una matriz donde
% cada columnarepresenta una portadora y cada fila
% representa un símbolo
% - por ejemplo:
%
% flujo de entrada serial = a b c d e f g h i j k l m n o p
%
% distribucion de las subportadoras en paralelo =
% C1/s1=a C2/s1=b C3/s1=c C4/s1=d
% C1/s2=e C2/s2=f C3/s2=g C4/s2=h
% C1/s3=i C2/s3=j C3/s3=k C4/s3=l
% . . . .
% . . . .
%
carrier_matrix = reshape(modulo_baseband, carrier_count, symbols_per_carrier)';
%

El resultado de esta sección, es convertir el flujo de bits de serie a paralelo. Ver figura 4 y
algunos valores del vector creado.

>> carrier_matrix(1:10,1:15)

ans =

2 2 1 1 2 2 2 1 3 0 2 0 2 3 2
1 0 0 3 2 0 3 3 3 1 2 2 1 3 0
1 1 1 1 0 1 0 0 0 3 1 1 2 2 2
1 0 0 1 3 2 3 1 2 2 3 3 0 2 1
2 1 3 3 1 1 3 2 3 1 0 3 0 3 1
1 3 3 1 1 3 2 2 3 0 1 1 0 0 0
0 2 3 3 1 0 0 1 0 1 3 0 3 0 0
1 1 2 1 2 3 2 3 3 0 1 1 3 1 0
1 2 2 2 3 2 0 3 1 2 2 0 3 1 3
2 0 1 0 3 1 1 2 3 0 2 2 3 1 2

Figura 4 Algunos valores del flujo en paralelo

%%
% Aplicacion de codificación diferencial a cada cadena de portadora
% - añadir un símbolo de inicio arbitrario (que sea 0, que funcione
% para todos de bits_per_symbol) (tenga en cuenta que esto se
% hace usando una vertical concatenación [x; y] de una fila
% de ceros con la matriz portadora,
% - realizar la adición del módulo N entre el símbolo (n) y el
% símbolo (n-1) para obtener el del valor codificado del símbolo (n)
% - por ejemplo:
% bits_per_symbol = 2 (modulo 4)
% flujo de simbolos = 3 2 1 0 2 3
% simbolo de inicio = 0
%
% simbolos codificados = 0 + 3 = 3
% 3 + 2 = 11 = 1
% 1 + 1 = 2
% 2 + 0 = 2

ACAJAHUARINGA 3
% 2 + 2 = 10 = 0
% 0 + 3 = 3
%
% flujo codificado = 0 3 1 2 2 0 3
%
%
carrier_matrix = [zeros(1,carrier_count);carrier_matrix];
for i = 2:(symbols_per_carrier + 1)
carrier_matrix(i,:) = rem(carrier_matrix(i,:)+carrier_matrix(i-
1,:),2^bits_per_symbol);
end

El resultado de esta sección, está en la misma matriz anterior, 𝒄𝒂𝒓𝒓𝒊𝒆𝒓_𝒎𝒂𝒕𝒓𝒊𝒙, se muestra


los valores de las variables alteradas por la ejecución de esta sección en la figura 5, así como
algunos valores de la matriz actualizada, con los símbolos codificados.

>> carrier_matrix(1:10,1:15)

ans =

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
2 2 1 1 2 2 2 1 3 0 2 0 2 3 2
3 2 1 0 0 2 1 0 2 1 0 2 3 2 2
0 3 2 1 0 3 1 0 2 0 1 3 1 0 0
1 3 2 2 3 1 0 1 0 2 0 2 1 2 1
3 0 1 1 0 2 3 3 3 3 0 1 1 1 2
0 3 0 2 1 1 1 1 2 3 1 2 1 1 2
0 1 3 1 2 1 1 2 2 0 0 2 0 1 2
1 2 1 2 0 0 3 1 1 0 1 3 3 2 2
2 0 3 0 3 2 3 0 2 2 3 3 2 3 1

Figura 5 Algunos valores de los simbolos codificados

%%
% Conversion de la codificacion diferencial en una fase
% - cada fase representa un estado diferente del simbolo
% - por ejempo:
% bits_per_symbol = 2 (modulo 4)
% simbolos = 0 3 2 1
% fases =
% 0 * 2pi/4 = 0 (0 grados)
% 3 * 2pi/4 = 3pi/2 (270 grados)
% 2 * 2pi/4 = pi (180 grados)
% 1 * 2pi/4 = pi/2 (90 grados)
%
carrier_matrix = carrier_matrix * ((2*pi)/(2^bits_per_symbol));

En la misma matriz, se mapea los valores numéricos a fase. Se muestran algunos valores en la
siguiente tabla 1.

ACAJAHUARINGA 4
>> carrier_matrix(1:20,1:13)
ans =
0 0 0 0 0 0 0 0 0 0 0 0 0
4.9348 4.9348 2.4674 2.4674 4.9348 4.9348 4.9348 2.4674 7.4022 0 4.9348 0 4.9348
7.4022 4.9348 2.4674 0 0 4.9348 2.4674 0 4.9348 2.4674 0 4.9348 7.4022
0 7.4022 4.9348 2.4674 0 7.4022 2.4674 0 4.9348 0 2.4674 7.4022 2.4674
2.4674 7.4022 4.9348 4.9348 7.4022 2.4674 0 2.4674 0 4.9348 0 4.9348 2.4674
7.4022 0 2.4674 2.4674 0 4.9348 7.4022 7.4022 7.4022 7.4022 0 2.4674 2.4674
0 7.4022 0 4.9348 2.4674 2.4674 2.4674 2.4674 4.9348 7.4022 2.4674 4.9348 2.4674
0 2.4674 7.4022 2.4674 4.9348 2.4674 2.4674 4.9348 4.9348 0 0 4.9348 0
2.4674 4.9348 2.4674 4.9348 0 0 7.4022 2.4674 2.4674 0 2.4674 7.4022 7.4022
4.9348 0 7.4022 0 7.4022 4.9348 7.4022 0 4.9348 4.9348 7.4022 7.4022 4.9348
0 0 0 0 4.9348 7.4022 0 4.9348 2.4674 4.9348 2.4674 2.4674 2.4674
0 0 4.9348 0 4.9348 2.4674 4.9348 4.9348 7.4022 7.4022 0 7.4022 4.9348
4.9348 4.9348 2.4674 4.9348 4.9348 0 0 0 2.4674 4.9348 7.4022 4.9348 7.4022
4.9348 2.4674 0 0 2.4674 0 2.4674 0 2.4674 2.4674 2.4674 4.9348 4.9348
0 2.4674 7.4022 0 0 4.9348 2.4674 0 0 0 7.4022 4.9348 7.4022
7.4022 0 4.9348 2.4674 7.4022 7.4022 7.4022 2.4674 2.4674 4.9348 7.4022 0 0
2.4674 0 0 2.4674 0 0 7.4022 0 7.4022 0 0 7.4022 4.9348
4.9348 4.9348 2.4674 2.4674 0 4.9348 0 4.9348 0 7.4022 7.4022 0 2.4674
7.4022 4.9348 2.4674 0 2.4674 0 4.9348 0 4.9348 2.4674 7.4022 2.4674 2.4674
7.4022 2.4674 2.4674 0 7.4022 0 2.4674 4.9348 4.9348 2.4674 2.4674 4.9348 4.9348
Tabla 1 Valores de fase de la señal de banda base
%%
% Conversion de la fase a un numero complejo
% - a cada simbolo se le da una magnitud de 1 para acompañar
% a su fase (via la funcion ones(r,c))
% - este es luego convertido de su forma polar a su forma cartesiana
% - como resultado, se obtienen dos matrices, X con los valores
% reales y Y con los valores imaginarios
% - cada columna de X tiene los valores reales para una portadora,
% y cada columna de Y tiene los valores imaginarios de una portadora
% - una sola matriz compleja es luego generado tomando a X para los
% reales y Y para los imaginarios
%
[X,Y] = pol2cart(carrier_matrix,
ones(size(carrier_matrix,1),size(carrier_matrix,2)));
complex_carrier_matrix = complex(X,Y);

Resultados de la conversión de fase anumero complejo, en la figura 6, así como la muestra de


algunos valores.

ACAJAHUARINGA 5
>> X(1:10,1:10), Y(1:10,1:10)
ans =
1.0000 1.0000 1.0000 1.0000 1.0000 1.0000 1.0000 1.0000 1.0000 1.0000
0.2206 0.2206 -0.7812 -0.7812 0.2206 0.2206 0.2206 -0.7812 0.4366 1.0000
0.4366 0.2206 -0.7812 1.0000 1.0000 0.2206 -0.7812 1.0000 0.2206 -0.7812
1.0000 0.4366 0.2206 -0.7812 1.0000 0.4366 -0.7812 1.0000 0.2206 1.0000
-0.7812 0.4366 0.2206 0.2206 0.4366 -0.7812 1.0000 -0.7812 1.0000 0.2206
0.4366 1.0000 -0.7812 -0.7812 1.0000 0.2206 0.4366 0.4366 0.4366 0.4366
1.0000 0.4366 1.0000 0.2206 -0.7812 -0.7812 -0.7812 -0.7812 0.2206 0.4366
1.0000 -0.7812 0.4366 -0.7812 0.2206 -0.7812 -0.7812 0.2206 0.2206 1.0000
-0.7812 0.2206 -0.7812 0.2206 1.0000 1.0000 0.4366 -0.7812 -0.7812 1.0000
0.2206 1.0000 0.4366 1.0000 0.4366 0.2206 0.4366 1.0000 0.2206 0.2206

ans =
0 0 0 0 0 0 0 0 0 0
-0.9754 -0.9754 0.6243 0.6243 -0.9754 -0.9754 -0.9754 0.6243 0.8997 0
0.8997 -0.9754 0.6243 0 0 -0.9754 0.6243 0 -0.9754 0.6243
0 0.8997 -0.9754 0.6243 0 0.8997 0.6243 0 -0.9754 0
0.6243 0.8997 -0.9754 -0.9754 0.8997 0.6243 0 0.6243 0 -0.9754
0.8997 0 0.6243 0.6243 0 -0.9754 0.8997 0.8997 0.8997 0.8997
0 0.8997 0 -0.9754 0.6243 0.6243 0.6243 0.6243 -0.9754 0.8997
0 0.6243 0.8997 0.6243 -0.9754 0.6243 0.6243 -0.9754 -0.9754 0
0.6243 -0.9754 0.6243 -0.9754 0 0 0.8997 0.6243 0.6243 0
-0.9754 0 0.8997 0 0.8997 -0.9754 0.8997 0 -0.9754 -0.9754
Figura 6 variables creadas Algunos valores de los simbolos codificados

%%
% Asignando a cada portadora su bin IFFT
% - cada fila de la matriz complex_carrier_matrix representa
% un período del símbolo, con un símbolo por portadora
% - se genera una matriz para representar todos los bin IFFT
% (columnas) y todo los simbolos (filas)
% - la modulación de fase para cada portadora se asigna,
% luego, al bin apropiado
% - el conjugado de la modulación de fase se asigna, luego,
% al bin apropiado
% - los bins de modulación de fase y sus conjugados son
% simétricos de la frecuencia de Nyquist en los bin IFFT
% - dado que el primer bin es DC, la frecuencia de Nyquist
% se encuentra en (número de contenedores / 2) + 1
% - se generan conjugados simétricos de modo que cuando la
% señal es transformada al dominio del tiempo, la señal
% en el tiempo tendrá valor real
% - ejemplo
% - 1024 bins IFFT
% - bin 513 es el centro (punto simétrico)
% - bin 1 es la DC
% - bin 514 es la conjugada compleja del bin 512
% - bin 515 es la conjugada compleja del bin 511
% - ....
% - bin 1024 es la conjugada compleja del bin 512
% (si todos los bins fueran usados como portadoras)
% - Asi, los bins del 2-512 se mapean a los bins del 1024-514
%
IFFT_modulation = zeros(symbols_per_carrier + 1, IFFT_bin_length);
IFFT_modulation(:,carriers) = complex_carrier_matrix;
IFFT_modulation(:,conjugate_carriers) = conj(complex_carrier_matrix);

ACAJAHUARINGA 6
El resultado es la creación de una matriz que contiene la IFFT de de cada bin FFT. Los
resultados en la figura 7.
>> IFFT_modulation(1:5, 1:10), IFFT_modulation(1:5, 201:205)
ans =
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
ans =
1.0000 + 0.0000i 1.0000 + 0.0000i 1.0000 + 0.0000i 1.0000 + 0.0000i 1.0000 + 0.0000i
-0.7812 + 0.6243i 0.4366 + 0.8997i 1.0000 + 0.0000i 1.0000 + 0.0000i 0.2206 - 0.9754i
-0.7812 + 0.6243i 0.4366 + 0.8997i -0.7812 + 0.6243i 0.2206 - 0.9754i 0.2206 - 0.9754i
0.2206 - 0.9754i 1.0000 + 0.0000i 1.0000 + 0.0000i -0.7812 + 0.6243i 0.2206 - 0.9754i
1.0000 + 0.0000i 0.2206 - 0.9754i 0.4366 + 0.8997i -0.7812 + 0.6243i 1.0000 + 0.0000i

Figura 7 Algunos valores de la matriz con IFFT de lis bin de IFFT

%%
% GRAFICA DE LA REPRESENTACION EN EL DOMINIO DE LA FRECUENCIA
%
figure (1)
stem(0:IFFT_bin_length-1, abs(IFFT_modulation(2,1:IFFT_bin_length)),'b*-')
grid on
axis ([0 IFFT_bin_length -0.5 1.5])
ylabel('Magnitud')
xlabel('bins de IFFT')
title('Magnitud en frecuencuia de la portadora OFDM')
figure (2)
plot(0:IFFT_bin_length-1, (180/pi)*angle(IFFT_modulation(2,1:IFFT_bin_length)),
'go')
hold on
stem(carriers-1, (180/pi)*angle(IFFT_modulation(2,carriers)),'b*-')
stem(conjugate_carriers-1,
(180/pi)*angle(IFFT_modulation(2,conjugate_carriers)),'b*-')
axis ([0 IFFT_bin_length -200 +200])
grid on
ylabel('Fase (grados)')
xlabel('bin IFFT')
title('Fase de la portadora OFDM')
hold off
% FIN DE LA GRAFICA

Las graficas de magnitud y fase de la señal OFDM, en las figuras 8 y 9.

ACAJAHUARINGA 7
Figura 8

Figura 9
%
% Transformacion de cada periodo del especto
% (representado por una fila de las portadoras)
% al dominio del tiempo mediante la IFFT
%
time_wave_matrix = ifft(IFFT_modulation');
time_wave_matrix = time_wave_matrix';

ACAJAHUARINGA 8
>> time_wave_matrix (1:10,1:10)
ans =
0.3906 0.0011 -0.2997 -0.0019 0.1010 0.0001 0.0545 0.0018 -0.0780 -0.0013
0.1009 0.0517 -0.1080 -0.0341 0.0690 0.0133 -0.0132 -0.0028 -0.0162 0.0078
0.0688 0.0464 -0.0488 -0.0282 0.0092 0.0070 0.0199 0.0024 -0.0183 0.0044
0.0999 0.0545 -0.0716 -0.0306 0.0121 0.0099 0.0326 -0.0058 -0.0358 0.0135
0.0642 0.0771 -0.0456 -0.0498 0.0163 0.0218 0.0095 -0.0093 -0.0236 0.0106
0.0751 0.0478 -0.0488 -0.0131 0.0087 -0.0083 0.0128 -0.0021 -0.0092 0.0228
0.0594 0.0503 -0.0667 -0.0344 0.0548 0.0132 -0.0295 -0.0001 0.0027 -0.0032
0.0847 0.0619 -0.0731 -0.0276 0.0304 -0.0124 0.0124 0.0310 -0.0245 -0.0230
0.0782 0.0576 -0.0565 -0.0382 0.0151 0.0065 0.0213 0.0146 -0.0330 -0.0158
0.0854 0.0548 -0.0677 -0.0275 0.0176 -0.0096 0.0310 0.0260 -0.0461 -0.0106

Tabla2 Objeción de la transformación al dominio del tiempo con IFFT

%%
% GRAFICA DE LA SEÑAL OFDM PARA UN PERIODO DEL SIMBOLO
% - la primera grafica es la IFFT del primer simbolo OFDM (index 2)
% - index 1 es el simbolo 'inicial' debido a la
% implementacion diferencial
% - la segunda grafica es para las demas portadoras y los dibuja
% en la misma grafica
% - solo funciona para un numero de portadoras <= 16 debido a
% la variabilidad de colores (más de 16 serían realmente
% legibles de todos modos)
%
figure (3)
plot(0:IFFT_bin_length-1,time_wave_matrix(2,:)); grid on
ylabel('Amplitud'); xlabel('Tiempo')
title('Señal OFDM en el tiempo para un periodo del simbolo')
%
colors = ['r' 'g' 'b' 'k' 'r' 'g' 'b' 'k' 'r' 'g' 'b' 'k' 'r' 'g' 'b' 'k'];
for f = 1:carrier_count
temp_bins(1:IFFT_bin_length)=0+0j;
temp_bins(carriers(f))=IFFT_modulation(2,carriers(f));
temp_bins(conjugate_carriers(f))=IFFT_modulation(2,conjugate_carriers(f));
temp_time = ifft(temp_bins');
figure(4)
plot(0:IFFT_bin_length-1, temp_time, colors(f))
hold on
end
grid on
ylabel('Amplitud'); xlabel('Tiempo')
title('Portadoras con sus Formas de onda Separadas en el Tiempo')
%
% FIN DE LA GRAFICA

ACAJAHUARINGA 9
Figura 10 Grafica de OFDM en el tiempo

Figura 11 Grafica de las portadoras en el dominio del tiempo

ACAJAHUARINGA 10
%%
%
% Aplicacion de una función de ventana a cada forma de onda en el tiempo
% - TEN EN CUENTA QUE LA VENTANA ESTÁ ACTUALMENTE COMENTADA, es decir, SIN VENTANAS
% - cada forma de onda en el tiempo (fila de time_wave_matrix)
% representa un símbolo en un período para todas las portadoras
% - la IFFT resultante tiene discontinuidades en cada extremo
% - cuando las formas de onda en el tiempo se serializan (concatenadas),
% las discontinuidades introducirán componentes de frecuencia no deseados
% - la función de la ventana es desenfatizar la señal en los puntos
% finales (en las discontinuidades)
% - esto reduce los efectos de las discontinuidades
% - también distorsiona la respuesta en frecuencia deseada
% (efecto secundario no deseado)
% - entre Blackman, Hanning y Hamming: Hamming introduce menos distorsión
% - tenga en cuenta que la transpuesta de la función de Hamming es
% utilizado (porque se necesita un vector fila)
%
% Dado que todos los valores imaginarios de time_wave_matrix son
% prácticamente iguales a cero, solo la parte real se conserva
% para las ventanas.
%
for i = 1:symbols_per_carrier + 1
%windowed_time_wave_matrix(i,:) = real(time_wave_matrix(i,:)) .* hamming(IFFT_bin_length)';
windowed_time_wave_matrix(i,:) = real(time_wave_matrix(i,:));
end

>> windowed_time_wave_matrix(1:10,1:10)
ans =
0.3906 0.0011 -0.2997 -0.0019 0.1010 0.0001 0.0545 0.0018 -0.0780 -0.0013
0.1009 0.0517 -0.1080 -0.0341 0.0690 0.0133 -0.0132 -0.0028 -0.0162 0.0078
0.0688 0.0464 -0.0488 -0.0282 0.0092 0.0070 0.0199 0.0024 -0.0183 0.0044
0.0999 0.0545 -0.0716 -0.0306 0.0121 0.0099 0.0326 -0.0058 -0.0358 0.0135
0.0642 0.0771 -0.0456 -0.0498 0.0163 0.0218 0.0095 -0.0093 -0.0236 0.0106
0.0751 0.0478 -0.0488 -0.0131 0.0087 -0.0083 0.0128 -0.0021 -0.0092 0.0228
0.0594 0.0503 -0.0667 -0.0344 0.0548 0.0132 -0.0295 -0.0001 0.0027 -0.0032
0.0847 0.0619 -0.0731 -0.0276 0.0304 -0.0124 0.0124 0.0310 -0.0245 -0.0230
0.0782 0.0576 -0.0565 -0.0382 0.0151 0.0065 0.0213 0.0146 -0.0330 -0.0158
0.0854 0.0548 -0.0677 -0.0275 0.0176 -0.0096 0.0310 0.0260 -0.0461 -0.0106

Figura 12 Muestra de algunos valores de las señales en el tiempo

ACAJAHUARINGA 11
%%
% Serializacion de la forma de onda modulante
% - toma secuencialmente cada fila de windowed_time_wave_matrix
% y construye un vector fila
% - el vector de fila será la señal de modulación
% - tenga en cuenta que windowed_time_wave_matrix es transpuesta,
% esto es para tomar en cuenta la forma en que la función de
% Matlab 'reshape' trabaja (reshape toma las columnas de la
% matriz objetivo y los agrega secuencialmente)
%
ofdm_modulation = reshape(windowed_time_wave_matrix', 1,
IFFT_bin_length*(symbols_per_carrier+1));

>> ofdm_modulation (1,1:20)


ans =
columns 1 to 10
0.3906 0.0011 -0.2997 -0.0019 0.1010 0.0001 0.0545 0.0018 -0.0780 -0.0013
columns 11 to 20
0.0093 -0.0009 0.0468 0.0019 -0.0337 -0.0004 -0.0152 -0.0017 0.0353 0.0015

Tabla 3 Valores numéricos de la señal OFDM

%
% GRAFICA DE LA SEÑAL OFDM (time)
%
temp_time = IFFT_bin_length*(symbols_per_carrier+1);
figure (5)
plot(0:temp_time-1,ofdm_modulation)
grid on
ylabel('Amplitud (voltios)')
xlabel('Tiempo (muestras)')
title('Señal OFDM en el tiempo')%

Figura 13 Grafica de la señal OFDM serializada.


%%
% GRAFICA DE LA SEÑAL OFDM (espectro)
symbols_per_average = ceil(symbols_per_carrier/5);
avg_temp_time = IFFT_bin_length*symbols_per_average;
averages = floor(temp_time/avg_temp_time);

ACAJAHUARINGA 12
average_fft(1:avg_temp_time) = 0;
for a = 0:(averages-1)
subset_ofdm = ofdm_modulation(((a*avg_temp_time)+1):((a+1)*avg_temp_time));
subset_ofdm_f = abs(fft(subset_ofdm));
average_fft = average_fft + (subset_ofdm_f/averages);
end
average_fft_log = 20*log10(average_fft);
figure (6)
plot((0:(avg_temp_time-1))/avg_temp_time, average_fft_log)
hold on
plot(0:1/IFFT_bin_length:1, -35, 'rd')
grid on
axis([0 0.5 -40 max(average_fft_log)])
ylabel('Magnitud (dB)')
xlabel('Frecuencia normalizada (0.5 = fs/2)')
title('Espectro de la señal OFDM')
%
% FIN DE LA GRAFICA
%

Figura 14 Espectro en frecuencial de una señal OFDM


%%
% Upconversion to RF
%
% Para este modelo, la banda base sera insertada directamente
% dentro del canal sin la conversion a las frecuencias RF
%
Tx_data = ofdm_modulation;
%
%------1-------2-------3-------4-------5-------6-------7-------8
%

ACAJAHUARINGA 13
>> Tx_data(1,1:30)
ans =
Columns 1 through 8
0.3906 0.0011 -0.2997 -0.0019 0.1010 0.0001 0.0545 0.0018
Columns 9 through 16
-0.0780 -0.0013 0.0093 -0.0009 0.0468 0.0019 -0.0337 -0.0004
Columns 17 through 24
-0.0152 -0.0017 0.0353 0.0015 -0.0092 0.0006 -0.0232 -0.0020
Columns 25 through 30
0.0220 0.0007 0.0059 0.0015 -0.0226 -0.0017

Figura 15 Algunos valores de los datos transmitidos

%
% CANAL ========================================================
%
% El modelo para el canal es unicamente el Gaussiano (AWGN)
% - El desvanecimiento de Rayleigh seria una adicion util
%
Tx_signal_power = var(Tx_data);
%
linear_SNR = 10^(SNR/10);
noise_sigma = Tx_signal_power/linear_SNR;
noise_scale_factor = sqrt(noise_sigma);
%
noise = randn(1, length(Tx_data))*noise_scale_factor;
Rx_Data = Tx_data + noise;
%

En la figura 16 se muestran los parámetros que modelan al canal para la tx y rx de señales


OFDM, así como la ventana de Matlab con las variables en memoria

Tx_signal_power = var(Tx_data);
Tx_signal_power =
3.8148e-04
linear_SNR = 10^(SNR/10);
linear_SNR =
10
noise_sigma = Tx_signal_power/linear_SNR;
noise_sigma =
3.8148e-05
noise_scale_factor = sqrt(noise_sigma);
noise_scale_factor =
0.0062
noise = randn(1, length(Tx_data))*noise_scale_factor;
Rx_Data = Tx_data + noise;

Figura 16 Resultados numéricos

ACAJAHUARINGA 14
Figura 17 grafica de la señal noise Figura 18 Grafica de la señal Rx_Data
%
% RECEPTOR <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
%
% Conversion del flujo serial de datos de entrada a un flujo paralelo
% (de acuerdo a la longitud del simbolo y numero de simbolos)
% - cada columna es un simbolo en un periodo
% - la longitud de cada simbolo (muestras / simbolo) es lal
% longitud de la IFFT que se uso para generarla
%
Rx_Data_matrix = reshape(Rx_Data, IFFT_bin_length, symbols_per_carrier + 1);
%
>> Rx_Data_matrix(1:20,1:10)
ans =
0.3880 0.1089 0.0807 0.0963 0.0539 0.0741 0.0585 0.0805 0.0690 0.0969
-0.0092 0.0494 0.0544 0.0623 0.0815 0.0550 0.0602 0.0623 0.0640 0.0508
-0.2989 -0.1080 -0.0510 -0.0719 -0.0414 -0.0570 -0.0573 -0.0720 -0.0571 -0.0540
-0.0001 -0.0287 -0.0302 -0.0370 -0.0496 -0.0171 -0.0405 -0.0234 -0.0368 -0.0254
0.0939 0.0726 0.0097 0.0128 0.0217 0.0122 0.0637 0.0301 0.0183 0.0269
0.0075 0.0034 0.0097 0.0197 0.0189 -0.0050 0.0158 -0.0157 0.0254 -0.0081
0.0619 -0.0225 0.0124 0.0302 0.0106 0.0158 -0.0233 0.0179 0.0288 0.0284
0.0016 0.0007 -0.0145 -0.0077 -0.0063 -0.0057 0.0070 0.0420 0.0193 0.0214
-0.0760 -0.0218 -0.0216 -0.0334 -0.0219 -0.0125 0.0046 -0.0223 -0.0330 -0.0469
-0.0003 -0.0023 0.0180 0.0165 0.0052 0.0289 -0.0003 -0.0237 -0.0126 -0.0146
0.0082 0.0022 -0.0101 0.0065 0.0217 0.0078 0.0135 0.0125 0.0201 0.0253
0.0036 -0.0241 -0.0087 -0.0137 -0.0131 -0.0101 0.0080 -0.0007 0.0129 -0.0117
0.0431 0.0143 0.0353 0.0120 -0.0273 -0.0035 -0.0193 0.0158 0.0005 0.0080
0.0154 0.0246 0.0262 0.0082 -0.0108 -0.0161 -0.0167 0.0079 0.0104 0.0299
-0.0345 -0.0211 -0.0302 -0.0154 0.0237 0.0227 0.0022 -0.0350 -0.0029 -0.0185
0.0003 -0.0401 -0.0095 0.0104 0.0231 0.0365 0.0094 -0.0083 -0.0138 -0.0093
-0.0086 -0.0005 0.0102 0.0235 -0.0207 -0.0256 0.0086 -0.0026 0.0014 0.0222
-0.0013 0.0184 -0.0186 -0.0075 -0.0211 -0.0295 -0.0044 -0.0065 0.0149 -0.0164
0.0347 0.0418 -0.0028 -0.0009 0.0159 0.0191 -0.0046 0.0320 0.0015 -0.0247
-0.0036 -0.0009 0.0317 0.0038 0.0316 -0.0199 -0.0150 0.0162 -0.0362 0.0002

Figura 19 Algunos valores numéricos de la señal OFDM recibida

ACAJAHUARINGA 15
%%
% Transformacion de cada simbolo en el tiempo
% al dominio de la frecuencia
% - tomar la fft de cada columna
%
Rx_spectrum = fft(Rx_Data_matrix);%
%

En la figura 20 se muestran las variables creadas por


la ejecución de la sección mostrada.

Figura 20

%%
% GRAFICA DE LA REPRESENTACION EN
% EL DOMINIO DE LA FRECUENCIA
%
figure (7)
stem(0:IFFT_bin_length-1, abs(Rx_spectrum(1:IFFT_bin_length,2)),'b*-')
grid on
axis ([0 IFFT_bin_length -0.5 1.5])
ylabel('Magnitud')
xlabel('BIN FFT')
title('Espectro de la OFDM recibida, Magnitud')
figure (8)
plot(0:IFFT_bin_length-1, (180/pi)*angle(Rx_spectrum(1:IFFT_bin_length,2)),
'go')
hold on
stem(carriers-1, (180/pi)*angle(Rx_spectrum(carriers,2)),'b*-')
stem(conjugate_carriers-1,
(180/pi)*angle(Rx_spectrum(conjugate_carriers,2)),'b*-')
axis ([0 IFFT_bin_length -200 +200])
grid on
ylabel('Fase (grados)')
xlabel('bin FFT')
title('Espectro de la OFDM recibida, Fase')
%
% FIN DE LA GRAFICA

En las figuras 21 y 22 se muestran las gráficas de la señal OFDM recibidos, tanto en magnitud
como fase.

ACAJAHUARINGA 16
Figura 21

Figura 22

%%
% Extraccion de los bin FFT de las portadoras
% - solo mantenga los bins fft que se usan como portadoras
% - tomar la transpuesta de la resultante para que cada
% columna represente una portadora
% - esto está en preparación para usar la función diff ()
% más tarde para decodificar la codificación diferencial
% - el formato después de esta operación es:
%

ACAJAHUARINGA 17
% C1-s1 C2-s1 C3-s1 ...
% C1-s2 C2-s2 C3-s2 ...
% C1-s3 C2-s3 C3-s3 ...
% . . .
% . . .
%
% - NOTA IMPORTANTE DE MATLAB RELATIVA A LA TRANSPOSICIÓN Y CONJUGACIÓN
% - parece que cada vez que se transpone una matriz,
% se toma, tambien, la conjugada de cada valor
% - si se realiza un número par de
transposiciones,
% entonces es transparente
% - obviamente, esto no afecta los
números reales
%
Rx_carriers = Rx_spectrum(carriers,:)';
%

Figura 23

%%
% GRAFICA DE CADA SIMBOLO RECIBIDO
%
figure (9)
Rx_phase_P = angle(Rx_carriers);
Rx_mag_P = abs(Rx_carriers);
polar(Rx_phase_P, Rx_mag_P,'bd');
%
% FIN DE LA GRAFICA

Figura 24

ACAJAHUARINGA 18
%%
% Hallando la fase (angulo) de cada bin FFT (cada portadora)
% - convertir de radianes a grados
% - normalizar la fase para que este entre 0 y 359 grados
%
Rx_phase = angle(Rx_carriers)*(180/pi);
phase_negative = find(Rx_phase < 0);
Rx_phase(phase_negative) = rem(Rx_phase(phase_negative)+360,360);
%
%%
% Extraccion de las diferencias de fase (de la codificacion diferencial)
% - la funcion de Matlab diff( ) es perfecta para esta operacion
% - de nuevo, normalizar la resultante para que este dentro de
% 0 a 359 grados
%
Rx_decoded_phase = diff(Rx_phase);
phase_negative = find(Rx_decoded_phase < 0);
Rx_decoded_phase(phase_negative) =
rem(Rx_decoded_phase(phase_negative)+360,360);
%

Figura 25 Variables creadas por la ejecución del script de la sección


%%
%
% Convercion de la fase a símbolo
% - calcular la fase base que es la diferencia de fase
% entre dos símbolo consecutivo
% - por ejemplo, si hay 2 bits por símbolo, la fase
% base es 90 y los símbolos están representados
% por 0, 90, 180 y 270 grados
% - calcular la desviación máxima de las fases base
% que seguirá siendo decodificado como fase base
% - por ejemplo, si la fase base es 90, entonces la
% fase delta es 45, y cualquier cosa dentro de los
% 45 grados de la fase base es aceptado como fase base
% - continuando el ejemplo anterior, un símbolo
% representado por 180 será decodificado como 180
% siempre que esté dentro del rango 180 + 45 y 180-45
% - genere una matriz de símbolos con los resultados de la
% decodificación de fase

ACAJAHUARINGA 19
% - tenga en cuenta que dado que la matriz se crea como
% una matriz cero, entonces los valores de cero no
% tienen que ser decodificados
% - cero es por lo tanto el valor predeterminado después
% de la decodificación, si un valor no se decodifica
% como cualquier otra cosa, entonces es cero
% - esto realmente ahorra muchos problemas ya que la fase
% cero abarca a los valores de fase más bajos y más altos
% y, por lo tanto, requiere de un especial procesamiento
% - también es eficiente ya que elimina un paso a través del lazo
%
base_phase = 360/2^bits_per_symbol;
delta_phase = base_phase/2;
Rx_decoded_symbols = zeros(size(Rx_decoded_phase,1),size(Rx_decoded_phase,2));
%
for i = 1:(2^bits_per_symbol - 1)
center_phase = base_phase*i;
plus_delta = center_phase+delta_phase;
minus_delta = center_phase-delta_phase;
decoded = find((Rx_decoded_phase <= plus_delta) & (Rx_decoded_phase >
minus_delta));
Rx_decoded_symbols(decoded)=i;
end
%

Figura 26 Creación de las variables que contienen la data de la conversión de fase a símbolo

ACAJAHUARINGA 20
%%
% Conversion de la matriz en un flujo de simbolos sriales
%
Rx_serial_symbols =
reshape(Rx_decoded_symbols',1,size(Rx_decoded_symbols,1)*size(Rx_decoded_symbols
,2));
%
%%
% Conversion de los simbolos a binarios
%
for i = bits_per_symbol: -1: 1
if i ~= 1
Rx_binary_matrix(i,:) = rem(Rx_serial_symbols,2);
Rx_serial_symbols = floor(Rx_serial_symbols/2);
else
Rx_binary_matrix(i,:) = Rx_serial_symbols;
end
end
baseband_in =
reshape(Rx_binary_matrix,1,size(Rx_binary_matrix,1)*size(Rx_binary_matrix,2));

%%
% Hallando los errores de bit
%
bit_errors = find(baseband_in ~= baseband_out);
bit_error_count = size(bit_errors,2);
%------1-------2-------3-------4-------5-------6-------7-------8

Figura 27 Variables creadas para medir la cantidad de errores de bits

ACAJAHUARINGA 21
>> Rx_decoded_symbols(1:20,1:10)
>> base_phase = 360/2^bits_per_symbol ans =
3 3 1 2 3 3 3 2 1 0
base_phase =
2 0 0 2 1 0 3 2 2 2
90
3 2 2 2 0 2 0 0 0 2

>> delta_phase = base_phase/2 2 0 0 2 1 1 2 1 1 3


3 3 3 2 3 2 1 3 1 2
delta_phase =
3 1 2 2 2 2 1 1 2 0
45
0 1 1 2 2 0 0 2 0 3
>> Rx_serial_symbols(1,1:20) 2 1 1 2 1 2 3 2 2 0
1 1 3 1 1 3 0 2 2 3
ans =
1 0 3 0 2 1 3 3 2 0
1 1 0 1 1 1 1 1 0 0 1 0 1 0 1 1 0 1 0 0 0 0 3 0 0 1 3 0 3 2
3 3 2 3 0 3 1 1 1 2
>> Rx_binary_matrix(1:2,1:15)
0 3 2 1 2 0 1 0 0 3

ans = 1 0 1 0 2 3 0 0 2 2
1 2 2 2 1 1 3 2 2 3
1 1 0 1 1 1 1 1 0 0 1 0 1 0 1 1 0 1 0 3 3 0 3 3 1
1 1 1 0 1 1 1 0 1 0 1 0 1 1 1
1 3 2 0 0 3 3 3 3 1
>> bit_errors(1,1:15) 2 0 0 3 2 1 3 1 3 1
0 2 0 0 3 0 2 3 0 0
ans = 2 0 2 1 3 2 2 2 3 0

2 4 7 8 10 12 14 15 16 17 22 26 27 30 32

>> bit_error_count

bit_error_count =
8909
Figura 28Variables para calcular la tasa de errores, así como la variable de símbolos
decodificados

La cantidad de bits trasmitidos, de acuerdo a los parámetros por defecto de la transmisión


son:

𝑩𝒊𝒕𝒔 𝒂 𝒕𝒓𝒂𝒔𝒎𝒊𝒕𝒊𝒓 = 𝑵𝒐 𝒅𝒆 𝒑𝒐𝒓𝒕𝒂𝒅𝒐𝒓𝒂𝒔 𝒙 𝒃𝒊𝒕𝒔 𝒑𝒐𝒓 𝒔𝒊𝒎𝒃𝒐𝒍𝒐 𝒙 𝑺𝒊𝒎𝒃𝒐𝒍𝒐 𝒑𝒐𝒓 𝒑𝒐𝒓𝒕𝒂𝒅𝒐𝒓𝒂


𝒃𝒊𝒕𝒔 𝒔𝒊𝒎𝒃𝒐𝒍𝒐𝒔
𝑩𝒊𝒕𝒔 𝒂 𝒕𝒓𝒂𝒔𝒎𝒊𝒕𝒊𝒓 = 𝟐𝟎𝟎 𝒑𝒐𝒓𝒕𝒂𝒅𝒐𝒓𝒂𝒔 𝒙 𝟐 𝒙 𝟓𝟎 = 𝟒𝟎, 𝟎𝟎𝟎 𝒃𝒊𝒕𝒔
𝒔𝒊𝒎𝒃𝒐𝒍𝒐 𝒑𝒐𝒓𝒕𝒂𝒅𝒐𝒓𝒂

La cantidad de bits errados, para el sistema OFDM (considerando que todas las portadoras
transmiten) es de 8909.

ACAJAHUARINGA 22