106929435 Diseno y Realizacion de Un Modulador Demodulador COFDM Sobre SoundBlaster Copia

Proyecto Fin de Carrera

Ingeniería de Telecomunicación

Diseño y realización de un

modulador/demodulador COFDM

sobre SoundBlaster

Autora: Inés María Pérez Ortega

Tutor: D. José Ramón Cerquides Bueno Departamento de Ingeniería Electrónica

Área de Teoría de la Señal y Comunicaciones Universidad de Sevilla

Septiembre 2003

2

Agradecimientos

Me gustaría dar las gracias a mi profesor y tutor D. José Ramón Cerquides Bueno por permitirme realizar con él este proyecto tan interesante, variado, práctico y motivador. También agradezco la amable atención y orientación que me ha prestado siempre que he necesitado consultarle.

Por supuesto, quiero dar las gracias a mis padres y hermanos por apoyarme,

confiar en mí y por proporcionarme todo lo necesario a lo largo de este proyecto, sobre todo cuando me han surgido problemas técnicos con mi PC durante la realización del mismo.

Por último, me gustaría agradecer especialmente a David todo el ánimo, todo el

apoyo, todo el tiempo que me ha dedicado y toda la ayuda que me ha proporcionado, porque gracias a él he sido capaz de realizar este trabajo.

3

Índice de contenidos 1. Introducción............................................................................................................ 6 2. Estudio del canal de comunicaciones............................................................. 8

2.1 Configuración del mezclador............................................................................. 9 2.2 Análisis del ruido presente en el sistema ........................................................ 14 2.3 Respuesta frecuencial del canal de comunicaciones...................................... 16

3. Modulador/demodulador COFDM .............................................................. 18

3.1 Introducción...................................................................................................... 18

3.1.1 Modulación multiportadora............................................................................ 18 3.1.2 Sistemas digitales de radiodifusión: modulación COFDM................................ 20 3.1.3 Historia de la modulación .............................................................................. 23 3.1.4 Ventajas de la Modulación............................................................................. 24

3.1.4.1 Igualación ........................................................................................ 24 3.1.4.2 Protección contra desvanecimientos....................................................... 24 3.1.4.3 Redes de frecuencia única.................................................................... 25

3.1.5 Esquema del sistema OFDM .......................................................................... 25

3.2 Transmisor COFDM ........................................................................................ 29

3.2.1 Bloques para corrección de errores ................................................................. 29

3.2.1.1 Codificador Reed-Solomon.................................................................. 31 3.2.1.2 Codificador convolucional ................................................................... 31

3.2.2 Conversor Serie-Paralelo ............................................................................... 33 3.2.3 Modulador QAM...................................................................................................33 3.2.4 Extensión del espectro................................................................................... 36 3.2.5 IFFT ............................................................................................................ 36 3.2.6 Inserción del intervalo de guarda.................................................................... 38 3.2.7 Conversor Paralelo-Serie ......................................................................................39 3.2.8 Bloques no incluidos en el transmisor implementado....................................... 39

3.2.8.1 Aleatorizador de Energía ..................................................................... 40 3.2.8.2 Barajador Externo.............................................................................. 41 3.2.8.3 Barajador interno ............................................................................... 42

Índice de contenidos

4

3.3 Receptor COFDM............................................................................................. 44

3.3.1 Conversor Serie-Paralelo ............................................................................... 44 3.3.2 Eliminación del intervalo de guarda................................................................ 45 3.3.3 FFT.............................................................................................................. 45 3.3.4 Reducción del espectro .................................................................................. 46 3.3.5 Igualador de canal ......................................................................................... 47 3.3.6 Demodulador QAM ...................................................................................... 48 3.3.7 Conversor Paralelo-Serie ............................................................................... 48 3.3.8 Decodificador Convolucional......................................................................... 48 3.3.9 Decodificador Reed-Solomon ........................................................................ 50 3.3.10 Bloques no incluidos en el receptor .............................................................. 50

3.3.10.1 Desbarajador Interno ...............................................................................51 3.3.10.2 Desbarajador Externo ....................................................................... 52 3.3.10.3 Desaleatorizador de Energía............................................................... 53

3.4 Programación en MATLAB del modem COFDM .............................................. 54

3.4.1 Programa principal........................................................................................ 55 3.4.2 Transmisor ................................................................................................... 59

3.4.2.1 Codificación Reed-Solomon ................................................................ 62 3.4.2.2 Codificación Convolucional ................................................................ 65 3.4.2.3 Modulador QAM............................................................................... 69 3.4.2.4 Inserción del supersímbolo de entrenamiento .......................................... 73 3.4.2.5 Extensión del espectro ........................................................................ 74 3.4.2.6 IFFT ............................................................................................... 78 3.4.2.7 Inserción del intervalo de guarda .......................................................... 79 3.4.3.8 Conversión Paralelo/Serie ................................................................... 80 3.4.3.9 Inserción de sincronismo..................................................................... 81

3.4.3 Receptor....................................................................................................... 83

3.4.3.1 Detección de sincronismo ..........................................................................86 3.4.3.2 Conversor Serie/Paralelo..................................................................... 87 3.4.3.3 Eliminación del intervalo de guarda ...................................................... 88 3.4.3.4 FFT ................................................................................................ 89 3.4.3.5 Reducción del espectro ....................................................................... 90 3.4.3.6 Extracción del supersímbolo de entrenamiento ........................................ 91 3.4.3.7 Igualador de canal.............................................................................. 92 3.4.3.8 Demodulador QAM ........................................................................... 93 3.4.3.9 Decodificador Convolucional............................................................... 95 3.4.3.10 Decodificador Reed-Solomon............................................................. 98

4. Sincronización.................................................................................................... 101

4.1 Sincronización de símbolo.............................................................................. 101

4.1.1 Errores de temporización ............................................................................. 101 4.1.2 Sincronización de trama y símbolo en el sistema implementado ..................... 102 4.1.3 Ruido de fase de la portadora ..............................................................................107

Índice de contenidos

5

4.2 Sincronización de la frecuencia de muestreo ............................................... 107

4.2.1 Sincronización de la frecuencia de muestreo en el sistema implementado.........108

4.2.1.1 Cálculo del desajuste de frecuencias de muestreo................................... 108

4.3 Sincronización de la frecuencia de la portadora.......................................... 110

4.3.1 Errores de frecuencia................................................................................... 110 4.3.2 Estimadores de frecuencia ........................................................................... 112

5. Entorno gráfico.................................................................................................. 113

5.1 Interfaz gráfico de usuario de MATLAB (GUI).......................................... 113

5.1.1 Entorno de desarrollo de la GUI .........................................................................113 5.1.2 Ficheros generados por el GUIDE ......................................................................114 5.1.3 Características del fichero-M ..............................................................................114 5.1.4 Creación de la GUI..............................................................................................115

5.1.4.1 Programación de la GUI ................................................................... 117

5.2 Resultado de las pruebas realizadas ............................................................. 122

6. Conclusiones ....................................................................................................... 128 6.1 Posibles mejoras y líneas de continuación.................................................... 128

Apéndice A. Códigos lineales de bloques: Códigos Reed-Solomon ..... 130 Apéndice B. Códigos convolucionales ............................................................ 135 Apéndice C. Código MATLAB del entorno gráfico.................................. 143

6

Capítulo 1 Introducción

La tarjeta de sonido del PC además de permitir la reproducción y adquisición de señales de audio, puede también utilizarse como convertidor A/D y D/A, permitiendo así el desarrollo de numerosas aplicaciones, incluyendo el área de transmisión de datos. En este proyecto se utilizará dicha tarjeta para programar un sistema de comunicaciones en banda base que utilice una modulación COFDM.

La modulación COFDM (Coded-Ortogonal-Frequency-Division-Multiplexing) realiza una multiplexación por división en frecuencia donde las frecuencias son ortogonales entre sí. Esta modulación es especialmente adecuada para comunicaciones de alta velocidad (p.e. sistemas digitales de radiodifusión y de comunicaciones móviles) debido a su resistencia a la interferencia entre símbolos (ISI).

Los sistemas de comunicación aumentan cada vez más la velocidad de

transmisión de la información y por lo tanto, se reduce el tiempo para cada transmisión. Dado que el retardo temporal causado por el multitrayecto (problema importante de la radiocomunicación) permanece constante, la ISI se convierte en una limitación en las comunicaciones con alta tasa de datos. COFDM evita este problema enviando muchas transmisiones de baja velocidad simultáneamente, lo que aumenta el periodo de los símbolos que se envían y por tanto, se disminuye la ISI. Además, COFDM utiliza codificación para la corrección de errores lo que hace al sistema más robusto. Otra razón para considerar COFDM es la baja complejidad de su implementación para sistemas de alta velocidad si se compara con las técnicas tradicionales de portadora única.

A lo largo del proyecto se hará un estudio exhaustivo de la modulación enfocado

a su posterior implementación práctica. A continuación se presentan las distintas partes de que se compone este proyecto

explicándose brevemente lo que se realiza en cada una de ellas:

Estudio del canal de comunicaciones En este apartado se realizará un análisis y caracterización del canal de comunicaciones formado por la tarjeta de sonido y el cable de audio, obteniéndose conclusiones acerca de la respuesta frecuencial del sistema y el ancho de banda que ocupa. También se realizará una estimación del ruido presente en sistema.

Introducción

7

Modulador/Demodulador COFDM En este apartado se realizará, en primer lugar, un estudio teórico de la modulación COFDM y de los bloques que forman el modulador y el demodulador. En segundo lugar se programarán en MATLAB las rutinas que permitan la modulación/demodulación de las señales transmitidas o recibidas por la tarjeta de sonido, integrándose estas en un único programa que verifica si la comunicación ha sido correcta mostrándose los valores de la BER (bit error rate), la SER (symbol error rate), la tasa neta de transmisión de datos y el tiempo que dura la ejecución del programa.

Sincronización En este apartado se realiza un estudio exhaustivo de la sincronización en los sistemas OFDM explicándose la forma en que se ha llevado a cabo ésta en este sistema particular.

Entorno gráfico En este apartado se explica la programación en MATLAB del entorno gráfico creado para la aplicación práctica, mostrándose así mismo la apariencia del mismo. Se presentan también los resultados de las diversas pruebas de simulación realizadas.

Conclusiones

Para finalizar se presentan las conclusiones obtenidas del estudio realizado así como las posibles mejoras o líneas de continuación.

8

Capítulo 2 Estudio del canal de comunicaciones

En este apartado trataremos de obtener conclusiones acerca de la respuesta frecuencial del canal o sistema de comunicaciones y el ancho de banda que ocupa, así como realizar una estimación del ruido presente en sistema. En nuestro caso el canal de comunicaciones estará formado por el cable de audio y la tarjeta de sonido del PC. El cable de audio conecta las líneas LINE IN (o Línea de entrada) y LINE OUT (o Línea de salida) de la misma tarjeta de sonido que estará configurada en modo full-duplex, ya que este modo permite reproducir y grabar datos simultáneamente, por lo que la comunicación (transmisión y recepción), se realiza dentro de un único ordenador.

Figura 2.1. Esquema simplificado del sistema de comunicaciones

También se podría simular la comunicación entre dos ordenadores conectando la línea de entrada de un ordenador (receptor) con la de salida del otro (transmisior), pero por simplicidad todas las pruebas prácticas de este proyecto se desarrollarán en un PC con una sola tarjeta de sonido. Dado que un análisis y caracterización de este canal de comunicaciones ya fueron llevados a cabo en un proyecto anterior, nos limitaremos a verificar las conclusiones obtenidas entonces.

Estas conclusiones fueron:

El canal de comunicaciones es un canal paso-banda (BP) pese a que a simple

vista parece tratarse de un canal paso-bajo (LP). Esto se comprueba ya que al transmitir una señal continua, en recepción vemos que se bloquea la DC.

TX/RX

TARJETA DE SONIDO

LINE IN

LINE OUT

CA

BLE

DE

AU

DIO

A/D

D/AONDA

Control de Volumen

Estudio del canal de comunicaciones

9

Además, esto se puede apreciar también al hacer un zoom a bajas frecuencias de la respuesta frecuencial del sistema.

El ancho de banda del canal es aproximadamente 20 KHz, ya que se extiende

desde los 20 Hz hasta algo menos de los 20 KHz.

La respuesta frecuencial no es totalmente plana, lo cual nos obligará en recepción, a introducir un bloque de ecualización o igualación de canal, con objeto de contrarrestar la atenuación producida por el cable en ciertas bandas de frecuencia.

El ruido presente en el sistema no es tan importante como para que haya que

realizar un filtrado de Wiener , de forma que la ecualización será suficiente y eficiente si se lleva a cabo con un filtrado que no tenga en cuenta el ruido como, por ejemplo, filtrado inverso o de cero forzado (ZF).

Antes de verificar estas conclusiones, debemos mencionar que la tarjeta de

sonido que usaremos para llevar a cabo la comunicación no es una SoundBlaster como la que se utilizó en el proyecto anterior, sino que en nuestro caso usaremos una tarjeta de sonido integrada en la placa base que es como se encuentran en la mayoría de los PC´s actuales y el modelo utilizado es el SiS 7012 Wave. Es posible, por tanto, que aunque el cable de audio sea prácticamente igual al utilizado en el proyecto anterior, al usarse una tarjeta de sonido diferente podamos obtener algunas conclusiones ligeramente distintas a las anteriores.

A continuación comprobaremos estas conclusiones con la ayuda de MATLAB

pero sin detenernos en detalles, por lo que nos limitaremos a verificar que el canal es efectivamente paso-banda, que su ancho de banda es aproximadamente 20 KHz y que el ruido del canal no es importante.

2.1 Configuración del mezclador

Antes de llevar a cabo estas comprobaciones acerca del canal de comunicaciones es importante, en primer lugar, realizar los ajustes adecuados en el mezclador de la tarjeta de sonido (SiS 7012 Wave) para conseguir nuestro propósito, que será el de transmitir un fichero de datos por el cable de audio y grabarlo para comprobar ciertas características de la transmisión realizada.

Debemos recordar que desde el mezclador de la tarjeta de sonido, lo que se hace internamente es controlar los amplificadores de esta. Las distintas fuentes que controlan estos amplificadores pueden ser de dos tipos:

INTERNAS (Onda, Midi y CD audio principalmente)

EXTERNAS ( Línea de Entrada y Micrófono)

Dentro del mezclador encontramos dos tipos de controles: reproducción y grabación. Con el de reproducción, controlamos lo que enviamos a la salida de la tarjeta


10

y con el de grabación, controlamos lo que queremos que la tarjeta de sonido registre cuando la ponemos a grabar fuentes externas.

Nuestro objetivo será generar una señal dentro del ordenador, enviarla por Línea de salida y recogerla por Línea de entrada, y para ello debemos cerrar los interruptores correspondientes en el mezclador seleccionando las propiedades de audio del control de volumen de Windows XP que se muestran a continuación:

En el Control de Volumen de Reproducción de sonido:

Silenciamos el Sintetizador SW, la Profundidad en 3D, el Reproductor de CD y

la Línea de entrada por lo que solo dejamos activos el Control de volumen (obligatorio, ya que si no, no saldría nada de la tarjeta) y la Onda (con esto permitimos el envío de un sonido procedente de un fichero almacenado en el PC).

En el Control de Grabación de Grabación de sonido:

Seleccionamos la Línea de entrada (para grabar solo lo que llegue por ahí)

dejando sin activar el Reproductor de CD y el Micrófono.

Con esto conseguimos reproducir un fichero interno y grabar sólo por la Línea de entrada, obviando las demás fuentes.


11

Una vez realizados todos los ajustes en el mezclador para reproducir y grabar correctamente, el siguiente paso es elegir el formato de audio que vamos a utilizar durante todo el proyecto. Para ello se explicamos en primer lugar lo que es el audio digital y los parámetros de dicho formato:

Una señal de audio es simplemente una serie de ondas de presión en movimiento. En la vida real esto no es más que una onda analógica, pero en el mundo digital debemos almacenar la señal como un conjunto de muestras a lo largo de esta onda. Una muestra es un valor que representa la amplitud de la onda en un instante temporal dado.

La tasa de muestreo indica con qué frecuencia tomamos una muestra de la onda. Se mide en hertzios (Hz) o muestras por segundo. Obviamente cuanto mayor sea la tasa de muestreo más parecida a la onda analógica se hace la onda muestreada, por lo tanto mejor será la calidad del sonido.

Otro factor que contribuye a la calidad del audio es el tamaño de cada muestra. Cuanto mayor sea el tamaño de la muestra más calidad de audio tendremos. El tamaño de las muestras se mide en bits. Consideremos una muestra de 8 bits. Esta tiene 256 (2^8) posibles valores. Esto significa que posiblemente no se puede representar el valor exacto de la amplitud de la onda con ella. Si consideramos ahora una muestra de 16 bits esta podrá representar 65536 posibles valores (2^16). Esto significa que puede representar la amplitud con una precisión 256 veces mayor que la muestra de 8 bits.

En cuanto a los canales que se usan, debemos tener en cuenta que en la mayoría de los sistemas se tienen 2 canales, el izquierdo y el derecho. Esto significa que se debe almacenar una muestra para el canal izquierdo y otra para el canal derecho. Afortunadamente esto se hace de forma fácil con 2 canales ya que las muestras se entrelazan, lo que significa que las muestras se almacenan, izquierda, derecha, izquierda, derecha,… y esto es lo que se llama formato de sonido estéreo.

La calidad de audio de CD muestrea a 44100 Hz, tiene un tamaño de muestra de 16 bits y usa 2 canales. Esto significa que 1MB de audio dura aproximadamente 6 segundos.

Para optimizar los resultados el formato de audio que usaremos será el siguiente: PCM 44100 Hz/48000Hz; 16 bits; mono (calidad de CD con un solo canal)

− El formato de sonido PCM no modula pulsos codificados como se podría pensar sino que es un sistema de codificación de pulsos modulados, codifica la señal (realizando previamente un muestreo y cuantización de la misma) para convertirla en digital.

− Se ha elegido la frecuencia de muestreo 44100 Hz dado que la calidad de CD es

la más extendida popularmente, aunque finalmente se ha añadido también la frecuencia de muestro de 48000Hz ya que la mayoría de las tarjetas actuales permiten también el uso de esta frecuencia. Una frecuencia de muestreo de 44100 Hz nos indica que en la duración de un segundo, tendremos 44100 muestras o lo que es lo mismo, que la separación entre muestra y muestra (tiempo de muestra) será de 1/44100 segundos.


12

− Este formato utilizará 16 bits para codificar cada muestra, esto significa que en

rango de 16 bits, una muestra podrá ser codificada con los números enteros entre -32768 y 32767 que, el programa MATLAB lo normaliza y equivale al rango -1 y 1.

− Por último, dado que sólo usaremos un canal de transmisión, el formato de

sonido es mono, y no estéreo, ya que éste equivaldría realmente a dos canales. A continuación deberemos realizar un ajuste de amplitudes en el transmisor y el

receptor para que todo funcione correctamente. Se trata de que la señal transmitida no se sature ni tampoco se atenúe en exceso. Estos fenómenos son debidos a los amplificadores del mezclador de la tarjeta de sonido por lo que antes de comenzar la transmisión de la señal deberemos calibrar su ganancia.

Para ello transmitiremos una señal senoidal de 4 KHz de amplitud máxima con

la configuración actual del mezclador, si la señal recibida aparece cortada o por el contrario muy atenuada deberemos ajustar las ganancias de los amplificadores de Onda y Control de Volumen ,en reproducción, y Línea de entrada ,en grabación, hasta lograr que la respuesta a esta senoide tenga máxima amplitud sin que llegue a cortarse por excesivo nivel de señal de entrada, ya que pretendemos usar todo el rango dinámico sin que se sature la señal.

El programa MATLAB que nos permite el ajuste de amplitudes es:

%Programa calibra. Envía una señal senoidal a través del canal y registra la %señal recibida calculando también su transformada de Fourier. Representa %también tanto la señal recibida como su espectro en frecuencia. while 1==1 frecMue = 44100; frecSin = 4000; durSin = 0.1;

numMue = frecMue * durSin; pasoSin = 2*pi*frecSin/frecMue;

t = ( 1:numMue ) * pasoSin; tx = sin(t); wavplay(tx, frecMue, 'async'); %%%%%%%%%% rx = wavrecord(numMue, frecMue, 1, 'double')';

esp = fft(rx(ceil(numMue/4):ceil(3*numMue/4))); f = 0:((frecMue/2+1)/(length(esp)/2)):(frecMue/2);

subplot(2,1,1),plot(rx); axis([(numMue/2-100) (numMue/2+100) -1 1]); xlabel('Indice temporal n');ylabel('Amplitud'); title('Señal senoidal recibida');

subplot(2,1,2),plot(f,20*log(abs(esp(1:ceil(length(esp)/2))))); axis([0 (frecMue/2) -100 150]); xlabel('Frecuencia');ylabel('Amplitud'); title('Espectro frecuencial de la señal recibida'); pause; clf reset;


13

end

El objetivo de este programa es ajustar el rango dinámico del transmisor y el receptor y para ello genera una señal senoidal de 4 KHz de frecuencia, la transmite a través de la tarjeta de sonido (a través de la fuente interna Onda mediante la función wavplay), y al mismo tiempo va grabando por la línea de entrada lo recibido a través del canal (mediante la función wavrecord). Para poder realizar los ajustes fácilmente se representa además de la señal recibida, el espectro frecuencial de esta señal con el fin de apreciar si aparecen armónicos y por lo tanto saber si los amplificadores saturan la señal. El programa se engloba dentro de un bucle infinito para poder ir cambiando los valores de ganancia de los amplificadores y al mismo tiempo poder visualizar la señal recibida y así se consigue calibrar el mezclador de forma fácil y cómoda.

Como ya habíamos indicado lo que debemos tener en cuenta para realizar los ajustes es lo siguiente:

Los amplificadores con ganancia alta pueden distorsionar la señal. Los amplificadores pueden saturar la señal. Se desea utilizar todo el rango dinámico.

Los amplificadores con los que jugamos son el de Onda, el de Control de

Volumen y el de Línea de Entrada. Para tratar el problema de la distorsión lo que hacemos es bajar mucho uno de

ellos y poner los otros al máximo de ganancia pero de forma que la señal no se sature. Por el espectro comprobamos que el rango dinámico es bajo y que no se produce distorsión, por lo que no aparecen armónicos en el espectro, debido a que los amplificadores estén configurados con ganancia máxima. Esto implica que no tendremos restricciones de ganancia en los amplificadores.

Por otro lado habrá que ajustar la saturación de la señal, para ello nos fijaremos

en que el seno no aparezca truncado y que no aparezcan picos en el espectro, ya que esto significa que aparecen armónicos y por lo tanto habría saturación. Realizando varias pruebas con distintas configuraciones de los amplificadores llegamos a una solución de compromiso en la que vemos que el seno no se satura y además se aprovecha casi por completo el rango dinámico de señal permitido.

En MATLAB mostramos la senoide recibida y su espectro, donde como vemos no aparecen armónicos a otras frecuencias que no sean la fundamental (4 KHz):


14

2120 2140 2160 2180 2200 2220 2240 2260 2280 2300-1

-0.5

0

0.5

1

Indice temporal n

Am

plitu

d

Señal senoidal recibida

0 0.5 1 1.5 2

x 104

-100

-50

0

50

100

150

Frecuencia

Am

plitu

d

Espectro frecuencial de la señal recibida

Figura 2.1. Ajuste del mezclador.

Una vez realizados todos los ajustes del mezclador necesarios para la

comunicación pasaremos a analizar el ruido del canal. 2.2 Análisis de ruido del sistema

En este apartado trataremos de comprobar que el ruido presente en el sistema de comunicaciones es realmente escaso y podremos hacer consideraciones posteriores sobre el canal que nos simplifiquen mucho nuestro estudio.

Para llevar a cabo este análisis nos limitaremos a enviar a través del canal una cadena larga de ceros, es decir, como si no transmitiésemos nada, de forma que en recepción, tendremos el ruido presente en el sistema, y posiblemente interferencias procedentes de la red eléctrica y sus primeros armónicos: 50 Hz/100 Hz/150 Hz.

Con el siguiente programa MATLAB podemos calcular el ruido y su densidad

espectral de potencia:

%Programa txvacio. Realiza una transmisión de vacío a través del canal y %registra el ruido que aparece en el mismo calculando su densidad espectral. frecMue = 44100; durSin = 100; numMue = frecMue * durSin; tx = zeros(1,numMue); wavplay(tx, frecMue, 'async'); %%%%%%%%%%


15

rx = wavrecord(numMue, frecMue, 1, 'double')'; rx = rx(ceil(numMue/4):ceil(3*numMue/4)); subplot(2,1,1),plot(rx); title('Ruido recibido') xlabel('Numero de muestras'); ylabel('Amplitud'); [Snno,F] = PSD(rx,2046,44100); subplot(2,1,2),plot(F,10*log10(Snno));grid; xlabel('Frecuencia'); ylabel('Densidad espectral de ruido del sistema');

A continuación se muestra gráficamente el ruido presente en el sistema y su densidad de potencia.

0 0.5 1 1.5 2 2.5

x 106

-4

-3.5

-3

-2.5

-2

-1.5x 10-3 Ruido recibido

Numero de muestras

Am

plitu

d

0 0.5 1 1.5 2 2.5

x 104

-100

-80

-60

-40

-20

0

Frecuencia

Den

sida

d es

pect

ral d

e ru

ido

del s

iste

ma

Figura 2.2. Ruido presente en el sistema

Con esto podemos comprobar que el ruido presente en el sistema tiene una amplitud lineal de aproximadamente 0.0007 que aparece superpuesta sobre un valor de continua de -0.0027, por lo que vemos que la presencia de ruido en este sistema es un poco mayor que la que suponíamos, ya que en el estudio que se realizó anteriormente el ruido tomaba valores de amplitud 0.0001 aproximadamente. En este caso solo habrá que tener en cuenta este ruido en el diseño del detector en el receptor, ya que los puntos de la constelación se verán ligeramente alterados por el ruido, pero este problema será estudiado con más detalle en el capítulo 3.


16

2.3 Respuesta frecuencial del canal de comunicaciones

La función de transferencia del canal se puede obtener mediante la transmisión de una función impulso (delta) y viendo, en recepción, cuál es la respuesta impulsiva del sistema. Otra forma de obtener la respuesta frecuencial del sistema que además es más robusta que la transmisión de una delta, es hacer uso de la expresión:

)()()( 2 fSnnifHcfSnno ⋅=

donde debemos tener en cuenta que )( fSnno es la densidad espectral de potencia del ruido a la salida del sistema, )( fSnni es la densidad espectral de potencia del ruido a la

entrada y 2)( fHc es el módulo al cuadrado de la respuesta frecuencial del sistema.

Por tanto, para el cálculo de esta respuesta frecuencial haremos lo siguiente: Creamos un ruido blanco en MATLAB y le calculamos su densidad espectral de potencia )( fSnni , lo transmitimos por el canal, lo registramos en recepción y le calculamos también su densidad espectral de potencia )( fSnno . Ya tan solo nos queda

despejar en la ecuación 2)( fHc , que como vemos se obtiene de la división )()( fSnnifSnno . Veamos la rutina que permite hacer esto en MATLAB:

%Programa respfrec. Calcula la respuesta frecuencial del sistema. frecMue = 44100; frecSin = 4000; durSin = 100; numMue = frecMue * durSin; tx = wgn(1,numMue,5); tx = tx/max(abs(tx)); wavplay(tx, frecMue, 'async'); %%%%%%%%%%%%%%% rx = wavrecord(numMue, frecMue, 1, 'double')'; tx = tx(ceil(numMue/4):ceil(3*numMue/4)); rx = rx(ceil(numMue/4):ceil(3*numMue/4)); %Hacemos un recorte de las señales de ruido transmitidas %y recibidas para evitar problemas de transitorio a la %hora de transmitir y comenzar a grabar [Snni,F] = PSD(tx,2046,44100); [Snno,F] = PSD(rx,2046,44100); H2 = Snno./Snni; plot (F, 20*log10(H2));grid title('Respuesta frecuencial del sistema') xlabel('Frecuencia'); ylabel('Modulo');


17

0 0.5 1 1.5 2 2.5

x 104

-30

-25

-20

-15

-10

-5

0

5Respuesta frecuencial del sistema

Frecuencia

Mod

ulo

Figura 2.3. Respuesta frecuencial del sistema de comunicaciones

Como se puede comprobar en la gráfica obtenida, en nuestro caso el sistema

tiene un ancho de banda menor de 20 KHz (obtenemos un ancho de banda de unos 18 KHz si usamos el criterio de -3dB) que era el que suponíamos y además el canal en este caso no sólo es que deje pasar la continua sino que además tiene un pico negativo en la frecuencia cero. Esto suponemos que se debe a que la tarjeta de sonido no posee condensadores de desacoplo, algo que no es muy usual, y por esto aparece más ruido y el canal es paso-baja (LP).

De cualquier forma, y dado que la respuesta frecuencial no es plana sino que

decae con la frecuencia por tratarse de un canal de transmisión no ideal, supondremos que el ancho de banda de nuestro sistema es de aproximadamente 20 KHz (un poco inferior) que es la frecuencia a la que se produce una caída más abrupta de la respuesta frecuencial, aún así se procurará no transmitir nada a frecuencias muy bajas o muy altas dentro de esta banda para evitar errores en la comunicación.

18

Capítulo 3 Modulador/demodulador COFDM 3.1 Introducción 3.1.1 Modulación multiportadora

Cuando consideramos una transmisión digital a través canales no ideales observamos que estos canales causan interferencia entre símbolos cuando el inverso de la tasa de transmisión del sistema es mucho menor que la dispersión temporal (duración de la respuesta impulsiva) del canal no ideal. En tal caso se emplea un ecualizador para compensar la distorsión del canal. Si el canal es paso de banda con un ancho especificado, la señal de información debe ser generada en banda base y ser trasladada a la frecuencia del canal. Por lo tanto, la señal de información se transmite con una única portadora. También se puede observar que la interferencia entre símbolos normalmente produce una degradación en el rendimiento del sistema, incluso en el caso donde se usa un detector óptimo para recuperar los símbolos de información en el receptor. Una propuesta alternativa para el diseño de un sistema de comunicación paso-banda eficiente en presencia de distorsión del canal es la división del ancho de banda del canal disponible en un número de subcanales con igual ancho de banda, donde el ancho de banda de cada subcanal sea lo suficientemente estrecho para que la respuesta impulsiva de cada subcanal sea aproximadamente ideal. Por lo tanto, creamos

fWK ∆= / subcanales, donde símbolos diferentes de información pueden ser transmitidos simultáneamente en los K subcanales. Como consecuencia, los datos son transmitidos mediante multiplexión por división en frecuencia (FDM). Con cada subcanal asociamos una portadora

tftx kk π2sin)( = , 1,...,1,0 −= kk [3.1] donde kf es la frecuencia central en el subcanal k . Si se elige la tasa de símbolo T/1 de cada subcanal que sea igual a la separación f∆ entre subportadoras adyacentes, las subportadoras son ortogonales en el intervalo símbolo T , independientemente de la relación relativa de fase entre subportadoras; es decir,

0)2sin()2sin(0

=++∫ dttftf j

T

jkk φπφπ [3.2]

Modulador/demodulador COFDM

19

donde Tnff jk /=− , ,...2,1=n , independientemente de los valores de las fases kφ y

jφ . En este caso, tenemos un sistema con multiplexación por división en frecuencias ortogonales (OFDM).

La modulación OFDM tiene como fin fundamental adecuar los datos que se quieren transmitir a las características del canal empleado. Esta modulación es un sistema de transmisión en paralelo, es decir, varios datos son transmitidos en el mismo instante de tiempo por múltiples portadoras, portadoras que se eligen de forma que sean ortogonales entre sí de la forma mencionada anteriormente.

La ortogonalidad de las portadoras puede ser mantenida siempre y cuando el canal no introduzca interferencia entre símbolos (ISI). En la práctica los canales siempre introducen ISI y para prevenirla se utiliza en esta modulación el concepto de intervalo de guarda, que se explicará más adelante de forma detallada.

PORTADORAS

Figura 3.1. Los espectros de las portadoras moduladas con señales pulsantes con

duración del pulso uT tienen una envolvente del tipo xsenx / y sus ceros se encuentran a una distancia 1/ uT

En un sistema OFDM que tiene K subcanales, la tasa de símbolo de cada subportadora se reduce un factor de N en relación a la tasa de símbolo de un sistema de una única portadora que emplea todo el ancho de banda W y transmite datos a la misma tasa que OFDM. Por lo tanto, el periodo de símbolo en el sistema OFDM es sKTT = , donde sT es el periodo de símbolo del sistema de una única portadora. Si se selecciona K lo suficientemente grande, el periodo de símbolo T puede ser de forma significativa mayor que la duración en tiempo de la dispersión temporal del canal. Por lo tanto, la interferencia entre símbolos puede hacerse arbitrariamente pequeña mediante la selección de un K determinado. En otras palabras, cada subcanal parece tener una respuesta frecuencial fijada )( kfC , .1,...,1,0 −= Kk

Portadoras OFDM


20

Mientras mantengamos la sincronización temporal entre las subportadoras, OFDM nos permite transmitir un número diferente de bits/símbolo en cada subportadora. Por esto, subportadoras que logran una SNR mayor debido a que sufren una atenuación menor, pueden ser moduladas para soportar más bits/símbolo que subcanales que obtienen menores SNR. Por ejemplo, podemos usar QAM con constelaciones de diferentes tamaños en un sistema OFDM. El modulador y demodulador de un sistema OFDM pueden ser implementados mediante el uso de un banco paralelo de filtros basado en la transformada de Fourier discreta (DFT). Cuando el número de subcanales es grande, digamos K >25, el modulador y demodulador en un sistema OFDM son implementados de forma eficiente mediante el uso del algoritmo de la transformada de Fourier rápida (FFT) para el cómputo de la DFT.

El concepto de lo que se hace fundamentalmente en esta modulación se puede entender de esta manera: tenemos una secuencia de símbolos que queremos transmitir; estos símbolos se ven como puntos en frecuencia de una señal que forman lo que se llama una constelación de puntos. Se agrupan de N en N (a cada grupo de N símbolos se les llama supersímbolo) y se hace una FFT inversa. El número de portadoras que vamos a tener se corresponde con el número de puntos que van a ser procesados en el algoritmo de la IFFT. En recepción bastará aplicar la transformada directa de Fourier a las muestras recibidas para recuperar la secuencia de datos transmitida. Un problema importante con la modulación multiportadora en general y con los sistemas OFDM en particular es su alta relación de potencia pico-promedio (PAR: peak-to-average power ratio) que es inherente en la señal transmitida. Aparecen grandes picos de señal en la señal transmitida cuando las señales de los K subcanales se añaden constructivamente en fase. Tales picos pueden saturar el amplificador de potencia del transmisor y, por tanto, causar distorsión de intermodulación en la señal transmitida. Esta distorsión se puede reducir y, generalmente evitar, reduciendo la potencia de la señal transmitida y, por tanto, operando el amplificador de potencia del transmisor en el rango lineal. Tal reducción de potencia tiene como resultado una operación ineficiente del sistema OFDM. Se han ideado una gran variedad de métodos para reducir la PAR en sistemas multiportadora. Un método relativamente simple es insertar diferentes desplazamientos de fase en cada una de las subportadoras, donde estos desplazamientos de fase se seleccionan de forma pseudoaleatoria, o mediante algún algoritmo, para reducir la PAR. 3.1.2 Sistemas digitales de radiodifusión: modulación COFDM

Los sistemas digitales definidos en la normativa europea para radiodifusión sonora y de TV tienen en común la utilización del formato de modulación OFDM para la transmisión terrenal. La ventaja principal de este formato estriba en su resistencia a la propagación multitrayecto. A cambio, para ser eficaz necesita un mínimo ancho de banda, así como la utilización de codificación y entrelazado para la corrección de errores.


21

Los nuevos sistemas digitales se han diseñado tomando en consideración el caso de peor recepción, correspondiente a los receptores portátiles móviles. De esta forma se garantiza que funcionarán correctamente en todos los entornos previstos.

En radiodifusión, la trama digital se divide en un gran número de flujos binarios de mucha menor velocidad que son transportados por las N portadoras. La modulación que se emplea es, dependiendo del sistema, QPSK, 16-QAM o 64-QAM. El principio de ortogonalidad define la separación entre portadoras de manera que sea exactamente la inversa del periodo útil de símbolo uT , de forma que, en la duración de dicho periodo, las señales son ortogonales entre sí, y por tanto pueden demodularse sin interferencia entre ellas. Pongamos un ejemplo. Si tenemos un flujo binario de 1 Mb/s, podemos transmitirlo dividido entre N = 1000 subportadoras. Cada una de ellas transportará un flujo de 1 Kb/s. Si suponemos, por simplicidad, que cada una de las subportadoras se modula en QPSK (2 bits/símbolo), la velocidad de símbolo es de 500 símbolos/segundo, y el periodo de símbolo resulta de 2 ms (1/500segundos/símbolo). Durante ese periodo de símbolo, la modulación permanece estable, es decir, cada una de las portadoras tendrá una de las cuatro fases posibles en QPSK. Por tanto, la señal modulada sigue la siguiente expresión, válida durante un periodo de símbolo individual:

[3.3]

Donde se comprueba que la señal es la combinación de N sinusoides, de

frecuencias uc Tkf /+ , cada una de ellas modulada en QPSK a través de los cuatro posibles valores que puede tomar kφ . Estas fases permanecen estables durante todo el periodo útil del símbolo. Si la modulación es 16-QAM ó 64-QAM, tanto la amplitud como la fase de cada subportadora se verían afectadas por la modulación, pero permanecerían estables en el tiempo uT .

Los valores que puede tomar k dependen de cómo se defina la frecuencia de portadora, que en este caso es una referencia del canal. Es frecuente que la referencia se sitúe en la mitad de la banda, y que además la subportadora correspondiente a esa frecuencia no se emita, con lo que, siguiendo el ejemplo, k tomaría valores entre -500 y -1 y entre 1 y 500. El ancho de banda total es de 1000 veces 1/ uT , es decir, del orden de 500 KHz.

Se puede comprobar fácilmente que, si las amplitudes y fases de las

subportadoras son estables dentro de un periodo uT , las señales son ortogonales entre sí. La demostración es inmediata como ya se ha visto anteriormente. Otra forma de comprobar esto es expresando las señales mediante exponenciales complejas, donde se verifica que para valores de m y n diferentes entre sí se cumple:

[ ]∑∑ +⋅+=

⋅=

kkuc

k

jTktjtj tTkeeets kuc φπωφπω )/2(cosRe)( /2


22

0))/2(())/2(( =⋅∫ ++−++

u

nucmuc

T

tTnjtTmj ee θπωθπω [3.4]

Siguiendo con el ejemplo, ¿qué ventaja aporta la modulación OFDM? Podría también emplearse una modulación QPSK a 500 Ks/s con el mismo flujo binario de 1 Mb/s, y prácticamente con el mismo ancho de banda. La ventaja está en que el periodo de símbolo se extiende desde 2 µs, en el caso de una sola portadora, hasta 2 ms en el caso multiportadora con OFDM. Ello lo hace mucho más inmune frente a interferencia entre símbolos por multitrayecto, eliminando la necesidad de ecualización. Pese a ello, el multitrayecto provocaría aún una cierta interferencia entre símbolos, reducida, pero que puede causar pérdidas de ortogonalidad que el sistema tolera mal. Para evitarlo, se habilita un tiempo de guarda entre cada dos símbolos, en el que se transmite ya la señal correspondiente al siguiente símbolo, pero el receptor permanece inactivo para que lleguen todos los ecos del símbolo anterior. Es decir, el periodo de símbolo T ahora se compone de un tiempo de guarda gT seguido del tiempo útil uT . Las portadoras deben ser ortogonales en el tiempo útil uT . La inserción del tiempo de guarda provoca una cierta ineficiencia, pues hay un tiempo en el que el canal no se usa para transmitir datos sino para permitir la llegada de los ecos del símbolo anterior. Por ello el ancho de banda es algo superior al mínimo necesario. Siguiendo con el ejemplo anterior, si se desea mantener el flujo de 1Mb/s, el periodo de símbolo debe ser, como antes de 2 ms. Si se destina un 20% a tiempo de guarda, es decir, gT = 400 µs, el periodo útil es ahora uT = 1,6 ms. La separación entre portadoras pasa a ser de 625 Hz, en lugar de 500 Hz, y el ancho de banda total es de 625 KHz. Sin embargo, el tiempo de guarda aporta ventajas considerables en cuanto a la inmunidad adicional frente a multitrayecto, y la posibilidad de utilizar redes de frecuencia única. Los principales parámetros de la modulación OFDM son, por tanto, los siguientes:

Periodo de símbolo T Tiempo útil de símbolo uT Tiempo de guarda gT Número de portadoras N Ancho de banda total TB Bits/símbolo de la constelación M

En un entorno con multitrayecto, además de la posible interferencia entre

símbolos se produce desvanecimiento. Algunas subportadoras sufren una atenuación fuerte por la combinación destructiva de las señales procedentes de diferentes trayectos. La modulación OFDM permite combatir el desvanecimiento si el ancho de banda supera un mínimo, que corresponde al ancho de banda de coherencia del canal. En este caso el desvanecimiento es selectivo, afectando solamente a un grupo de subportadoras. Los


23

datos transportados en dichas subportadoras se pierden si el desvanecimiento es profundo, pero pueden recuperarse en base a los datos detectados correctamente de las subportadoras no afectadas por desvanecimiento. Para ello es necesario utilizar una combinación de codificación para corrección de errores, entrelazado temporal y entrelazado de frecuencia:

− La codificación añade redundancia para permitir la recuperación de los bits

erróneos partiendo de los que se reciben sin errores. Se utilizan técnicas estándar de codificación de bloques y/o convolucional.

− El entrelazado temporal mitiga el efecto de las ráfagas de errores, al dispersar en el tiempo los bits ligadas por la codificación, de manera que no todos ellos se vean simultáneamente afectados por los errores.

− El entrelazado en frecuencia es dual del anterior, y su objetivo es mitigar el efecto del desvanecimiento selectivo, que afecta a un grupo de portadoras contiguas, de manera que los bits ligados por la codificación se distribuyan en todo el ancho de banda de la señal.

Se suele hablar de COFDM (Coded OFDM) para denotar el uso de OFDM combinado con codificación. 3.1.3 Historia de la modulación

Esta modulación no es de nueva creación. El concepto de transmitir datos en

paralelo y hacer un multiplexado por división en frecuencia es una idea aparecida ya a mediados de los años sesenta. Ya en el mes de Enero de 1970 se presentó una patente en Estados Unidos con la idea de transmitir datos en paralelo al multiplexar por división en frecuencia con solapamiento de los subcanales, de esta manera se empleaba el ancho de banda total disponible. Las primeras aplicaciones se realizaron en el campo militar.

En el caso de tener un gran número de subcanales el conjunto de generadores sinusoidales y demoduladores coherentes que se requieren para un sistema así hacían que el sistema fuese caro y complejo. Fueron Weinstein y Ebert quienes aplicaron la transformada discreta de Fourier (DFT) a la transmisión de datos en paralelo como parte del modulador y demodulador. Los avances en la escala de integración electrónica hacen posible que se pueda disponer de chips que realizan la transformada rápida de Fourier (FFT) y, por lo tanto, hacen factible la aplicación de la modulación COFDM. En los años 80 esta modulación se estudió para su uso en modems de alta velocidad, comunicaciones digitales para móviles, grabaciones de alta densidad y comunicaciones de datos en banda ancha sobre canales de radio FM para receptor móvil. En esta década se debe resaltar el estudio sobre el que fue objeto la modulación para su empleo en el medio terrenal. Fue finalmente elegida como la modulación para el estándar de radio comercial digital DAB (Digital Audio Broadcasting). Los resultados


24

obtenidos en el proyecto DAB resultaron sin duda fundamentales para la elección de esta modulación en la radiodifusión terrenal de las señales de televisión (DVB-T). 3.1.4 Ventajas de la Modulación 3.1.4.1 Igualación

Las características de esta modulación facilitan la igualación en el receptor. Esta modulación distribuye una serie de portadoras a lo largo de todo el ancho de banda que se va a usar en la transmisión, por lo tanto, es muy fácil hallar la respuesta en frecuencia del canal mediante la transmisión de una secuencia de entrenamiento o una serie de señales piloto. 3.1.4.2 Protección contra desvanecimientos

Un desvanecimiento es una distorsión provocada por las variaciones de las características físicas del canal que tiene como resultado una disminución de la potencia recibida. Las mayores distorsiones son provocadas por los desvanecimientos profundos que son selectivos en frecuencia, afectando de manera distinta a las diferentes componentes frecuenciales de la señal enviada. De esta manera, algunas frecuencias se verán muy atenuadas mientras que otras pueden tener una ganancia en potencia. Suelen ser provocados por la existencia de multitrayecto al producirse una interferencia entre los rayos que alcanzan el receptor, teniendo como señal resultante la suma de las señales que llegan hasta él.

Como consecuencia inmediata de la atenuación soportada en las portadoras más afectadas por el desvanecimiento, se puede citar que si el nivel de ruido en el canal es suficientemente elevado, no va a ser posible recuperar la información transportada por las mismas, hecho que implicará la aparición de una ráfaga de errores en la decodificación como consecuencia de la pérdida de los símbolos que las modulan. La modulación OFDM no proporciona ninguna protección contra estos desvanecimientos, como ya se ha comentado anteriormente. Como solución se dota a la modulación de un codificador de canal compuesto de dos elementos: un código convolucional y un barajador (por este motivo pasa a llamarse la modulación Coded-OFDM). La intención pretendida al introducir un código convolucional es añadir cierta redundancia en los datos que se desean transmitir, redundancia que en recepción será empleada en la corrección de errores. Esa corrección de errores tiene ciertas limitaciones pues si a la entrada del decodificador apareciese una secuencia larga de errores, este elemento no sería capaz de decodificar de una manera correcta. Para acortar la longitud de estas ráfagas de errores, y que sean abordables por el código convolucional, se añade el barajador. El barajador (interleaver) trata de introducir un cierto desorden (entrelazado) de manera que las portadoras adyacentes no sean moduladas por datos consecutivos. Si se produce una pérdida de información llevada por portadoras adyacentes, al deshacer el desorden debido al barajador, el error debido a cada portadora queda aislado, acortándose la longitud de la ráfaga.


25

A modo de resumen se puede decir que el efecto conjunto del código convolucional y del barajador puede verse como un promediado de los desvanecimientos locales sobre todo el espectro de la señal. 3.1.4.3 Redes de frecuencia única

En un principio se podría pensar que el multitrayecto es debido a causas exclusivamente naturales, pero el hecho de tener herramientas para paliar los efectos del mismo, puede inducir a pensar que de manera artificial se introduzca un multitrayecto controlado como consecuencia del empleo de redes de frecuencia única.

El espectro para radiodifusión de televisión está muy saturado ya que con el actual sistema de modulación un canal de televisión ocupa el propio canal, los adyacentes, los canales del oscilador y el canal imagen, es decir, cinco más aparte del propio. Además, para la radiodifusión de una misma señal por parte de dos transmisores geográficamente adyacentes, se tiene que usar dos canales distintos, precisamente por culpa del multitrayecto. Usando la modulación COFDM se podría tener una red de transmisores que operen todos en la misma frecuencia, una red de frecuencia única (SFN). COFDM se apoya en el intervalo de guarda (prefijo cíclico) para paliar los efectos del multitrayecto, sea este natural o artificial, fruto de que un receptor reciba señales procedentes de diversos transmisores. Aparte del mejor aprovechamiento del espectro, otra ventaja de las redes de frecuencia única es que debido a la adición de señales provenientes de dos transmisores cercanos pertenecientes a la red, se produce una ganancia que se denomina ganancia de red. Esta ganancia trae consigo múltiples ventajas: la infraestructura para la radiodifusión es más barata, ya que se necesita menos potencia en los transmisores; hacen un mejor uso de la potencia transmitida y logra una mejor cobertura. Un inconveniente es que la división de la red no es posible; es decir, en caso de querer radiodifusión regional sería necesaria la creación de una red por ámbito de radiodifusión. 3.1.5 Esquema del sistema OFDM En este apartado, describiremos un sistema OFDM en el que se usa la QAM para la transmisión de datos de cada una de las subportadoras y el algoritmo FFT en la implementación del modulador y demodulador. El diagrama de bloques básico del sistema OFDM se ilustra a continuación.


26

Figura 3.2. Diagrama de bloques básico del sistema OFDM Un convertidor serie paralelo subdivide la secuencia de información en bloques

de fB bits. Los fB bits de cada bloque son analizados en K grupos, donde al i-ésimo grupo se le asignan ib bits. Por tanto,

∑=

=K

ifi Bb

1 [3.5]

Podemos ver el modulador multiportadora como un generador de K subcanales

QAM independientes, donde la tasa e símbolo para cada subcanal es T/1 y la señal de cada subcanal tiene una constelación QAM definida. Por tanto, el número de puntos de señal para el i-ésimo subcanal es ib

iM 2= . Si denotamos los valores complejos de los puntos de señal que corresponden a las señales de información de los K subcanales como kX , 1,...1,0 −= Kk , Estos símbolos de información { kX } representan los valores de la transformada discreta de Fourier (DFT) de una señal multiportadora OFDM )(tx , donde la modulación de cada subportadora es QAM. Como )(tx debe ser una señal real, su DFT de N puntos { kX } debe satisfacer la propiedad de simetría

*kkN XX =− . Por lo tanto, creamos KN 2= símbolos de K símbolos de información

definiendo

*kkN XX =− , 1,...2,1 −= Kk

)Re( 0'0 XX = [3.6]

)Im( 0XX N =

Notar que el símbolo de información 0X se divide en dos partes, siendo ambas reales. Si denotamos la nueva secuencia de símbolos como { '

kX , 1,...1,0 −= Kk }, la DFT-inversa (IDFT) de N puntos da como resultado la secuencia de valores reales

NnkjN

kkn eX

Nx /2

1

0

'1 π∑−

=

= 1,...,1,0 −= Nn [3.7]

Modulador

QAM

IFFT

D/A

Demodulador

QAM

FFT

A/D

TRANSMISOR

RECEPTOR

Datos

Datos

Señal OFDM

Señal OFDM

Añade Prefijo Cíclico

S/P

P/S

S/P

EliminaPrefijo Cíclico

S/P


27

donde 1/ N es simplemente un factor de escala. Esta secuencia { nx , 10 −≤≤ Nn } se corresponde con las muestras de la señal multiportadora OFDM )(tx , compuesta por K subportadoras, que puede ser expresada como

TktjN

kk eX

Ntx /2

1

0

'1)( π∑−

=

= , Tt ≤≤0 [3.8]

donde T es la duración de la señal y )/( NnTxxn = , 1,...,1,0 −= Nn . Las frecuencias de las subportadoras son Tkfk /= , .1,...,1,0 −= Kk La señal muestreada { nx } generada mediante el cálculo de la IDFT se pasan a través del convertidor analógico-digital, donde a la salida, idealmente, está la forma de onda de la señal OFDM )(tx . Con )(tx como entrada al canal, la salida del canal en el receptor se puede expresar como

)()(*)()( tntctxtr += [3.9] donde )(tc es la respuesta impulsiva del canal y * denota convolución. Como el ancho de banda f∆ de cada subcanal se selecciona para que sea muy pequeño en relación con el ancho de banda del canal total fKW ∆= , la duración del símbolo fT ∆= /1 es grande comparada con la respuesta impulsiva del canal. Para ser específico, supongamos que la respuesta impulsiva del canal se expande sobre m +1 muestras de señal, donde Nm << . Una forma simple de evitar completamente la interferencia entre símbolos (ISI) es insertar un intervalo de guarda de duración NmT / entre la transmisión de bloques de datos sucesivos. Esto permite que la respuesta del canal se desvanezca antes de que el siguiente bloque de K símbolos se transmita. Un tipo de intervalo de guarda comúnmente usado es añadir un llamado prefijo cíclico a cada bloque de N muestras de señal { nx , 10 −≤≤ Nn }. El prefijo cíclico para el bloque de muestras se compone de las muestras 11 ,...,, −+−− NmNmN xxx . Estas muestras se colocan al principio del bloque, y por tanto, se crea una secuencia de longitud mN + muestras, que pueden indexarse desde mn −= a 1−= Nn , donde las primeras m muestras constituyen el prefijo cíclico. Entonces si los valores muestreados de la respuesta del canal son { nc , mn ≤≤0 }, la convolución de { nc } con { nx ,

1−≤≤− Nnm } produce la señal recibida { nr }. Como la ISI en cualquier par de bloques de transmisión de señal sucesivos afecta las primeras m muestras, desechamos las primeras m muestras de { nr } y demodulamos la señal basándonos en las muestras de la señal recibida { nr , 10 −≤≤ Nn }. Si vemos las características del canal en el dominio de la frecuencia, la respuesta frecuencial del canal en las frecuencias subportadoras Tkfk /= es

Nnkjm

nnk ec

NkCC /2

0)2( ππ −

=∑== , 1,...,1,0 −= Nk [3.10]


28

Como la ISI se elimina por el uso de o el prefijo cíclico o la banda de guarda temporal, la secuencia demodulada de símbolos se puede expresar como

kkkk XCX η+=∧

' , 1,...,1,0 −= Nk [3.11]

donde { kX∧

} es la salida de la DFT de N puntos calculada por el demodulador y { kη } es el ruido aditivo que corrompe la señal.

Como se ilustraba en la figura, la señal recibida se demodula mediante el cálculo de la DFT de la señal recibida después de que ha pasado a través del convertidor analógico-digital. Como en el caso del modulador OFDM, el cálculo de la DFT en el demodulador se lleva a cabo de forma eficiente mediante el uso del algoritmo FFT. Para recomponer los símbolos de información de los valores calculados por la DFT, es necesario estimar y compensar los factores del canal { kC }. La estimación del canal se puede llevar a cabo transmitiendo inicialmente, o una secuencia modulada conocida en cada una de las subportadoras, o simplemente, transmitiendo las subportadoras sin modular pero esto podría provocar PAR. Si las características del canal varían lentamente con el tiempo, las variaciones temporales se pueden seguir usando las decisiones a la salida del detector de una forma de decisión directa. Por tanto, el sistema OFDM multiportadora puede ser hecho para operar de forma adaptativa. La tasa de transmisión de cada una de las subportadoras se puede optimizar asignando adecuadamente la potencia transmitida en promedio y el número de bits que son transmitidos por cada subportadora. La SNR por subcanal se puede definir como

2

2

nk

kkk

CTPSNR

σ= [3.12]

donde T es el periodo de símbolo, kP la potencia transmitida promedio del subcanal k-

ésimo, 2kC es la magnitud al cuadrado de la respuesta frecuencial del k-ésimo

subcanal, y 2nkσ es la varianza del ruido correspondiente. En subcanales, con alta SNR,

transmitimos más bits/símbolo usando una constelación QAM mayor comparada con los subcanales con menor SNR. Por lo tanto, la tasa de bits de cada subcanal se puede optimizar de tal forma que el resultado de la tasa de error entre los subcanales queda igualado para satisfacer las especificaciones deseadas. El OFDM multiportadora usando modulación QAM en cada una de las subportadoras como se ha descrito anteriormente ha sido implementado en una gran variedad de aplicaciones incluyendo transmisión de alta velocidad sobre la línea telefónica. Este tipo de modulación multiportadora OFDM se ha llamado también DMT o modulación multitono discreta.


29

3.2 Transmisor COFDM

En la siguiente figura se muestra el transmisor implementado:

Figura 3.3. Diagrama de bloques del transmisor COFDM

El transmisor implementado en este proyecto es un modelo simplificado del transmisor OFDM estandarizado en DVB-T o DAB, ya que usa para codificación para la corrección de errores pero no utiliza técnicas de entrelazado lo que haría al sistema más robusto frente a ráfagas de errores, pero dado que nuestra transmisión no es de difusión sino que se realiza a través de un canal (cable de audio) prácticamente ideal, la codificación será suficiente para la corrección de los posibles errores de transmisión que pudieran ocurrir. De cualquier modo, más adelante se verán cómo son las técnicas de entrelazado externo e interno que se utilizan en sistemas modulados con COFDM. Se presentan a continuación los distintos bloques que constituyen la cadena transmisora: 3.2.1 Bloques para corrección de errores: codificador Reed-Solomon y codificador convolucional 1

El ruido, fundamentalmente, y otros factores como las interferencias, pueden producir errores en la transmisión de un flujo binario que se manifiestan en la errónea interpretación de un 1 por un 0, y viceversa. Es por lo tanto necesario usar una técnica de corrección de errores. Se puede crear un código sencillo de detección de errores de n dígitos binarios, situando los bits de información en las primeras n-1 posiciones y llenando la última posición con un 0 ó 1, (el llamado bit de paridad) de forma que la

1 En los apéndices A y B se encuentra una explicación más detallada del funcionamiento de los códigos de bloque y convolucionales empleados en la corrección de errores.

TRANSMISOR COFDM

Codificador Convolucional

Conversor

Serie-Paralelo

Modulador

QAM

Extensión de

espectro

Codificador

Reed-Solomon

Añade

prefijo cíclico (guarda)

Conversor

Paralelo-Serie

IFFT

Pasa a binario

Inserta Supersímbolo Entrenamiento

Inserta Señal

Sincronismo

Trama

de datos

Muestras


30

palabra completa de código contenga un número par de unos. Si cuando esta palabra que se detecta en el extremo receptor contiene un número impar de unos, evidentemente se ha producido un error. Del mismo modo podría utilizarse paridad impar colocando en la posición n un bit de forma que la palabra código contenga un número impar de unos. En general, se puede crear un código ),( kn de longitud n, añadiendo ckn =− bits de paridad o redundantes a k bits de información. Se llama tasa de código a la relación

nk / . Si esta relación es, por ejemplo 3/4, se utilizaran 4 bits para transmitir 3 bits de información.

Figura 3.4. Códigos de bloque ),( kn

Esta corrección de errores mediante códigos insertados antes del modulador en la cadena de transmisión se la denomina corrección de errores sin canal de retorno, conocida también por las siglas FEC (Forward Error Correction). A la entrada del codificador llega una secuencia continua de dígitos de información y del codificador sale otra secuencia con algunos dígitos mas que va al modulador. En el lado receptor, el demodulador envía una secuencia de bits al decodificador que los convierte en una secuencia algo más corta de dígitos de información. Las reglas de operación del codificador y decodificador están dictadas por el código específico que se utilice.

Hay muchos tipos de códigos, en general muy complejos, pero aquí nos vamos a referir únicamente a los códigos lineales de bloque y a los de convolución. Cuando se utiliza uno de los primeros, el codificador rompe la secuencia continua de dígitos de información en secciones o bloques de k bits y opera independientemente con cada uno de ellos de acuerdo con el código especifico que se utilice. Con cada bloque posible de información esta asociado un numero n de bits de canal, siendo kn > . El resultado (bloque de n bits), que ahora se llama palabra de código, se transmite afectada por el ruido, y se decodifica con independencia de todas las demás palabras de código. A la cantidad k se la llama longitud de bloque.

Las palabras de código llegan al modulador, el cual genera un conjunto de formas de onda de duración finita para su transmisión. El codificador de bloque es un dispositivo que actúa como si no tuviese memoria ya que cada palabra de código de n bits depende exclusivamente de un bloque especifico de información de k bits y no de otros. Si llamamos R a la tasa de código antes definida, y bR y cR a las velocidades binarias a la entrada y a la salida del codificador respectivamente se tiene:

Dígitos de información Dígitos de correción

Redundancia

k c

n

La tasa de codificación o coding rate se define:

R = k/n= 1-c/n


31

knRRRR bbc // == [3.13]

Los valores prácticos de la longitud de bloque de información k van de 3 a varios centenares, y los correspondientes a R , de 1/4 a 7/8.

3.2.1.1 Codificador Reed-Solomon Este bloque va a ser el primer paso para conseguir robustez contra errores. Su

inclusión viene motivada porque a la salida del decodificador de canal en el receptor se tiene una tasa de bits erróneos del orden de 10-4 la cual es muy elevada para la transmisión de la señal de televisión o audio. Así, la introducción de este código consigue obtener a la salida del receptor unas tasas de errores muy bajas.

Este codificador implementa un código bloque del tipo Reed-Solomon, que

pertenece a una subclase de los códigos BCH en la que los elementos con los que se trabaja son grupos de bits, ocho en este caso.

Estos códigos corrigen cualquier combinación de t o menos errores y necesitan no más de t2 bits de paridad. Los parámetros son tckn 2==− y 12 += td siendo d la distancia mínima entre cualesquiera palabras de código (distancia de Hamming), es decir, el número mínimo de cambios de bits necesario para convertir una palabra de código en otra.

En el estándar DVB-T, el código Reed-Solomon definido es el sistemático RS (204,188,8) lo que quiere decir que ante una entrada de 188 bytes añade 16 bytes de paridad lo que da un total de 204 bytes, poseyendo la capacidad de corregir hasta 8 bytes erróneos arbitrarios.

3.2.1.2 Codificador convolucional

Este elemento constituye el primer bloque que forma parte del codificador de canal. La función que va a desarrollar va a ser la codificación de los bits que se presentan a la entrada mediante la introducción de bits de redundancia que habilitarán la corrección de errores en recepción. El funcionamiento del convolucional está basado en registros de memoria (de capacidad un bit) y sumas módulo dos. La codificación de los bits se realiza a partir del valor del bit presente a la entrada y los valores de los m bits anteriores que están guardados en los registros.

En los códigos de convolución, los datos de información pasan a través de un registro de desplazamiento lineal con M pasos que desplazan k bits a la vez .Para cada M bits de información almacenada en el registro de desplazamiento, hay n circuitos lógicos lineales que operan sobre el contenido del registro para obtener n bits codificados a la salida del codificador. La tasa de código es, por tanto nkR /= . Puesto que cada bit de información permanece en el registro kM / desplazamientos afecta al valor de knM / bits codificados. Así pues el codificador de convolución es un dispositivo con memoria. El estado del codificador se define como el contenido del registro de desplazamiento. La longitud K del código de convolución es la suma de los bits de estado y de los bits de entrada, aunque en algunas referencias se define K


32

únicamente por el número de bits de estado. Valores típicos para k y n están en la gama de 1 a 8, para R de 1/4 a 7/8, para M e 5 a 70 y para K de 6 a 9. Los códigos de bloque y de convolución tienen una capacidad de corrección de errores similar y las mismas limitaciones fundamentales.

El codificador convolucional que define el estándar DVB-T se construye a partir de un código convolucional que denominaremos como código base. Por lo tanto, se definirá este código en primer lugar, para posteriormente, obtener las distintas tasas que el estándar contempla en función del código base. El código convolucional base está formado por seis registros de memoria y dos bits de salida por cada bit de entrada.

Los polinomios que generan el código son:

6321)(1 DDDDDg ++++= [3.14] 65321)(2 DDDDDg ++++=

Estos polinomios se pueden ver representados en la siguiente figura sin más que

tener en cuenta que D indica un retardo unidad.

Figura 3.5 .Codificador convolucional de una entrada y dos salidas. Tasa 1/2 Como se indicó anteriormente, el estándar contempla diversas tasas para el

codificador convolucional. La tasa 1/2 viene aportada por el propio código base, mientras que las restantes tasas se consiguen a partir de estrategias de perforado. Estas estrategias consisten en descartar salidas del código convolucional base siguiendo ciertos patrones predeterminados que no se van a presentar.


Perforado con salida serie

X

Y


33

Tasas de código r Modelo de perforado Secuencia transmitida 1/2

X: 1 Y: 1

X1 Y1

2/3

X: 10 Y: 11

X1 Y1 X2

3/4

X: 101 Y: 110

X1 Y1 X2 X3

5/6

X:10101 Y:11010

X1 Y1 Y2 X3 Y4 X5

7/8

X:1000101 Y:1111010

X1 Y1 Y2 Y3 Y4 X5 Y6 X7

Figura 3.6. Modelos de perforado para obtener distintas tasas de código

3.2.2 Conversor Serie-Paralelo Este bloque tratará de agrupar la cadena de bits en serie que sale del codificador convolucional en conjuntos de N bits o símbolos en paralelo que serán la unidad del trabajo del siguiente bloque, el modulador QAM. 3.2.3 Modulador QAM Será este bloque el encargado de modular cada una de las subportadoras. La función básica que realiza este bloque será asignar a los símbolos de su entrada un valor complejo de la constelación correspondiente al número de niveles empleados en la modulación QAM.

Figura 3.7. Modulación QAM

La modulación M-QAM (M =16, 32, 64, 256) permite aumentar la capacidad de transmisión, sin aumenta el ancho de banda ocupado. La señal M-QAM se obtiene sumando vectorialmente dos oscilaciones de la misma frecuencia pero en cuadratura, moduladas en amplitud, con doble banda lateral pero con la portadora suprimida. El bloque anterior (convertidor serie-paralelo), toma la cantidad de bits necesarios para formar un símbolo: 6 en 64-QAM, 4 en 16-QAM y 2 en QPSK, y se convierten de serie a paralelo, en esta parte se gana en ancho de banda ya que de 6 bits se forma un solo símbolo a transmitir, y se convierte esa combinación de bits al nivel analógico correspondiente, dando por resultado, 64 (para el caso 64-QAM) niveles analógicos que luego formarán la constelación.

Modulación

QAM

S[n]

Xn[0] Xn[1]

Xn[N-1]


34

En la figura 3.8, se explica la mecánica utilizada en QAM siguiendo el ejemplo

16-QAM: los niveles obtenidos a la salida del conversor digital-analógico en forma de señal pulsante NRZ (sin retorno a cero) se divide, siguiendo secuencialmente los distintos símbolos sucesivos, en dos ramas que serán las señales llamadas I (in phase) y Q (quadrature). Estas señales pasan a modular en amplitud a dos señales senoidales de la misma frecuencia pero en cuadratura. En COFDM estas señales provienen de desfasar una de las múltiples subportadoras ortogonales generadas por la IFFT como se verá en la etapa siguiente. (Se debe tener cuidado de no confundir el desfase de 90º inherente a la modulación QAM con la ortogonalidad de las distintas portadoras).

Figura 3.8. Esquema de modulación QAM explicado a través del 64-QAM

Obsérvese que cuando la señal modulante pasa de un cuadrante a otro, la

portadora cambia de fase. Este cambio de fase, combinado con los cambios de niveles da la posición de los símbolos de la constelación ubicada en los cuatro cuadrantes. Obviamente en el receptor, la fase de la portadora debe ser detectada con precisión. Si fπω 2= es la frecuencia de la portadora y V su amplitud se tiene:

)cos()()()()( tVtQtVsentItS ωω += [3.15] donde las señales )(tI y )(tQ son pulsos digitales cuya amplitud y polaridad son determinadas por el código de la palabra a la entrada de acuerdo a la combinación de bits presentes a la entrada del conversor analógico-digital. Como regla, los valores pueden asumir L niveles (en realidad [+/- (L/2)], donde L = raíz cuadrada de M) sobre cada uno de los ejes. Por ejemplo, para 64-QAM se representan cuatro niveles positivos en el eje X y cuatro negativos. El mismo análisis es válido para el eje Y, dando un total de 8 por 8 (64) niveles en toda la constelación. El mapeado se realiza según el código de Gray que establece que los puntos que difieren en un bit, estén vecinos en la constelación a los efectos de no realizar excesivos cambios de fase y/o nivel. Un código Gray se caracteriza por tener una diferencia de un solo bit entre dos símbolos que estén a distancia mínima. Si la relación señal a ruido es suficientemente alta es mucho más


35

probable que un símbolo sea confundido con un símbolo vecino que con otros que disten mucho del símbolo inicialmente transmitido.

Figura 3.9. Constelación 64-QAM

En la figura 3.9, se muestran los valores de fase y amplitud que corresponden a cada símbolo así como los umbrales de decisión dentro de lo cual deben caer los símbolos. Las constelaciones recogidas en el estándar son las siguientes: QPSK, 16-QAM y 64-QAM. Todas estas constelaciones tienen en común que la asignación binaria de los elementos se corresponde a un código Gray.

Figura 3.10. Constelaciones de la modulación QPSK y QAM

De los bits que forman parte de la asignación binaria de un símbolo, algunos de ellos están relacionados con la parte real del mismo y otros con la parte imaginaria. Por ejemplo, en el caso de emplear una 64-QAM (6 bits), los bits 0, 2 y 4 están relacionados con la parte real de los símbolos y los bits 1, 3 y 5 con la imaginaria.

Para finalizar hay que decir que los símbolos de la constelación deben de ser multiplicados por unos valores para conseguir que estén normalizados en energía.

I

Q

16-QAM

I

Q

QPSK

01

00 10

11


36

3.2.4 Extensión del espectro Este bloque tiene como función principal añadir la parte simétrica conjugada al espectro que se obtiene a la salida del modulador QAM. Esto se hace, ya que como se explicó anteriormente queremos obtener una señal real a la salida del bloque que realiza la IFFT.

La explicación de cómo se lleva a cabo esta extensión del espectro, ya fue comentada en este capítulo pero se incluye de nuevo para que quede más claro.

Si denotamos los valores complejos de los puntos de señal (obtenidos del modulador QAM) que corresponden a las señales de información de los K subcanales como kX , 1,...1,0 −= Kk , Estos símbolos de información { kX } representan los valores de la transformada discreta de Fourier (DFT) de una señal multiportadora OFDM )(tx , donde la modulación de cada subportadora es QAM. Como )(tx debe ser una señal real, su DFT de N puntos { kX } debe satisfacer la propiedad de simetría

*kkN XX =− . Por lo tanto, creamos KN 2= símbolos de K símbolos de información

definiendo

*kkN XX =− , 1,...2,1 −= Kk

)Re( 0'0 XX = [3.6]

)Im( 0XX N =

Con lo que se ha duplicado el número de símbolos a los que se les aplica la IFFT y además, estos símbolos cumplen la propiedad de simetría conjugada para que podamos obtener a la salida del siguiente bloque una señal real, que es nuestro propósito.

Tal y como se muestra en el diagrama de bloques del transmisor, antes de

realizarse la expansión del espectro se inserta un supersímbolo de entrenamiento que será conocido cuya misión será poder obtener la rotación y escalado que produce el canal sobre los símbolos transmitidos para así, en el receptor poder realizar una igualación para cada subcanal de los símbolos recibidos y poder detectar correctamente el supersímbolo que se transmitió. 3.2.5 IFFT

Este bloque es especialmente importante, y ha sido objeto de estudio durante mucho tiempo. Su función será obtener una señal real en tiempo a partir del espectro de la señal, es decir de un conjunto de coeficientes en el dominio de la frecuencia.

Si tenemos en cuenta que para lograr una señal OFDM con éxito la relación

entre las portadoras debe ser escogida adecuadamente para garantizar la ortogonalidad entre ellas, entonces, tras escoger el espectro requerido, debemos convertir la señal de nuevo al dominio del tiempo usando la transformada de Fourier inversa. En la mayoría de las aplicaciones esta transformada se lleva a cabo usando el algoritmo de la transformada rápida de Fourier inversa (IFFT), ya que este algoritmo consigue esta


37

transformación de forma muy eficiente y proporciona una forma simple de asegurar que las subportadoras producidas son ortogonales.

Figura 3.11. Transformada inversa de Fourier mediante el algoritmo IFFT

Como ya se explicó con anterioridad, si denotamos la nueva secuencia de símbolos obtenida tras la expansión del espectro como { '

kX , 1,...1,0 −= Kk }, la DFT-inversa (IDFT) de N puntos da como resultado la secuencia de valores reales

NnkjN

kkn eX

Nx /2

1

0

'1 π∑−

=

= 1,...,1,0 −= Nn [3.7]

donde 1/ N es simplemente un factor de escala. Esta secuencia { nx , 10 −≤≤ Nn } se corresponde con las muestras de la señal multiportadora OFDM )(tx , compuesta por K subportadoras, que puede ser expresada como

TktjN

kk eX

Ntx /2

1

0

'1)( π∑−

=

= , Tt ≤≤0 [3.8]

donde T es la duración de la señal y )/( NnTxxn = , 1,...,1,0 −= Nn . Las frecuencias de las subportadoras son Tkfk /= , .1,...,1,0 −= Kk La señal muestreada { nx } generada mediante el cálculo de la IDFT se pasan a través del convertidor analógico-digital, donde a la salida, idealmente, está la forma de onda de la señal OFDM )(tx .

Sólo cabe destacar que para que sea eficiente el algoritmo, el número de puntos con los que debe trabajar tiene que ser potencia de dos, por lo que en el modo 2K del estándar DVB-T se trabaja con 2048 puntos y en el modo 8K de este mismo estándar con 8192. En caso de no tener estos números de forma exacta, tendremos que rellenar con ceros hasta completar estos valores.

3.2.6 Inserción del intervalo de guarda Este es el último bloque del transmisor (antes de volver a serializar las muestras) y trata de combatir el multitrayecto, ya que ésta es una característica habitual en el tipo de canal para el que está destinada esta modulación (medio terrenal). Debemos recordar

IFFT

Xn[0] Xn[1]

Xn[N-1]

xn[0] xn[1]

xn[N-1]


38

que una de las propiedades más importantes de las transmisiones OFDM es su robustez contra esta expansión del retardo por multitrayecto que se consigue teniendo un periodo de símbolo grande que minimice la interferencia entre símbolos o ISI. Para la consecución de este objetivo, la modulación emplea una técnica que consiste en habilitar un cierto intervalo temporal que se añade al intervalo de tiempo necesario para la transmisión de un supersímbolo. Con esto se evita que unos símbolos se vean afectados por otros (interferencia intersímbolo), aunque un símbolo siempre puede ser afectado por una versión retardada de sí mismo (interferencia intrasímbolo).

Los efectos anteriormente mencionados se pueden ver en la figura de abajo, en donde el símbolo K de la señal directa se ve afectado por la versión retardada de sí mismo. Ahora bien, si la duración del intervalo de guarda ( ∆ ) está bien dimensionada, el símbolo K de la señal directa no se ve afectado por el símbolo 1−K de la señal retardada, cosa que sí ocurriría en caso de no existir el intervalo de guarda.

Figura 3.12. Ventaja del intervalo de guarda: el símbolo K no se ve afectado por el K-1

La realización de este bloque se lleva a cabo mediante una extensión cíclica de la salida de la IFFT. Esto nos lleva a que la duración total del periodo de símbolo será

∆+= 0TTsímbolo , siendo 0T la parte que denominábamos como parte de símbolo útil pues en ese intervalo se concentra toda la información transmitida, y ∆ la duración del intervalo de guarda. Esta extensión cíclica no es más que la copia de un determinado número de las últimas muestras de salida de la IFFT, y la colocación al principio a modo de prefijo, como se muestra en la figura de abajo.

Figura 3.13. Adición del intervalo de guarda mediante extensión cíclica del símbolo

Cabe destacar por tanto, que el intervalo de guarda más efectivo que podemos usar es una extensión cíclica del símbolo. Esto es así porque la transformada rápida de Fourier (Fast Fourier Transform) que usaremos en el receptor, transforma una señal cíclica en el dominio del tiempo a su espectro frecuencial equivalente. Dado que la señal muestreada [ ]kxn no es necesariamente cíclica, podemos formar una señal de

1−+ LN muestras repitiendo las 1−L muestras de la señal [ ]kxn al comienzo de la señal. Esta técnica es lo que llamamos intervalo de guarda mediante prefijo cíclico.


39

La desventaja de la introducción del intervalo de guarda estriba en una reducción

de la eficiencia espectral, ya que hay que transmitir muestras duplicadas que no aportan nueva información.

El estándar DVB-T considera cuatro posibles valores para la duración del intervalo de guarda. Estos cuatro valores son 1/4, 1/8, 1/16 y 1/32 de la duración de la parte útil del periodo de símbolo de cada uno de los dos modos posibles. 3.2.7 Conversor Paralelo-Serie Este bloque transformará el supersímbolo al que se le han añadido los correspondientes intervalos de guarda (uno por símbolo, es decir, por cada subportadora) en una serie de muestras, colocando cada símbolo del supersímbolo uno a continuación de otro. Como se muestra en el diagrama de bloques del transmisor, antes de mandar estas muestras a través del canal se inserta una señal de sincronismo, que más tarde se verá como se implementa, para que el receptor sea capaz de sincronizarse a las diferentes tramas de datos y así demodular correctamente la señal de muestras recibida. 3.2.8 Bloques no incluidos en el transmisor implementado Cuando se comenzó la explicación de los diversos bloques que componen el transmisor COFDM se comentó que además de los bloques implementados existen otros más, utilizados por los estándares de DVB-T y DAB, que no se han incluido en este proyecto ya que sirven para proporcionar todavía más protección frente a errores que se puedan producir. Como ya se dijo, dadas las características de nuestro sistema, la corrección que nos permite la inclusión de los bloques de codificación será suficiente para que el sistema funcione dentro de unos límites más que aceptables. De cualquier forma, se explican aquí los bloques no incluidos por si en un proyecto posterior la simulación se llevara a cabo utilizando otro canal menos ideal y se quisieran incluir estos bloques en la implementación para ajustarla aún más a la utilizada por los estándares digitales actuales de difusión de radio y televisión. El diagrama de bloques del transmisor es el siguiente:


40

Figura 3.14. Diagrama de bloques completo del transmisor usado en DVB-T y DAB

Podemos ver en la figura que los bloques sombreados son los que difieren del transmisor implementado y que por tanto serán los que se comentan a continuación.

3.2.8.1 Aleatorizador de Energía

El objetivo de este bloque consiste en evitar que en una ristra de bits haya ciertas secuencias que se repitan con mayor asiduidad, ya que esto provocaría la aparición de ciertos puntos de la constelación con mayor frecuencia. Si estos puntos coincidiesen en necesitar mayor energía para su transmisión se tendría un gran desperdicio de potencia. En definitiva, el objetivo consiste en obtener una cierta uniformidad en la transmisión de los símbolos de la constelación.

Para conseguir esto se utiliza una secuencia binaria pseudoaleatoria que se obtiene a partir del polinomio generador 1+X14+X15 y una secuencia binaria inicial. En la siguiente figura se puede observar el esquema hardware para la obtención de la secuencia pseudoaleatoria:

TRANSMISOR COFDM ESTÁNDAR

Codificador

Reed-Solomon

Barajador externo


Extensión de

espectro

Aleatorizador

de energía

Añade prefijo

cíclico (guarda)

Conversor Paralelo-

Serie

IFFT

Pasa a binario

Inserta Supersímbolo Entrenamiento

Inserta Señal

Sincronismo

Trama

de datos

Muestras

Conversor

Serie-Paralelo

Modulador

QAM

Barajador

interno


41

Figura 3.15. Esquema hardware del aleatorizador de energía.

El proceso de aleatorización consiste en hacer una Or-exclusiva entre los bits

que componen los datos de entrada y la secuencia pseudoaleatoria obtenida. El estándar contempla ciertas consideraciones adicionales para la consecución del objetivo de este bloque, consideraciones que no serán expuestas aquí ya que no añaden nada de interés y sólo son necesarias en una implementación práctica.

3.2.8.2 Barajador Externo

El código Reed-Solomon tiene la capacidad de corregir un cierto número de errores consecutivos, lo cual implica que ante la aparición de una gran cantidad de errores consecutivos, el código no es efectivo. Es por lo que se acaba de ver por lo que tiene interés la introducción del barajador externo. Este bloque se encarga de introducir un cierto desorden en los bytes de entrada de forma que si hubiese una secuencia de bytes erróneos en recepción, al pasar por el elemento inverso a éste, esos bytes quedarían dispersos, con lo cual, el código Reed-Solomon podría corregirlos.

El motivo de que la unidad de trabajo sean bytes estriba en el hecho de que es la unidad de trabajo del código Reed-Solomon. A continuación se muestra una figura que representa el funcionamiento de este bloque y que ayudará a entender cómo se produce el desorden.

Figura 3.16. Esquema hardware del entrelazado de bytes

El sistema está compuesto por dos conmutadores y doce ramas en las que hay intercalados un número creciente de registros. Los conmutadores siempre están sincronizados, lo que quiere decir que si el de entrada apunta a una rama el de salida


42

coge datos de la misma rama. Cada vez que un dato entra por una rama ambos conmutadores pasan a la siguiente posición (de forma cíclica). La aleatorización se ve reflejada en el hecho de que en cada rama exista un número determinado de registros que provoca un retardo variable entre la entrada de un dato por un conmutador y la salida por el otro. Cada registro contiene capacidad para 17 bytes. Estos registros se comportan como colas FIFO y caracterizan el comportamiento que presenta cada rama. Partiendo de la primera rama que no posee ningún registro, el número de registros que posee cada rama se incrementa en una unidad con respecto a la anterior, llegando así a la duodécima rama, que posee once registros. Una característica que conviene resaltar es que los bytes dirigidos por la primera rama no sufren ningún retardo. Esta circunstancia se aprovecha con fines de sincronización; así, los bytes de sincronismo de las tramas MPEG-2 (tramas utilizadas en el estándar DVB-T) van siempre dirigidos por la primera rama.

Una última consideración a realizar es que al empezar a trabajar, y debido a las colas FIFO, el bloque pasa por un periodo transitorio (en este periodo se entregan a la salida bytes que no pertenecen a la estructura de datos de la entrada) que hay que tener en cuenta para su posterior eliminación.

3.2.8.3 Barajador interno

El barajador interno tiene como misión limitar en lo posible la longitud de las ráfagas de errores que se puedan producir durante la transmisión para que estas no desborden la longitud máxima soportada por el código corrector intentando conseguir así una decodificación libre de errores.

Para conseguir esta limitación se implantan dos barajadores, uno que trabaja a nivel de bits y otro que trabaja a nivel de grupos de bits (símbolos). El barajador de bits consigue que los grupos de bits que dan lugar a un símbolo no estén formados por bits consecutivos de la entrada. Esto se consigue barajando los bits siguiendo un patrón fijo que se basa en una rotación cíclica. Los bits serializados que provienen del bloque anterior se agrupan de 126 en 126 y cada grupo se introduce en los registros de cada una de las ramas que conforman el barajador. El número de ramas depende de la modulación empleada, así, para la QPSK y la 16-QAM habrá cuatro ramas y para la 64-QAM seis ramas. Una vez que tenemos cada registro lleno con los 126 bits, se les aplica una rotación que depende de la rama con la que se esté trabajando. Después de aplicar dicha rotación los bits de cada rama pasan a alimentar la entrada del barajador de símbolo.

En la figura se puede observar un diagrama de bloques del barajador interno:


43

Figura 3.17. Esquema hardware del entrelazado de bits

El último bloque de la figura es el barajador de símbolo que como se observa

agrupa los bits de 4 en 4 (QPSK o 16-QAM) o de 6 en 6 (64-QAM) cogiendo uno de cada rama.

Ahora que ya se han formado los símbolos el barajador de símbolo será el encargado de desordenarlos. El barajador de símbolo es el primer bloque que se ve afectado por el modo de transmisión. Dependiendo del modo utilizado la profundidad de trabajo de este barajador será de 1512 posiciones en el modo 2K o 6048 en el modo 8K; con profundidad de trabajo se quiere decir la cantidad de símbolos que se cogen cada vez para desordenar.

Para finalizar cabe destacar que al desordenar símbolos lo que se está consiguiendo es separar portadoras (cada símbolo modula una portadora) que estén correladas entre sí de forma que ante un desvanecimiento profundo la posibilidad de que símbolos contiguos se vean afectados sea pequeña. Así, una portadora atenuada puede ser recuperada a partir de la correlación que existe con otras portadoras que no han sido atenuadas.


44

3.3 Receptor COFDM A continuación se presenta el esquema del receptor implementado:

Figura 3.18. Diagrama de bloques del receptor COFDM Al igual que ocurría con el transmisor, el receptor COFDM implementado es un modelo simplificado del receptor estandarizado para DVB-T o DAB, ya que se han omitido los bloques que introducen una mayor robustez al sistema para la corrección de errores mediante la aleatorización de la energía de los datos y las técnicas de entrelazado de los mismos. Como ya se comentó en el transmisor, dado que el sistema que se usará para la simulación es prácticamente ideal en cuanto a desvanecimiento por multitrayecto o ruido2, será suficiente aplicar codificación para la corrección de los posibles errores que se puedan producir en la comunicación.

Se presentan a continuación los distintos bloques que constituyen la cadena receptora: 3.3.1 Conversor Serie-Paralelo

La función de este bloque no es otra que pasar las muestras de señal transmitidas en serie a través del canal al supersímbolo correspondiente. Este supersímbolo estará formado símbolos de tamaño sNportadoraTg ×+ 2 , es decir, de tamaño igual al 2 Recordemos que se utilizará el cable de audio estudiado en el capítulo 1 como canal de transmisión en la comunicación que simularemos con Matlab.

RECEPTOR COFDM

Elimina


FFT

Reducción

del espectro

Igualador de

canal

Conversor

Serie-Paralelo

DecodificadorConvolucional

Decodificador

Reed-Solomon

Demodulador

QAM

Pasa a Bloques Reed-Solomon

Datos Recibidos

Detecta Señal

Sincronismo

Conversor Paralelo-

Serie

Extrae Supersímbolo Entrenamiento

Muestras


45

intervalo de guarda de cada símbolo más dos veces el número de portadoras que intervienen en la FFT.

Debemos tener en cuenta, tal y como se muestra en el diagrama, que antes de

realizar esta conversión de muestras a supersímbolos, el receptor debe detectar la señal de sincronismo para alinearse a la trama y comenzar todo el proceso de demodulación. 3.3.2 Eliminación del intervalo de guarda Este primer bloque del receptor tras la formación de los supersímbolos, tiene como misión la eliminación del intervalo de guarda en transmisión, introducido justo antes de la salida al canal con el objetivo de evitar los efectos del multitrayecto con respecto a la interferencia intersímbolo, de forma que la única interferencia posible sea la denominada como intrasímbolo. La señal recibida se muestrea con un periodo de muestreo de FsamT /1= , y se toman un número determinado de muestras según el modo de transmisión y el valor de la duración del intervalo de guarda. La eliminación del intervalo de guarda consiste en no tener en cuenta las M primeras muestras de cada periodo de símbolo, como se muestra en la siguiente figura:

Figura 3.19. Eliminación del intervalo de guarda del símbolo

El valor que ha de tomar M varía en función del modo de transmisión y de la

duración del intervalo guarda. Una vez eliminado el intervalo de guarda, las muestras restantes llevan toda la información necesaria para una correcta demodulación y constituirán la entrada del siguiente elemento. 3.3.3 FFT

Este bloque tiene como objetivo realizar la operación inversa a la IFFT de la cadena transmisora, por lo que ahora se realizará la transformada de Fourier directa (FFT). Esto implica que pasaremos de un conjunto de muestras en el dominio temporal al espectro frecuencial de la misma, tal como se muestra en la figura. De forma inversa a como se hacía en el transmisor:


46

Figura 3.20. Transformada de Fourier de la señal mediante el algoritmo FFT

Debemos tener en cuenta que gracias a la ortogonalidad entre las subportadoras

hemos evitado el uso de cientos de filtros y gracias a la FFT también se ahorra una gran carga computacional de multiplicadores, integradores y osciladores. En la práctica, se trabaja con la señal recibida muestreada. El proceso de integración se convierte por tanto, en uno de suma y el proceso completo de demodulación toma una forma idéntica al de la transformada discreta de Fourier (DFT), la cual, como ya se ha comentado, se implementa en la actualidad de forma muy eficiente gracias a la FFT (disponemos de circuitos integrados que la llevan a cabo), por lo que la modulación COFDM se puede realizar fácilmente sin grandes complicaciones en cuanto a instrumentación.

Las versiones más comunes de la FFT operan en un grupo de M2 muestras de tiempo y proporcionan el mismo número de coeficientes frecuenciales. Estos se corresponden con los datos demodulados de las subportadoras. En la práctica como muestreamos por encima de la tasa de Nyquist, no todos los coeficientes obtenidos se corresponden con portadoras que hemos usado realmente3.

El número de puntos que se utilizarán en el algoritmo de la FFT dependerá del modo de transmisión usado, que como ya mencionamos en el transmisor, para el estándar DVB-T será de 2048 puntos para el modo 2K y 8192 puntos para el modo 8K.

Como ya se vio en el transmisor, para poder realizar el algoritmo de la IFFT había que completar con ceros las muestras de entrada hasta obtener 2048 o 8192 puntos, según el caso. Por lo tanto, en el receptor, después de realizar la FFT es necesaria una ordenación frecuencial para eliminar los puntos correspondientes a las altas frecuencias y que no llevan información ya que valen cero. Esta ordenación frecuencial consiste en descartar esos valores nulos y serializar solamente 1705 o 6817 valores dependiendo del modo de transmisión. 3.3.4 Reducción del espectro Al igual que en el transmisor se llevaba a cabo la extensión del espectro para lograr una señal de KN 2= puntos y que, de esta forma se pudiera realizar la IFFT, en

3 Notar que esto no nos lleva a ninguna pérdida de capacidad o a un uso ineficiente del ancho de banda, sino que simplemente se corresponde con “headroom” para el filtrado analógico del sistema.

FFT

Xn[1]

Xn[N-1]

xn[0] xn[1]

xn[N-1]

Xn[0]


47

el receptor debemos eliminar la simetría conjugada de la señal y quedarnos de nuevo con una señal de K puntos para que pueda ser demodulada por el demodulador QAM. También es en este momento, justo al reducir el espectro tal y como muestra el diagrama de bloques del receptor, cuando se extrae el supersímbolo de entrenamiento que será procesado en el siguiente bloque, el igualador de canal. 3.3.5 Igualador de canal Una vez hecho el paso del dominio temporal al frecuencial, el igualador tiene como misión mitigar en lo posible las distorsiones inherentes al canal. Debido a que no existen canales perfectos, el receptor será alcanzado por diversas señales que serán versiones retardadas del rayo directo. Como ya se ha visto, el intervalo de guarda elimina la interferencia entre símbolos, y la misión del igualador será la de eliminar la interferencia intrasímbolo intentando compensar la acción del canal. Si el número de portadoras transmitidas es suficientemente grande, el comportamiento frecuencial del canal no será selectivo, es decir, se puede considerar que la influencia del canal para cada portadora se reduce a una atenuación y una fase (o escalado y rotación), siempre que el canal sea estable durante el periodo de tiempo que dura un supersímbolo.

Si denominamos kH al valor con el que el canal afecta al ancho de banda ocupado por la portadora k-ésima, la igualación, según el criterio de cero forzado se realiza multiplicando la portadora k-ésima por 1/ kH . Este criterio no tiene en cuenta el ruido presente, por lo que ante nulos espectrales, kH será un valor alto y el ruido que acompaña a la señal en esas frecuencias se verá tremendamente amplificado.

Si se quiere tener en cuenta el efecto combinado del ruido y de la interferencia, se puede optimizar según el criterio del mínimo error cuadrático, en la que la portadora k-ésima se ve multiplicada por el coeficiente

donde σn

2 es la varianza de ruido aditivo y σa2 es la varianza de los símbolos

transmitidos.

Para obtener los valores de kH se usan las señales piloto insertadas en todos los supersímbolos. En nuestro caso para obtener estos valores se ha enviado un supersímbolo de entrenamiento constituido por una secuencia pseudoaleatoria conocida tanto por el transmisor como por el receptor, por lo que en recepción se puede calcular la rotación y escalado que habrá que aplicar a los símbolos recibidos antes de realizar la decisión.


48

3.3.6 Demodulador QAM Este será el bloque del receptor encargado de realizar de detección de los símbolos. La entrada a este bloque serán los coeficientes frecuenciales o números complejos que indican los símbolos recibidos, que tras habérseles aplicado la corrección de fase y amplitud (en el igualador de canal) podrán ser demodulados fácilmente ya que se corresponderán con símbolos de la constelación QAM (constelación cuyo tamaño dependerá del número de niveles empleados en la modulación). Por lo tanto, a la salida de este bloque tendremos los datos demodulados o lo que es lo mismo la [ ]nS .

Figura 3.21. Demodulación QAM

3.3.7 Conversor Paralelo-Serie Este bloque tendrá como función convertir los valores detectados tras el demodulador en una secuencia serie de estos valores, ya que los bloques de corrección de errores del receptor (el decodificador convolucional y el decodificador Reed-Solomon) trabajan con los datos en serie, a nivel de bits el decodificador convolucional y a nivel de bytes el decodificador Reed-Solomon. 3.3.8 Decodificador Convolucional Este bloque que trabaja a nivel de bits realizará la decodificación convolucional de los datos serie recibidos. Debemos tener en cuenta que cuando se trata de codificación convolucional, el decodificador más eficiente es el decodificador Viterbi4. Este decodificador se basa sobre todo en el tipo de decisión suave (o soft-decision). A continuación se explica brevemente en qué consiste tal decisión y por qué es la elegida para la decodificación de este tipo de sistemas

♦ Decodificación por decisión suave (soft-decision)

Tomemos primero el ejemplo de un sistema de portadora única. Consideremos un señal de 2 niveles ( ± ). Podemos transmitir un bit por símbolo indicando con -1V que se ha transmitido un ‘0’ y con +1V que se ha transmitido un ‘1’

4 En el apéndice B se tratarán de explicar de forma más detallada los códigos convolucionales, tanto el funcionamiento de la codificación como su decodificación llevada a cabo por el decodificador Viterbi.

Demodulación

QAM

S[n]

Xn[0] Xn[1]

Xn[N-1]


49

En el receptor, suponiendo que la ganancia es correcta, podríamos esperar recibir una señal siempre cercana a -1V o +1V, según se haya transmitido un ‘0’ o un ‘1’, la distancia a los valores exactos ± 1V será debida al inevitable ruido que se añade en la transmisión.

Un receptor simple puede operar según la regla de que señales negativas se decodifiquen como ‘0’ y señales positivas como ‘1’. Esto es un ejemplo de decisión fuerte (hard decisión), con 0V como el umbral de decisión.

Si la amplitud instantánea del ruido nunca excediera ± 1V entonces, este receptor simple no cometería errores. Pero el ruido normalmente tiene una distribución gaussiana y puede alcanzar ocasionalmente amplitudes mayores, aunque con menor probabilidad que valores menores. Por lo tanto, si decimos que se reciben +0.5V, es más probable que signifique que se transmitió un ‘1’ que un ‘0’ aunque existe una cierta probabilidad de que ocurriera. El sentido común sugiere que si se recibe una señal con amplitud grande podemos estar más seguros con la decisión fuerte que si la amplitud es pequeña.

Este hecho de la existencia de un grado de confianza está es la base en los decodificadores de Viterbi de decisión suave (soft-decision). Estos almacenan una historia de las posibles secuencias transmitidas, haciéndose una idea de sus probabilidades relativas y finalmente seleccionando el valor ‘0’ o ‘1’ para cada bit según el que tenga mayor probabilidad. Por conveniencia, un decodificador Viterbi añade probabilidades logarítmicas para acumular la probabilidad de cada posible secuencia. Por tanto, el decodificador de Viterbi está basado en una decisión suave compuesta de una decisión dura junto con una medida de la amplitud de la señal recibida.

En sistemas de modulaciones con constelaciones rectangulares, como la 16-

QAM o la 64-QAM cada eje soporta más de un bit, a menudo con codificación Gray. En el receptor la decisión suave puede ser hecha de forma separada para cada bit recibido. Las métricas son más complicadas que para QPSK pero el principio del decodificador explotando su conocimiento de la fiabilidad de cada bit permanece.

Las métricas para COFDM son ligeramente más complicadas. Hemos comenzado entendiendo que la información de la decisión suave es una medida de la fiabilidad del lugar en que se coloca acompañado de una decisión fuerte.

Cuando los datos se modulan con un única portadora en un sistema invariable en el tiempo, entonces, a priori, todos los símbolos sufren la misma potencia de ruido en media; la información de la decisión suave simplemente necesita tomar nota de las variaciones aleatorias entre símbolos que causa este ruido.

Cuando los datos son modulados por múltiples portadoras, como en OFDM, las distintas portadoras tendrán diferentes SNR’s. Por ejemplo, una portadora que caiga dentro de un rechazo en la respuesta frecuencia estará compuesta principalmente de ruido; una en un pico sufrirá mucho menos. Por lo tanto podemos ver que además de las variaciones entre símbolos hay otro factor a tener en cuenta en las decisiones suaves: los datos que llevan portadoras que tienen una alta SNR son a priori más fiables que los


50

llevados por portadoras con baja SNR. Esta información extra a priori es conocida como información del estado del canal (CSI).

Este concepto de CSI engloba la interferencia que puede afectar a las portadoras selectivamente tal y como lo hace el ruido.

Incluir la información sobre el estado del canal en la generación de decisiones soft es la clave del rendimiento sin igual de COFDM en presencia de desvanecimiento selectivo en frecuencia e interferencia. 3.3.9 Decodificador Reed-Solomon Este bloque es el último de la cadena receptora. Trabaja a nivel de bytes y llevará a cabo la decodificación del código Reed-Solomon que se introdujo al comienzo del transmisor. La salida de este bloque serán los datos recibidos ya demodulados y decodificados por lo que si la comunicación ha sido aceptable, estos datos deberían ser iguales a los transmitiéndose admitiéndose una cierta tasa de error que haya sido imposible de corregir.

El código empleado en transmisión fue el código sistemático RS (204, 188, t = 8), que tiene la capacidad de corregir hasta ocho bytes erróneos de los 204 bytes que constituyen la entrada en una ejecución, ya que este código posee una distancia mínima de 2t+1. Como se ha podido observar la unidad de trabajo de este decodificador es el byte. Una vez que se conocen los bytes erróneos que hay en cada trama de entrada a este bloque, éstos pueden ser corregidos. Al tener la trama libre de errores el bloque da como salida los primeros 188 bytes, ya que este codificador es sistemático, lo que implica que toda la redundancia se introduce en los últimos 16 bytes (el resto es información). 3.3.10 Bloques no incluidos en el receptor Al igual que se ha comentado en el transmisor, el receptor COFDM utilizado en los estándares digitales de difusión, incluye técnicas de entrelazado y de aleatorización de la energía de los símbolos para obtener una gran protección frente a los errores que se puedan producir en la comunicación. Los bloques que se aparecen en el receptor estándar que no han sido incluidos en el receptor implementado serán los homólogos a los del transmisor, es decir, bloques que realizan la operación contraria a la realizada en transmisión. En la siguiente figura se muestra el diagrama de bloques del receptor completo utilizado en el estándar donde los bloques sombreados serán los que se explican a continuación ya que son los que difieren del receptor implementado en este proyecto.


51

Figura 3.22. Receptor COFDM estándar

3.3.10.1 Desbarajador Interno A la entrada del desbarajador de símbolos (o interno), los datos son valores complejos y en este bloque se va a implementar la función inversa de la segunda parte del barajador interno implementado en transmisión. Como se había dicho, en el barajador interno, las unidades de trabajo son grupos de bits que conforman los símbolos. En el transmisor lo que se hacía era alejar los símbolos correlados entre sí para que, en el caso de que hubiese un desvanecimiento, no se viesen afectados todos a la vez y así ayudar a la recuperación de la información. Por lo tanto aquí, en el desbarajador de símbolo, lo que se hará será deshacer lo barajado en el transmisor (agrupar las portadoras correladas). Es importante señalar que, en este bloque, no se toma ninguna decisión sobre los valores recibidos, simplemente se reubican los datos. Para realizar su tarea, este bloque usa la misma permutación que la empleada por el transmisor. Así, a la entrada se tienen 1512 valores complejos (en el modo 2K) o 6048 (en el modo 8K), y después de aplicar la permutación se obtienen a la salida la misma cantidad de valores complejos. Se consigue así que los símbolos recuperen la ordenación primitiva que tendrían de no haber barajador de símbolo.

RECEPTOR COFDM ESTÁNDAR

Elimina


FFT

Reducción

del espectro

Demodulador

QAM

Conversor

Serie-Paralelo

Decodificador

Reed-Solomon

Desaleatorizador

de energía

Decodificador Convolucional

Pasa a Bloques Reed-Solomon

Muestras

Datos

Recibidos

Detecta Señal

Sincronismo

Desbarajador

Externo

Extrae Supersímbolo Entrenamiento

Igualador de

canal

Desbarajador

Interno

Conversor Paralelo-

Serie


52

La figura da una idea de como funciona la permutación:

Figura 3.23. Desbarajador de símbolos

3.3.10.2 Desbarajador Externo Después de las decisiones tomadas en el decodificador de canal lo que obtenemos es una secuencia binaria que no está libre de errores de transmisión. El estándar pone como límite superior aceptable a la salida del bloque anterior una tasa de errores de 2x10-4.Esta tasa de errores es muy elevada para las aplicaciones de radiodifusión digital por lo que se introduce el barajador externo en el transmisor y el equivalente en el receptor para así poder bajar la tasa de errores hasta un límite que hace que se pueda considerar que se ha realizado una comunicación libre de errores

La misión que tiene el desbarajador externo es la de limitar las longitudes de las posibles ráfagas de errores que se puedan producir, para que los errores estén lo más dispersos posible. Con esto se logra que su detección y corrección sea más fácil de realizar.

Este elemento trabaja a nivel de bytes ya que el código externo está diseñado para dar protección a estas unidades. El funcionamiento de este bloque es el siguiente: Los bytes son paralelizados por el conmutador de entrada. El conmutador funciona de forma cíclica: cada vez que dirige un byte por una rama, conmuta a la siguiente posición.

A la salida hay otro conmutador que siempre está apuntando a la misma rama que el conmutador de entrada y que recoge un byte de la cola FIFO situada en esa rama. Las colas FIFO que forman parte de cada rama disminuyen su número de registros a medida que vamos aumentando el número de la rama. Así, llegamos a que la última rama no tiene ningún registro.

Cada registro tiene una capacidad de 17 bytes, lo cual concuerda con el sistema equivalente en transmisión.

Las características explicadas anteriormente se ven representadas gráficamente en la siguiente figura:


53

Figura 3.24. Desbarajador de bytes

La única característica que diferencia el barajador en transmisión del desbarajador en recepción es que los registros crecen de forma contraria, lo cual tiene como objetivo compensar los retardos introducidos en transmisión, de forma que todos los bytes sufran el mismo retardo. Al igual que en el barajador, al principio hay un estado transitorio mientras los registros no se llenan con bytes y esto ha de ser tenido en cuenta para eliminar los bytes que sobran. 3.3.10.3 Desaleatorizador de Energía El desaleatorizador de energía es el último bloque de la cadena receptora. Es el homólogo del aleatorizador de energía implementado en el transmisor y, por lo tanto, tiene las mismas características físicas que éste. La intención del aleatorizador en el transmisor era impedir que hubiese cierta predilección en enviar unos símbolos frente a otros. La misión de este bloque en el receptor es la de recomponer la secuencia original y conseguir así los datos que constituían las tramas MPEG-2 (tramas usadas en el estándar DVB-T).

Para realizar el aleatorizador se usaba la función OR-exclusiva; por lo tanto, en el desaleatorizador hemos de usar la misma función y la misma secuencia pseudoaleatoria. Todas las consideraciones que se tuvieron en cuenta en el caso del aleatorizador son aplicables aquí.

A la salida de este bloque debemos de obtener una secuencia binaria que debería de coincidir con las tramas MPEG-2 que se usaron a la entrada del transmisor, de esta forma cumplimos con el objetivo de todo sistema de transmisión: la información a la entrada del transmisor ha de ser la misma que la información obtenida a la salida del receptor.


54

3.4 Programación en MATLAB del modem COFDM Una vez adquiridos los conocimientos teóricos sobre la modulación COFDM es necesario implementar el sistema de transmisión en un lenguaje de programación para poder simular el comportamiento del mismo y comprobar que los resultados concuerdan con lo explicado en teoría. El lenguaje que se ha elegido para la programación del modulador y demodulador es el lenguaje MATLAB (archivos .m) ya que simplifica mucho el tratamiento de señales y datos y además, proporciona funciones para la transmisión y recepción a través de la tarjeta de sonido, por lo que se utilizará este programa para hacer las diversas pruebas. Los parámetros generales de configuración de la comunicación provendrán del interfaz gráfico que se explica en el capítulo 5, centrándose este capítulo en lo que es la programación básica del modulador/demodulador. Se explicará, por tanto, la programación de la rutina principal del modem, y también del transmisor y el receptor que son llamadas por el principal.

Para las pruebas de la transmisión se van a utilizar tanto secuencias aleatorias de

datos como ficheros que contienen imágenes y estos datos se transmitirán y recibirán en forma de tramas. El formato de las tramas es el siguiente:

Figura 3. Esquema de las tramas COFDM.

Una vez pasada la etapa de codificación para la corrección de errores tendremos un flujo binario que debe modularse en OFDM para esto se forman bloques de bits que se van modulando y formando supersímbolos OFDM donde tras añadírsele la guarda ya forman la trama de datos serie que se transmite a través del canal. El procedimiento que se va a seguir para explicar la programación realizada es el siguiente:

En primer lugar, se presenta el código del programa principal. Este programa realizará una transmisión y una recepción de una secuencia de datos, según los


55

parámetros que se indiquen, calculando al final la tasa de error de símbolo Reed-Solomon, la tasa de error de bit sin protección, es decir, sin tener en cuenta las etapas de codificación y decodificación, la tasa neta de transmisión (teniendo en cuenta sólo datos útiles) y el tiempo tardado en ejecutarse todo el programa, que superior al que se tarda en transmitir y recibir por el canal.

En segundo lugar, se presenta el código completo del transmisor, desglosándose

seguidamente, en los distintos bloques y explicándose cada uno de ellos.

En último lugar, se presenta el código completo del receptor, desglosándose, seguidamente, en los distintos bloques y explicándose el funcionamiento de cada uno de ellos.

Se presenta a continuación el código MATLAB del programa principal. Se diseñará

en el capítulo 5 un entorno gráfico que permita pedir al usuario los parámetros de configuración del sistema de transmisión pero para este capítulo se supondrán ciertos parámetros que se irán modificando en las diversas pruebas. 3.4.1 Programa principal Esquema básico del programa principal:

Código MATLAB del programa principal:

function [ Tiempo,TasaNeta,BER,SER,esImagen,DatosTX,DatosRX,EspectroTX, EspectroRX,ConstelacionTX,ConstelacionRX ] = principal_(imag,imagen,NumTramas, RSn,RSk,CCk,CCn,QAMm,ESPbanda,ESPginf,ESPgsup,GUAint,AUDIOfrec) %%%%%%%%%%%%%%%%%%%%%%%%%%%% %PARAMETROS DEL SISTEMA %%%%%%%%%%%%%%%%%%%%%%%%%%%% tic % Parametros de configuracion general % Parametros de configuracion RS %RSn = 204; RSk = 188; %RSn = 7; RSk = 3; RSm = ceil( log2(RSn + 1) ); SimbRS = floor(BDT*8/RSm); % Parametros de configuracion cod conv CCLength = [7]; CCGenerator = [171 133]; CCtrellis = poly2trellis(CCLength, CCGenerator); if CCk==1 model = [1 1]; elseif CCk==2

Transmisor Canal

Receptor Selección de

parámetros Presenta-ción de resultados


56

model = [1 0 1 1]; elseif CCk==3 model = [1 1 0 1 1 0]; elseif CCk==5 model = [1 1 0 1 1 0 0 1 1 0]; elseif CCk==7 model= [1 1 0 1 0 1 0 1 1 0 1 0 1 0]; else disp('error en el codigo convolucional'); end %CCk=1; CCn=2; model= [1 1]; %CCk=2; CCn=3; model= [1 0 1 1]; %CCk=3; CCn=4; model= [1 1 0 1 1 0]; %CCk=5; CCn=6; model= [1 1 0 1 1 0 0 1 1 0]; %CCk=7; CCn=8; model= [1 1 0 1 0 1 0 1 1 0 1 0 1 0]; % Parametros de configuracion QAM %QAMm = 2; % Bits por Simbolo de la QAM %QAMm = 4; %QAMm = 6; QAMtable = tablaqam(QAMm); % Parametros de configuracion de espectro %ESPbanda = 100; %ESPbanda = 10; %ESPginf = 10; %ESPginf = 2; %ESPgsup = 10; %ESPgsup = 4; % Parametros de configuracion de guarda %GUAint = 1/4; %GUAint = 1/8; %GUAint = 1/16; %GUAint = 1/32; % Parametros de configuracion de sincronismo SINCpre = 200; SINCchi = 100; SINCf0 = 0; SINCf1 = .5; SINCpos = 200; sincro = [ zeros(1,SINCpre) chirp(0:(SINCchi-1), SINCf0, SINCchi, SINCf1) zeros(1,SINCpos) ]; sincro = sincro/max(abs(sincro)); % Parametros de configuracion de audio AUDIOmargen = 0.5; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% if imag== 1 %imagen = 'Fish.bmp'; [X,MAP] = imread(imagen); A = ind2gray(X,MAP); I = round(255*A); % figure(1) % subplot(1,2,1),imagesc(I,[0 255]); colormap(gray); totaldatos = reshape(I,1,size(I,1)*size(I,2)); numdatos = length(totaldatos); DATpad = mod(BDT-mod(numdatos,BDT),BDT); Datos = [totaldatos zeros(1,DATpad)]; NumTramas = length(datos)/BDT; else


57

datos = randint(1, floor(NumTramas*SimbRS), [0 2^RSm-1]); % figure(1) % subplot(2,1,1),plot(datos); % title('Datos transmitidos'),xlabel('Indice temporal %n'),ylabel('Amplitud'); end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%TRANSMITE%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%% % Bucle del transmisor %%%%%%%%%%%%%%%%%% totaldatosTX = []; totaltramas = []; txSinProt = []; i=1; for trama=1:NumTramas %%%%%%%%%%%%%%%%%% % Genera los datos de la trama %%%%%%%%%%%%%%%%%% txDatos = datos(i:i+SimbRS-1); totaldatosTX = [ totaldatosTX txDatos ]; tramasTX=totaltramas; [totaltramas,txSS,SINCss,CCtam,CCPtam,QAMtam,ESPtam,RStam,GUAmue,BloqueRSTrama,txSinPr,EspectroTX,ConstelacionTX] = transmisor_(tramasTX,SimbRS,txDatos, RSk,RSn,RSm,CCtrellis,CCk,CCn,model,QAMm,QAMtable,ESPbanda,ESPginf,ESPgsup, GUAint,sincro,AUDIOfrec); txSinProt = [txSinProt txSinPr]; i=i+SimbRS; end %figure(4) %subplot(2,1,1),plot(totaltramas); %title('Tramas transmitidas por el canal'),xlabel('Indice temporal %n'),ylabel('Amplitud'); %esp = fftshift(fft(totaltramas)); %subplot(2,1,2),plot((abs(esp))); %%%%%%%%%%%%%%%% %Calculo de la tasa de transmision neta %%%%%%%%%%%%%%%% bitDatos = BloqueRSTrama * RSk * RSm * NumTramas; tasaNeta = bitDatos/(length(totaltramas)/AUDIOfrec) totaltramasTX = totaltramas; %%%%%%%%%%%%%%%%%% %Transmision a traves del canal %%%%%%%%%%%%%%%%%% totaltramas = [ zeros(1, AUDIOmargen*AUDIOfrec) totaltramas zeros(1, AUDIOmargen*AUDIOfrec) ] / max(abs(totaltramas)); wavplay(totaltramas, AUDIOfrec, 'async');


58

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%FIN TRANSMISOR%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%RECIBE%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% totaltramas = wavrecord(length(totaltramas), AUDIOfrec, 1, 'double')'; totaltramasRX = totaltramas; %figure(4) %subplot(2,1,2),plot(totaltramas,'r'); %title('Tramas recibidas tras el canal'),xlabel('Indice temporal %n'),ylabel('Amplitud'); [totaldatosRX,rxSinProt,EspectroRX,ConstelacionRX] = receptor_(totaltramas, sincro,SINCss,GUAmue,ESPginf,ESPbanda,ESPgsup,ESPtam,QAMm,QAMtam,CCtrellis,model,CCPtam,CCtam,RSn,RSk,RSm,BloqueRSTrama,txSS,RStam,AUDIOfrec); if imag == 1 totaldatosRX = totaldatosRX(1:numdatos); totaldatosTX = totaldatosTX(1:numdatos); imagenrx = reshape(totaldatosRX,size(I,1),size(I,2)) % figure(1) % subplot(1,2,2),imagesc(imagenrx,[0 255]); colormap(gray); else % figure(1) % subplot(2,1,2),plot(datos,'r'); % title('Datos recibidos'),xlabel('Indice temporal n'),ylabel('Amplitud'); end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%FIN RECEPTOR%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%% %Calculo de la tasa de error de simbolo Reed-Solomon %%%%%%%%%%%%%%%% if imag ==1 Errores=find(double(totaldatosTX) - double(totaldatosRX)); else Errores=find(totaldatosTX - totaldatosRX); End NumErr=length(Errores); NumDatos=length(totaldatosTX); SER=NumErr/NumDatos errSinProt=find(txSinProt - rxSinProt); numErrSinProt=length(errSinProt); numDatSinProt=length(txSinProt); BERSinProt=numErrSinProt/numDatSinProt disp(['Tasa de error de bit (sin proteccion): ' num2str(BERSinProt)]); toc Tiempo = toc; TasaNeta = tasaNeta; BER = BERSinProt; esImagen = imag; if esImagen, DatosTX = I; DatosRX = imagenrx; else DatosTX = totaltramasTX; DatosRX = totaltramasRX; end


59

3.4.2 Transmisor

El siguiente diagrama de bloques muestra las principales funciones de MATLAB que conforman cada bloque del transmisor así como los vectores o matrices entrada y salida a estos bloques. Esto nos servirá para explicar más claramente el funcionamiento conjunto del transmisor COFDM programado.

TRANSMISOR MATLAB

Figura 3. . Esquema del transmisor MATLAB

A continuación se presenta el código MATLAB del transmisor completo:

Codificador

Reed

Solomon

Codificador

Convo-

lucional

Conversor

Serie/

Paralelo

Modulador

QAM

Extensión

del

Espectro

IFFT

Adición

del

Intervalo

de Guarda

Conversor

Paralelo/

Serie

Añade Supersímbolo

de Entrenamiento

Añade Señal de Sincronismo

txDatos txRS

BloqueRS

RellenoRelleno

txPAR txCOM

txCOM

txSS

txESP

txTIE txGUA

txMUE

Sincro

Relleno

rsenc convenc s2p_

qam_ extesp_ ifft_

guard_ p2s_

txCC

txMUE


60

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%TRANSMISOR%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% function [totaltramas,txSS,SINCss,CCtam,CCPtam,QAMtam,ESPtam,RStam, GUAmue,BloqueRSTrama,txSinProt,EspectroTX,ConstelacionTX]=transmisor_(tramasTX, SimbRS,txDatos,RSk,RSn,RSm,CCtrellis,CCk,CCn,model,QAMm,QAMtable,ESPbanda,ESPginf,ESPgsup,GUAint,sincro,AUDIOfrec) totaltramas=[]; %%%%%%%%%%%%%%%%%% % Codificacion RS %%%%%%%%%%%%%%%%%% %Añade padding BloqueRSTrama = ceil(SimbRS/RSk); Rstam = length(txDatos); Rspad = mod(RSk-mod(SimbRS,RSk),RSk); txDatos = [txDatos zeros(1,RSpad)]; txRS = []; j = 1; for i=1:BloqueRSTrama bloqueDatos = txDatos(j:j+RSk-1); bloqueGalois = gf(bloqueDatos, RSm); bloqueRS = rsenc(bloqueGalois, RSn, RSk); j = j + RSk; txRS = [ txRS double(bloqueRS.x) ]; end % Pasa a 0s y 1s txRS = de2bi(txRS, RSm, 'left-msb'); txRS = reshape(txRS, 1, BloqueRSTrama * RSn * RSm); %%%%%%%%%%%%%%%%%% % Codificacion Convolucional %%%%%%%%%%%%%%%%%% % Añadir padding CCtam = BloqueRSTrama * RSn * RSm; % Guarda el tamaño para cuando se % quite el padding CCpad = mod(CCk - mod(CCtam, CCk), CCk); % Numero de bits de padding txRS = [txRS zeros(1, CCpad) ]; % Añande el padding con ceros txCC = convenc(txRS, CCtrellis); CCPtam = length(txCC); txCC = puncture(txCC,model); % Introduce el perforado para obtener la tasa txSinProt = txCC; %%%%%%%%%%%%%%%%%% % Codificacion QAM %%%%%%%%%%%%%%%%%% % Añade padding QAMtam = ( CCtam + CCpad ) / CCk * CCn; QAMpad = mod(QAMm - mod(QAMtam, QAMm), QAMm); txCC = [txCC zeros(1, QAMpad) ]; txPAR = s2p_(txCC, QAMm);


61

txCOM = qam_(txPAR, QAMtable); %figure(2) %subplot(1,3,1),plot(txCOM,'.b'); %title('Constelacion transmitida'), xlabel('Eje de fase'),ylabel('Eje de %cuadratura'); %axis square; %axis equal; %grid on; ConstelacionTX=txCOM; %%%%%%%%%%%%%%%%%% % Inserta SuperSimbolo entrenamiento %%%%%%%%%%%%%%%%%% rand('state',0); txSS = QAMtable(1)/sqrt(2) * exp(2i*pi*rand(ESPbanda, 1)); txCOM = [ txSS ; txCOM ]; %%%%%%%%%%%%%%%%%% % Extension espectro %%%%%%%%%%%%%%%%%% % Añade padding ESPtam = ESPbanda + ( QAMtam + QAMpad ) / QAMm; %ESPtam = ( QAMtam + QAMpad ) / QAMm; ESPpad = mod(ESPbanda - mod(ESPtam, ESPbanda), ESPbanda); txCOM = [txCOM ; zeros(ESPpad, 1) ]; txESP = extesp_(txCOM, ESPbanda, ESPginf, ESPgsup); %%% % Necesitamos saber el numero de supersimbolos por trama SINCss = ( ESPtam + ESPpad ) / ESPbanda; %%% %%%%%%%%%%%%%%%%%% % IFFT %%%%%%%%%%%%%%%%%% txTIE = ifft_(txESP); %%%%%%%%%%%%%%%%%% % Añade guarda %%%%%%%%%%%%%%%%% GUAmue=ceil(GUAint*size(txTIE,2)); txGUA = guard_(txTIE, GUAmue); %%%%%%%%%%%%%%%%%% % Pasa a muestras %%%%%%%%%%%%%%%%%% txMUE = p2s_(txGUA); txMUE = txMUE/max(abs(txMUE)); %figure(3) esp=(fft(txMUE)); f = 0:AUDIOfrec/(length(esp)/2-1)/2:AUDIOfrec/2; %subplot(2,1,1),plot(f, 20*log(abs(esp(1:floor(length(esp)/2))))); %title('Espectro COFDM transmitido'), %xlabel('Frecuencia(Hz)'),ylabel('Magnitud(dB)'); EspectroTX = 20*log(abs(esp(1:floor(length(esp)/2))));


62

%%%%%%%%%%%%%%%%%% % Añade señal sincronismo %%%%%%%%%%%%%%%%%% txMUE = [ sincro txMUE]; %%%%%%%%%%%%%%%%%% % Fin bucle del transmisor %%%%%%%%%%%%%%%%%% totaltramas = [ tramasTX txMUE ];

A continuación se explican, por bloques, las distintas funciones del transmisor.

Además comprobaremos mediante un sencillo ejemplo que la comunicación se realiza de forma correcta, es decir, que el vector de datos recibidos es el mismo que el vector de datos transmitidos. Para el ejemplo supondremos que transmitimos una única trama de datos aleatorios de un solo byte. 3.4.2.1 Codificación Reed-Solomon % Parametros de configuracion RS RSn = 7; RSk = 3; RSm = ceil( log2(RSn + 1) ); %%%%%%%%%%%%%%%%%% % Codificacion RS %%%%%%%%%%%%%%%%%% %Añade padding BloqueRSTrama = ceil(SimbRS/RSk); Rstam = length(txDatos); Rspad = mod(RSk-mod(SimbRS,RSk),RSk); txDatos = [txDatos zeros(1,RSpad)]; txRS = []; j = 1; for i=1:BloqueRSTrama bloqueDatos = txDatos(j:j+RSk-1); bloqueGalois = gf(bloqueDatos, RSm); bloqueRS = rsenc(bloqueGalois, RSn, RSk); j = j + RSk; txRS = [ txRS double(bloqueRS.x) ]; end % Pasa a 0s y 1s txRS = de2bi(txRS, RSm, 'left-msb'); txRS = reshape(txRS, 1, BloqueRSTrama * RSn * RSm);

El bloque de codificación Reed-Solomon va tomando todos los bloques de la trama y los va codificando gracias a la función de MATLAB rsenc formándose así el vector txRS que será el vector de entrada al siguiente bloque, el codificador convolucional.


63

Los parámetros que se utilizan en la codificación RS serán: RSk (tamaño del bloque o palabra de entrada al codificador), RSn (tamaño de la palabra codificada de salida según los códigos Reed-Solomon) y RSm (el número de bits por símbolo que se utilizarán para formar los bloques Galois, este número vendrá determinado por el valor de RSn).

Este bloque se encarga en primer lugar de calcular el número de símbolos Reed-

Solomon de la trama y a continuación rellena con ceros el vector de entrada, para prepararlo para la funcion de MATLAB rsenc, que lo recibirá como parámetro.

Para el cálculo de los bits de relleno que hacen falta se utiliza el operador mod de

MATLAB. Este operador realiza la división entera entre los operandos (x, y) que se le pasan como parámetros (mod(x,y)) y devuelve el resto. Esto nos es muy útil ya que como la función convenc tomará los símbolos del vector de datos de entrada en grupos de RSk, pero es posible que no siempre salga exacto y sobren ciertos símbolos. Realizando la operación mod(SimbRS,RSk) averiguamos los símbolos que sobran. Si hacemos esto se lo restamos a RSk ya tenemos el número de bits de relleno que hacen falta. Hay que destacar que volvemos a hacer un mod del resultado con RSk sólo para el caso en que nos salgan cero bits sobrantes, ya que si no lo incluyéramos nos saldrían CCk bits de relleno, mientras que debe salir cero. Un ejemplo sencillo de esta operación sería: >> RSk=3; >> SimbRS=10; >> mod(SimbRS,RSk) ans = 1 >> RSpad=mod(RSk-ans,RSk) RSpad = 2

Se queda tanto por tanto, que si el número de símbolos Reed-Solomon de la

trama es 10 y se toman los símbolos en grupos de 3, habrá que añadir 2 símbolos de relleno al vector para obtener un número que sea divisible entre 3 (12/3 = 4 grupos de 3 símbolos Reed-Solomon).

Para cada bloque RS (Reed-Solomon) de la trama se forma un bloque de datos que se obtiene de tomar RSk elementos del vector txDatos que será el vector que guarda los datos que se van a transmitir. A continuación y tomando como parámetros de entrada el bloque de datos y los bits por símbolo de cada bloque RS se forma las estructura Galois (mediante la función de MATLAB gf) con la que trabaja la función de MATLAB rsenc. La función rsenc codifica el bloque Galois según el código Reed-Solomon (RSk,RSn) y devuelve otra estructura Galois con el bloque RS ya codificado. Por esto, al final del bucle se va añadiendo al vector txRS el bloque RS pero pasado del tipo estructura Galois al tipo array de MATLAB (esto se hace poniendo bloqueRS.x) ya que el resto de funciones del transmisor trabajarán con este tipo de datos (array).


64

Las últimas líneas de código que se presentan en este bloque tienen la misión de

preparar el vector txRS para el siguiente bloque, el codificador convolucional. Para ello se utilizan las funciones de MATLAB de2bi y reshape que realizan en primer lugar la conversión de decimal a binario (de2bi) del vector de símbolos codificados, donde cada símbolo del vector pasa a ser una fila de la matriz de salida con el valor en binario. En segundo lugar pasamos esta matriz de 0’s y 1’s a un vector fila que será la entrada al siguiente bloque, el codificador convolucional.

Para que quede más claro el funcionamiento del modem, usaremos un ejemplo muy sencillo de datos a transmitir y comprobaremos si estos datos, a la salida del receptor coinciden, lo que implicará que el modem funciona de forma correcta.

Comenzamos con el ejemplo, y tomamos los siguientes parámetros de configuración general y del bloque de codificación Reed-Solomon:

NumTramas = 1; BDT = 1; RSn=7; RSk=3; RSm=3; datos = randint(1, floor(NumTramas*BDT*8/RSm), [0 2^RSm-1]);

El resultado que se obtiene al ejecutar el programa es: datos = 7 0 BloqueRSTrama = 1 RStam = 2 RSpad = 1 txDatos = 7 0 0 bloqueDatos = 7 0 0 bloqueGalois = GF(2^3) array. Primitive polynomial = D^3+D+1 (11 decimal) Array elements = 7 0 0 bloqueRS = GF(2^3) array. Primitive polynomial = D^3+D+1 (11 decimal) Array elements = 7 0 0 4 7 4 3


65

Vector codificado. Pasamos de tamaño 3 a tamaño 7: txRS = 7 0 0 4 7 4 3 txRS = 1 1 1 0 0 0 0 0 0 1 0 0 1 1 1 1 0 0 0 1 1

Tomando los valores por columnas pasamos esta matriz a un vector serie: txRS = Columns 1 through 14 1 0 0 1 1 1 0 1 0 0 0 1 0 1 Columns 15 through 21 1 0 0 0 1 0 1 3.4.2.2 Codificación convolucional % Parametros de configuracion cod conv CCLength = [7]; CCGenerator = [171 133]; CCtrellis = poly2trellis(CCLength, CCGenerator); [CCk CCn] = size(CCGenerator); %%%%%%%%%%%%%%%%%% % Codificacion Convolucional %%%%%%%%%%%%%%%%%% % Añadir padding CCtam = BloqueRSTrama * RSn * RSm; % Guarda el tamaño para cuando se % quite el padding CCpad = mod(CCk - mod(CCtam, CCk), CCk); % Numero de bits de padding txRS = [txRS zeros(1, CCpad) ]; % Añande el padding con ceros txCC = convenc(txRS, CCtrellis); CCPtam = length(txCC); txCC = puncture(txCC,model); % Introduce el perforado para obtener la tasa txSinProt = txCC;

Esta función realiza la codificación convolucional del vector de entrada txRS, que a su vez era la salida del codificador Reed-Solomon, obteniéndose a la salida del bloque el vector codificado txCC. Con esto acaba la fase de codificación en el transmisor.


66

La codificación convolucional es un caso especial de codificación para el control de errores. A diferencia de los codificadores de bloque un codificador convolucional es un dispositivo con memoria. A pesar de que un codificador convolucional admite un número fijo de símbolos de mensaje y produce un número fijo de símbolos codificados, sus cálculos no sólo dependen del conjunto actual de símbolos de entrada sino también de algunos símbolos de entrada previos.

Este bloque se encarga en primer lugar de rellenar con ceros el vector de entrada, para prepararlo para la funcion de MATLAB convenc, que lo recibirá como parámetro.

La función de MATLAB que realiza la codificación convolucional, convenc,

sigue la estructura: code=convenc(msg,trellis)

Esta función codifica el vector binario msg usando el codificador convolucional

definido por la estructura trellis de MATLAB. Cada símbolo en msg está formado por log2(trellis.numInputSymbols) bits, por lo que el número de bits de la entrada vendrá fijado para que el número de símbolos que se obtengan de msg sea entero. El vector msg contiene uno o más símbolos. El vector de código de salida contiene uno o más símbolos y cada uno está formado por log2(trellis.numOutputSymbols) bits.

La estructura Trellis se puede definir explícitamente indicándose el número de símbolos de entrada, de salida, el número de estados, los estados a los que se pasan, y las salidas. Un ejemplo de esto sería:

trel = struct('numInputSymbols',2,'numOutputSymbols',4,... 'numStates',4,'nextStates',[0 2;0 2;1 3;1 3],... 'outputs',[0 3;1 2;3 0;2 1]); code2 = convenc(randint(10,1),trel);

Este ejemplo define una estructura trellis explícitamente y utiliza convenc para

codificar 10 símbolos de 1 bit.

Otra forma de definir la estructura trellis, es mediante la función poly2trellis, que es la que se ha utilizado en este proyecto. La función poly2trellis acepta una descripción polinomial de un codificador convolucional y devuelve la descripción de la estructura trellis correspondiente.

trellis = poly2trellis(ConstraintLength,CodeGenerator)

Lleva a cabo la conversión para un codificador de tasa nk / . ConstraintLength es un vector k×1 que especifica el retraso para los k flujos de bits de entrada del codificador. Los elementos de este vector indican el número de bits almacenados en cada registro de desplazamiento incluyendo los bits de entrada actuales. CodeGenerator es una matriz nk × de números en octal que especifica las n conexiones de salida para cada uno de los k flujos de bits de entrada. El elemento de la i-ésima fila y j-ésima columna indica cómo la i-ésima entrada contribuye a la i-ésima salida.

La estructura trellis elegida para el codificador convolucional en nuestro proyecto es la utilizada en el estándar de DAB y DVB-T y se representa como sigue:


67

CCLength = [7]; CCGenerator = [171 133]; CCtrellis = poly2trellis(CCLength, CCGenerator); [CCk CCn] = size(CCGenerator);

Si la representamos mediante sumadores módulo 2 y registros de desplazamiento

obtenemos:

Como ya se comentaba en la sección 3.2.1.2 donde se describía teóricamente el codificador convolucional, la tasa base que se obtiene del codificador es 1/2 y para obtener el resto de tasas hay que incluir un bloque que realice el llamado perforado o puncturing. Las técnicas de perforado parten del vector codificado convolucionalmente y según la tasa que se desee obtener, toman un modelo o patrón determinado que indica los bits que habrá que eliminar del vector codificado. Un ejemplo de modelo puede ser:

model = [1 1 0 1 1 0]

que es el modelo que se utiliza para obtener la tasa 3/4, que indica que entran tres bits en el codificador convolucional y saldrán cuatro. En el código del programa principal aparecen el resto de patrones o modelos de las distintas tasas. La función de MATLAB que realiza el perforado del código es la siguiente:

%Funcion punture. Realiza el perforado del vector codificado %convolucionalmente para obtener la tasa de código deseada. function txCC = puncture(txCOD,model) j = 1; k = 1; txCC = []; for i=1:length(txCOD) if model(k)==1 txCC(j)=txCOD(i); j=j+1; end if k==length(model) k=1; else k=k+1; end end

Esta función tiene como argumentos de entrada el vector codificado y el modelo de la tasa determinada. A la salida devuelve el vector codificado al que se le ha


68

realizado el perforado, es decir, se le han eliminado ciertos bits redundantes para obtener dicha tasa.

El procedimiento que se sigue para realizar el puncturing es el siguiente:

Se va recorriendo el vector codificado y a la vez el modelo. En caso de que en el modelo aparezca un 0 ese bit habrá que eliminarlo, por lo que no se copia en el vector final.

Para entender más fácilmente todo esto, ponemos un ejemplo:

>> txCOD = [ 1 1 1 1 0 0 1 0 1 0 0 1 0 0 1 1 1 1]; >> model = [1 1 0 1 1 0]; >> txCC = puncture(txCOD, model) txCC = 1 1 1 0 1 0 0 0 0 0 1 1

Se puede observar que el perforado se ha realizado de forma correcta, y que el vector de salida es de menor tamaño que txCOD, tal y como debería ser. Debemos recordar que las técnicas de perforado pretenden reducir la redundancia y por tanto, protección de los datos. Parten de la tasa 1/2 que es la que introduce más redundancia ya que dobla el número de bits, y para conseguir la 3/4 eliminan los bits correspondientes. Es por esto que el vector txCOD es de longitud 18 y txCC es de longitud 12.

Continuando con el ejemplo de transmisión de partida y tomando como entrada el vector de salida del anterior bloque, txRS y los siguientes parámetros se obtiene: Parámetros: CCLength = [7]; CCGenerator = [171 133]; CCtrellis = poly2trellis(CCLength, CCGenerator); CCk = 7; CCn = 8;

Resultado en MATLAB: CCtam = 21 CCpad = 0 txRS = Columns 1 through 14 1 0 0 1 1 1 0 1 0 0 0 1 0 1 Columns 15 through 21 1 0 0 0 1 0 1

Antes del perforado:


69

txCC = Columns 1 through 14 1 1 1 0 1 1 0 0 0 1 1 1 0 1 Columns 15 through 28 1 1 0 0 0 1 0 1 0 0 1 1 1 1 Columns 29 through 42 1 0 0 1 0 1 0 0 1 0 0 0 1 1 CCPtam = 42

Tras el perforado: txCC = Columns 1 through 14 1 1 0 1 0 0 1 0 1 1 0 1 1 0 Columns 15 through 24 1 1 1 0 1 1 0 1 0 1

Al ser la tasa del codificador 7/8 vemos que el vector codificado txCC tiene una

longitud 8/7 mayor a la del vector de entrada txRS. 3.4.2.3 Modulador QAM % Parametros de configuracion QAM QAMm = 2; % Bits por Simbolo de la QAM QAMtable = tablaqam(QAMm); %%%%%%%%%%%%%%%%%% % Modulacion QAM %%%%%%%%%%%%%%%%%% % Añade padding QAMtam = ( CCtam + CCpad ) / CCk * CCn; QAMpad = mod(QAMm - mod(QAMtam, QAMm), QAMm); txCC = [txCC zeros(1, QAMpad) ]; [txPAR] = s2p_(txCC, QAMm); [txCOM] = qam_(txPAR, QAMtable);

El modulador QAM será el que se encargue de asignar a cada símbolo que se

transmite un punto de la constelación. Esta constelación tendrá tantos niveles o bits por símbolo como se indiquen en el parámetro de entrada del sistema. Para llevar a cabo esta asignación vemos que en primer lugar se debe crear la tabla de la QAM a partir del número de bits por símbolo de la modulación.

Dado que el vector de entrada al modulador deberá tener una cierta longitud

divisible por el número de bits por símbolo, y es posible que esto no sea así, se hace


70

necesaria, en determinados casos, la adición de bits de relleno en el vector de salida del codificador convolucional que será el de entrada a este bloque.

Una vez que se han añadido los bits de relleno necesarios, realizamos en primer lugar y antes de la modulación, la conversión serie paralelo de los datos (vector txCC) por lo que pasamos de la ristra de bits a símbolos formados por tantos bits como indique el parámetro y además en paralelo, es decir, como vector columna. Son estos símbolos los que pasarán al modulador QAM.

El modulador QAM tomará los símbolos (que tendrán un valor en decimal) y la tabla de la constelación, y dada la correspondencia entre ambos, obtiene un vector columna donde cada elemento será el número complejo correspondiente al símbolo, según la constelación de la modulación QAM dada, obteniéndose a la salida de este bloque el vector txCOM.

Las funciones implicadas en este bloque son s2p_ y qam_ que no son funciones de MATLAB propiamente sino que han sido creadas para los propósitos explicados. El código de estas funciones se muestra a continuación: %Funcion s2p_. Transforma un vector binario de entrada ser, en un vector %decimal columna con tantas filas como resulte de dividir ser entre tam. function [par] = s2p_(ser, tam) bloq = floor( length(ser) / tam); par = []; if bloq > 0, par = reshape( ser(1:(bloq * tam)), tam, bloq).';

par = bi2de(par, 'left-msb');%pasa a decimal; end

Pongamos un ejemplo sencillo de su funcionamiento:

Vamos a suponer el siguiente vector de datos y 3 bits por cada símbolo que se transmite. El resultado en MATLAB es el siguiente: >> datos datos = 0 0 0 1 0 1 0 1 0 1 1 1 >> QAMm QAMm = 3 >> par=s2p_(datos,QAMm) par = 0 5 2 7

Con lo que se comprueba que el resultado es un vector columna de números decimales y de tantas filas como el resultado de dividir la longitud del vector datos entre el número de bits por símbolo, es decir 12/3=4.


71

A continuación se va a realizar la asignación del número complejo correspondiente según la tabla de la QAM. La función que crea la tabla no es de MATLAB y su código es:

%Funcion tablaqam. Crea la tabla con los puntos de la constelacion. function [tablaqam] = tablaqam(BitSimb) iBits = floor(BitSimb/2); %numero de bits para el eje de fase qBits = ceil(BitSimb/2); %numero de bits para el eje de cuadratura

tablaqam = []; %Vector columna que contendra los numeros complejos de la %constelacion for k = 0:(2^BitSimb-1),

iLin = gray2lin_(bitshift(k, -qBits)); %se queda con los bits de %fase qLin = gray2lin_(bitand(k, 2^qBits-1)); %se queda con los bits de %cuadratura

tablaqam = [tablaqam ; (iLin*2-(2îBits-1))+(qLin*2-(2^qBits-1))*i ]; %Se centra la constelacion y se multiplica por dos para obtener %numeros enteros

end

De los BitSimb bits de cada símbolo los más significativos serán los que se usen para el eje en fase y los menos significativos para el eje en cuadratura, es decir se escogen de forma consecutiva, aunque normalmente se suelen escoger de forma alterna.

Esta función decide, en primer lugar, el número de bits que se van a usar para el

eje de fase y para el eje de cuadratura. A continuación y para cada símbolo se separa la parte en fase y la parte en cuadratura, y se pasa del valor gray (en que está codificada cada posición) a su posición determinada dentro de la tabla (gray2lin_). Con estos valores se calculan los números complejos correspondientes a los puntos de la constelación, de forma que quede centrada y con valores enteros. La función tablaqam hace uso de otra función, gray2lin_ que se explica a continuación. %Funcion gray2lin_. Pasa un numero codificado en gray a su correspondiente %lineal function lin = gray2lin_(gray) bin = de2bi(gray,'left-msb'); %Pasa el numero gray a binario invierte = 0; new_bin = []; %Vector binario con el numero correspondiente al gray for k = 1:length(bin), if invierte new_bin(k) = ~ bin(k); %hace la not al bit k, lo invierte else new_bin(k) = bin(k); end if bin(k) invierte = ~ invierte; %modifica invierte para el siguiente bit end end lin = bi2de(new_bin,'left-msb');Pasa el numero en binario a decimal


72

Ya se ha comentado en la primera parte de este capítulo, que se utiliza codificación gray para los símbolos de la constelación QAM y esto es así porque esta codificación tiene la propiedad de que símbolos vecinos (a distancia mínima) de la constelación solo varían un bit por lo que disminuye la probabilidad de error ya que si la relación señal a ruido es suficientemente alta es mucho más probable que un símbolo sea confundido con un símbolo vecino que con otros que disten mucho del símbolo inicialmente transmitido. La función gray2lin_ pasa de un número codificado en gray a su correspondiente en lineal. Para ello en primer lugar pasa el número a binario (a ceros y unos). La bandera invierte se usa para indicar si hay que invertir el bit o no, es decir, para pasar de uno a cero o viceversa. Se recorrerá el vector bin que almacena los valores binarios del número codificado que se pasa como argumento de entrada. El vector new_bin almacenará el número en binario una vez decodificado. El primer bit de este vector será igual al del vector bin. Los siguientes bits vendrán determinados por el valor del bit correspondiente de bin. En caso de ser uno habrá que invertir el siguiente bit de bin antes de copiarlo en new_bin, y en caso de ser cero, se copia tal cual. Ya, por último, se pasa el número decodificado de binario a decimal con la función de MATLAB bi2de.

Si creamos una tabla de 3 bits por símbolo, el resultado que ofrece MATLAB es: >> tqam=tablaqam(QAMm) tqam = -1.0000 - 3.0000i -1.0000 - 1.0000i -1.0000 + 3.0000i -1.0000 + 1.0000i 1.0000 - 3.0000i 1.0000 - 1.0000i 1.0000 + 3.0000i 1.0000 + 1.0000i

La función qam_ solo realizará la correspondencia entre cada símbolo y cada

punto de la constelación, teniendo en cuenta que al símbolo 0 le corresponde el valor de la primera fila, al símbolo 1 el de la segunda fila y así sucesivamente. El código de esta función se muestra a continuación: %Funcion qam_. Realiza la asignacion de los bloques (simbolos)con el %numero complejo correspondiente segun la tabla de la modulacion qam.El %resultado lo guarda en el vector columna com que tendrá tantas filas como %el vector par que se le pasa como entrada a la funcion.

function [com] = qam_(par, tqam)

com = [ tqam(par(:) + 1) ];

Si continuamos con el ejemplo anterior, con la tabla de la QAM obtenida y el vector de símbolos par, el resultado que se obtiene de ejecutar la función qam_ es: >> com=qam_(par,tqam) com = -1.0000 - 3.0000i


73

1.0000 - 1.0000i -1.0000 + 3.0000i 1.0000 + 1.0000i

El vector com será el vector de salida del modulador QAM y estará formado por números complejos. Estos números forman lo que es el espectro de la señal que se está transmitiendo, pero dado que la señal en tiempo que se transmite a través del canal debe ser una señal real, debemos entonces pasar este vector al siguiente bloque que se encargará de realizar una extensión de este espectro adecuada (añade la parte simétrica conjugada del espectro) para que a la salida del transmisor obtengamos la señal real que queremos.

Si continuamos con la cadena de datos del ejemplo inicial podemos ver que el vector resultado que se obtiene a la salida de este bloque sería: QAMtam = 24 QAMpad = 0 txCC = Columns 1 through 14 1 1 0 1 0 0 1 0 1 1 0 1 1 0 Columns 15 through 24 1 1 1 0 1 1 0 1 0 1 txPAR = 13 2 13 11 11 5

Constelación transmitida: txCOM = 1.0000 - 1.0000i -3.0000 + 3.0000i 1.0000 - 1.0000i 3.0000 + 1.0000i 3.0000 + 1.0000i -1.0000 - 1.0000i Donde se ha usado una constelación de cuatro bits/símbolo o 16-QAM. 3.4.2.4 Inserción del supersímbolo de entrenamiento %%%%%%%%%%%%%%%%%% % Inserta SuperSimbolo entrenamiento %%%%%%%%%%%%%%%%%% rand('state',0); txSS = QAMtable(1)/sqrt(2) * exp(2i*pi*rand(ESPbanda, 1)); txCOM = [ txSS ; txCOM ];


74

Justo antes de realizar la extensión del espectro debemos insertar un

supersímbolo5 de entrenamiento, es decir, un supersímbolo conocido tanto por el transmisor como por el receptor. Este será clave en la comunicación ya que gracias a él se podrán calcular la rotación y escalado que sufre cada supersímbolo al transmitirse por el canal, con lo que una vez conocidos ambos, el receptor ya no tendrá problema para detectar los símbolos.

Como muestra el código del bloque, este supersímbolo estará modulado en PSK y tendrá una potencia parecida al resto de símbolos de la constelación (como indica su amplitud), estará ocupando las primeras filas del vector que contiene el espectro, y por tanto será el primer supersímbolo que se transmita.

Suponiendo que el espectro estará formado por 4 bandas y que el vector que contiene el espectro es txCOM (salida del bloque anterior) podemos ver el resultado de la ejecución de MATLAB de este programa como: txSS = -2.6719 - 1.3641i 1.8556 - 2.3573i 0.3415 + 2.9805i 2.2997 + 1.9265i txCOM = -2.6719 - 1.3641i 1.8556 - 2.3573i 0.3415 + 2.9805i 2.2997 + 1.9265i 1.0000 - 1.0000i -3.0000 + 3.0000i 1.0000 - 1.0000i 3.0000 + 1.0000i 3.0000 + 1.0000i -1.0000 - 1.0000i

3.4.2.5 Extensión del espectro % Parametros de configuracion de espectro ESPbanda = 4; ESPginf = 2; ESPgsup = 2; %%%%%%%%%%%%%%%%%% % Extension espectro %%%%%%%%%%%%%%%%%% % Añade padding ESPtam = ESPbanda + ( QAMtam + QAMpad ) / QAMm; ESPpad = mod(ESPbanda - mod(ESPtam, ESPbanda), ESPbanda); txCOM = [txCOM ; zeros(ESPpad, 1) ]; [txESP] = extesp_(txCOM, ESPbanda, ESPginf, ESPgsup);

5 Recordemos que se ha llamado supersímbolo a la agrupación de N símbolos correspondientes a las N portadoras que intervienen en la FFT/IFFT.


75

%%% % Necesitamos saber el numero de supersimbolos por trama SINCss = ( ESPtam + ESPpad ) / ESPbanda; %%%

El bloque extensión del espectro, como ya se ha comentado, tiene la función de añadir la parte simétrica conjugada al espectro que recibe como entrada. Esta extensión del espectro se lleva a cabo tal y como se explicó en la parte teórica del capítulo.

En el código del bloque que aquí se presenta, se puede ver que en primer lugar se prepara el vector columna de entrada para que se le pueda realizar la extensión mediante la adición de relleno o ceros al final del mismo. Esto se hace ya que la longitud que debe tener este vector a la hora de realizarse la extensión es fija y viene determinada por el número de bandas o subportadoras que van a intervenir posteriormente en la realización de la transformada inversa de Fourier (bloque IFFT).

El número de bandas vendrá dado por el parámetro ESPbanda. Los parámetros

ESPginf y ESPgsup se utilizarán para dejar algunas bandas de guarda, es decir, bandas por las que no se transmita nada por protección, ya que puede haber casos (como el de nuestro cable) en los que la transmisión por la banda base (o por bandas de alta frecuencia) no sea conveniente6.

El código de la función extesp_ se muestra a continuación: %Funcion extesp_. Añade la parte simétrica conjugada del espectro function [esp] = extesp_(com, NumPort, Ginf, Gsup) bloq = floor(length(com)/NumPort); %calcula el numero de supersimbolos ext = reshape(com, NumPort, bloq).';%pasamos a una matriz donde cada %supersímbolo esta en una fila ext = [ zeros(bloq, Ginf) ext zeros(bloq, Gsup)]; %añade bandas de guarda esp = [ real(ext(:,1)) ext(:,2:end) imag(ext(:,1)) conj(ext(:,end:-1:2)) ]; %realiza la extension del espectro

La función extesp_ recibe como parámetros de entrada el vector com, que es un vector columna de números complejos, el número de portadoras que intervendrán en la IFFT, y las bandas tanto inferiores como superiores que se reservarán como guarda y por las que no se transmitirá nada. Esta función devuelve la matriz esp. Esta matriz tendrá tantas filas como supersímbolos hubiese en el vector com, y tantas columnas como el doble de NumPort+Ginf+Gsup.

Para ver más claramente cómo se realiza la extensión del espectro pondremos tres ejemplos. Estos tres ejemplos extenderán el mismo vector com, sólo que las bandas de guarda serán diferentes en cada uno de ellos: com = -1.0000 - 3.0000i 1.0000 - 1.0000i -1.0000 + 3.0000i

6 En nuestro caso, dadas las características del canal no será conveniente transmitir ni a muy bajas frecuencias ni a frecuencias altas en torno a 20 KHz.


76

1.0000 + 1.0000i >> ESPbanda=3; >> ESPginf=0; >> ESPgsup=0; >> ESPtam=length(com) ESPtam = 4 >> ESPpad = mod(ESPbanda - mod(ESPtam, ESPbanda), ESPbanda) ESPpad = 2 >> com = [com ; zeros(ESPpad, 1) ] com = -1.0000 - 3.0000i 1.0000 - 1.0000i -1.0000 + 3.0000i 1.0000 + 1.0000i 0 0 >> txESP = extesp_(com, ESPbanda, ESPginf, ESPgsup) txESP = Columns 1 through 5 -1.0000 1.0000 - 1.0000i -1.0000 + 3.0000i -3.0000 1.0000 – 3.0000i 1.0000 0 0 1.0000 0 Column 6 1.0000 + 1.0000i 0

Si ahora añadimos una banda de guarda inferior (ESPginf =1) obtendremos: txESP = Columns 1 through 4 0 -1.0000 - 3.0000i 1.0000 - 1.0000i -1.0000 + 3.0000i 0 1.0000 + 1.0000i 0 0 Columns 5 through 8 0 -1.0000 – 3.0000i 1.0000 + 1.0000i -1.0000 + 3.0000i 0 0 0 1.0000 - 1.0000i

Si en lugar de una banda de guarda inferior reservamos una banda superior (ESPgsup=1) obtenemos: >> ESPbanda=3; >> ESPginf=0; >> ESPgsup=1; >> txESP = extesp_(com,ESPbanda,ESPginf,ESPgsup) txESP = Columns 1 through 4


77

-1.0000 1.0000 - 1.0000i -1.0000 + 3.0000i 0 1.0000 0 0 0 Columns 5 through 8 -3.0000 0 -1.0000 - 3.0000i 1.0000 + 1.0000i 1.0000 0 0 0

Una vez realizada la extensión del espectro, ya podemos realizar la transformada inversa de Fourier para cada supersímbolo. Antes de realizar la IFFT para obtener la señal en tiempo calculamos el número de supersímbolos que hay en cada trama, ya que nos hará falta saberlo para el sincronismo del sistema y esto es lo que realizan las últimas líneas de código que se presentan en este bloque.

Antes de pasar al siguiente bloque, seguimos con el ejemplo de transmisión tomado desde el principio, y ejecutamos este bloque en MATLAB tomando como entrada el vector txCOM obtenido del bloque de modulación QAM. El resultado que se obtiene es: ESPtam = 10 ESPpad = 2 txCOM = -2.6719 - 1.3641i 1.8556 - 2.3573i 0.3415 + 2.9805i 2.2997 + 1.9265i 1.0000 - 1.0000i -3.0000 + 3.0000i 1.0000 - 1.0000i 3.0000 + 1.0000i 3.0000 + 1.0000i -1.0000 - 1.0000i 0 0 txESP = Columns 1 through 5 0 0 -2.6719 - 1.3641i 1.8556 - 2.3573i 0.3415 + 2.9805i 0 0 1.0000 - 1.0000i -3.0000 + 3.0000i 1.0000 - 1.0000i 0 0 3.0000 + 1.0000i -1.0000 - 1.0000i 0 Columns 6 through 10 2.2997 + 1.9265i 0 0 0 0 3.0000 + 1.0000i 0 0 0 0 0 0 0 0 0 Columns 11 through 15 0 2.2997 - 1.9265i 0.3415 - 2.9805i 1.8556 + 2.3573i -2.6719 + 1.3641i 0 3.0000 - 1.0000i 1.0000 + 1.0000i -3.0000 - 3.0000i 1.0000 + 1.0000i 0 0 0 -1.0000 + 1.0000i 3.0000 - 1.0000i Column 16


78

0 0 0

Donde se han utilizado cuatro subportadoras útiles, y se han tomado dos de

guarda inferior y dos de guarda superior. 3.4.2.6 IFFT %%%%%%%%%%%%%%%%%% % IFFT %%%%%%%%%%%%%%%%%% [txTIE] = ifft_(txESP);

Este bloque, como ya se ha comentado, calcula la transformada inversa de

Fourier de la señal de entrada. Esta transformada se lleva a cabo mediante el algoritmo IFFT (Inverse-Fast-Fourier-Transform) y realiza la conversión de la señal representada por sus coeficientes espectrales a una señal de muestras en tiempo. Debemos tener en cuenta que la IFFT se realiza para cada supersímbolo y por lo tanto, depende del número de bandas de que dispongamos.

La función principal de este bloque es ifft_ cuyo código MATLAB se muestra a continuación: %Funcion ifft_.Realiza la IFFT a cada supersímbolo, pasando de %coeficientes espectrales a muestras en tiempo. function [tie] = ifft_(esp) tie = []; for k = 1:size(esp,1), tie = [ tie ; real(ifft(esp(k,:))) ]; end

Esta función va realizando la IFFT a cada supersímbolo, es decir a cada fila del vector de entrada esp y devuelve en el vector tie las distintas muestras a las que da lugar cada supersímbolo, es decir, en cada fila tendremos los valores reales de tiempo que se generan al calcular la transformada inversa de Fourier a cada coeficiente complejo. Las dimensiones de los vectores de entrada y salida coinciden, por tanto.

Para mostrar el funcionamiento de este bloque continuamos con el ejemplo de transmisión, por lo que la función ifft_ tomará como matriz de entrada la obtenida a la salida del bloque anterior de extensión de espectro, txESP. El resultado de este bloque es el siguiente: txTIE = Columns 1 through 8 0.2281 -0.4597 0.1392 0.7600 -0.1588 -0.3289 0.5327 0.0868 0.2500 -0.4472 -0.1768 0.7593 0.2500 -0.5533 -0.4268 -0.2999 0.2500 0.2444 0.0518 -0.2859 -0.5000 -0.3401 0.1250 0.5169 Columns 9 through 16


79

-0.8107 -0.5167 0.1165 0.6986 0.9121 -0.1851 -0.9591 -0.0552 0.2500 1.0507 0.1768 -1.0093 -0.2500 0.4498 -0.0732 0.0499 0.5000 0.1091 -0.3018 -0.4212 -0.2500 -0.0135 0.1250 0.1902

Una vez obtenida la señal en tiempo ya estamos en condiciones de transmitirla

pero antes de hacerlo y para la protección por multitrayecto pasamos esta señal por el siguiente bloque. 3.4.2.7 Inserción del intervalo de guarda % Parametro de configuracion de guarda GUAint = 1/32; %%%%%%%%%%%%%%%%%% % Añade guarda %%%%%%%%%%%%%%%%%% GUAmue = ceil(GUAint*size(txTIE,2)); [txGUA] = guard_(txTIE, GUAmue);

Este bloque como se explicó en teoría, va a añadir un intervalo de muestras de guarda en cada supersímbolo. El intervalo de guarda que se va a añadir tiene la forma de prefijo cíclico, es decir se tomarán las GUAmue muestras finales de cada supersímbolo de la señal de entrada al bloque (la señal temporal obtenida tras la IFFT) y se repetirán al comienzo de cada supersímbolo, por lo que cada supersímbolo ve aumentada su longitud en GUAmue muestras.

El código de la función que realiza este bloque se presenta a continuación: %Funcion guard_. Añade el prefijo cíclico a cada supersímbolo temporal. function [gua] = guard_(tie, IntGuar) gua = []; if length(tie)>0, gua = [ tie( :, (size(tie,2) - IntGuar + 1):size(tie,2) ) tie ]; end

Para comprobar que efectivamente esta función añade el intervalo de guarda con forma de prefijo cíclico ponemos el siguiente ejemplo donde tomamos el vector txTIE obtenido anteriormente como entrada a este bloque y GUAint = 1/32: GUAmue = 1

txGUA = Columns 1 through 8 -0.0552 0.2281 -0.4597 0.1392 0.7600 -0.1588 -0.3289 0.5327 0.0499 0.2500 -0.4472 -0.1768 0.7593 0.2500 -0.5533 -0.4268 0.1902 0.2500 0.2444 0.0518 -0.2859 -0.5000 -0.3401 0.1250 Columns 9 through 16 0.0868 -0.8107 -0.5167 0.1165 0.6986 0.9121 -0.1851 -0.9591 -0.2999 0.2500 1.0507 0.1768 -1.0093 -0.2500 0.4498 -0.0732 0.5169 0.5000 0.1091 -0.3018 -0.4212 -0.2500 -0.0135 0.1250 Column 17


80

-0.0552 0.0499 0.1902

Efectivamente se comprueba que esta función ha añadido la última muestra de

cada supersímbolo al comienzo de estos y que, por lo tanto, el número de columnas de la matriz de salida ha aumentado en una unidad. 3.4.2.8 Conversión Paralelo/Serie %%%%%%%%%%%%%%%%%% % Pasa a muestras %%%%%%%%%%%%%%%%%% [txMUE] = p2s_(txGUA);

La misión de este bloque no es otra que obtener un vector fila de muestras que pueda ser transmitido a través del canal. Para esto simplemente toma la matriz txGUA donde cada fila es un supersímbolo y coloca en el vector de salida txMUE un supersímbolo tras otro. Mostramos a continuación el código de la función que realiza este bloque: %Funcion p2s_. Serializa una matriz que se le pasa como entrada (par). %La salida sera el vector fila serie (ser). function [ser] = p2s_(par) ser = reshape( par.', 1, size(par,1) * size(par,2) );

Esta función hace uso de la función de MATLAB reshape que es de la forma:

reshape(x,m,n)

que devuelve una matriz mxn tomando los elementos por columnas de la matriz x. En este caso los elementos se toman de par y la salida es un vector fila y tantas columnas como elementos tiene la matriz par.

El siguiente ejemplo ilustra el funcionamiento de este bloque de conversión paralelo/serie, en el que se ha tomado como matriz de entrada al bloque txGUA, que era la obtenida tras el bloque de inserción del intervalo de guarda. El resultado que se obtiene es: txMUE = Columns 1 through 8 -0.0552 0.2281 -0.4597 0.1392 0.7600 -0.1588 -0.3289 0.5327 Columns 9 through 16 0.0868 -0.8107 -0.5167 0.1165 0.6986 0.9121 -0.1851 -0.9591 Columns 17 through 24 -0.0552 0.0499 0.2500 -0.4472 -0.1768 0.7593 0.2500 -0.5533 Columns 25 through 32 -0.4268 -0.2999 0.2500 1.0507 0.1768 -1.0093 -0.2500 0.4498


81

Columns 33 through 40 -0.0732 0.0499 0.1902 0.2500 0.2444 0.0518 -0.2859 -0.5000 Columns 41 through 48 -0.3401 0.1250 0.5169 0.5000 0.1091 -0.3018 -0.4212 -0.2500 Columns 49 through 51 -0.0135 0.1250 0.1902

3.4.2.9 Inserción de sincronismo % Parametros de configuracion de sincronismo SINCpre = 5; SINCchi = 10; SINCf0 = 0; SINCf1 = .5; SINCpos = 5; SINCk = 1; sincro = [ zeros(1,SINCpre) SINCk * chirp(0:(SINCchi-1), SINCf0, SINCchi, SINCf1) zeros(1,SINCpos) ]; %%%%%%%%%%%%%%%%%% % Añade señal sincronismo %%%%%%%%%%%%%%%%%% txMUE = [ sincro txMUE]; txMUE = txMUE/max(abs(txMUE));

Dado que se dedicará el próximo capítulo a explicar el sincronismo de los sistemas OFDM no vamos a detallar el funcionamiento de este bloque. Nos nos limitaremos a mencionar, que una vez obtenida la señal en tiempo debemos introducirle al comienzo de la misma una señal de sincronismo conocida para que el receptor sea capaz de detectar el principio de cada trama y pueda sincronizarse a la misma. Esto le permitirá llevar a cabo de forma correcta el proceso de demodulación.

El vector que se obtiene al añadirse la señal de sincronismo en cada trama es:

txMUE = Columns 1 through 8 0 0 0 0 0 1.0000 0.9877 0.8090 Columns 9 through 16 0.1564 -0.8090 -0.7071 0.8090 0.1564 -0.8090 0.9877 0 Columns 17 through 24 0 0 0 0 -0.0525 0.2171 -0.4375 0.1325 Columns 25 through 32 0.7233 -0.1511 -0.3130 0.5070 0.0826 -0.7716 -0.4917 0.1109 Columns 33 through 40 0.6649 0.8681 -0.1761 -0.9128 -0.0525 0.0475 0.2379 -0.4256 Columns 41 through 48 -0.1682 0.7226 0.2379 -0.5266 -0.4062 -0.2854 0.2379 1.0000 Columns 49 through 56


82

0.1682 -0.9605 -0.2379 0.4281 -0.0697 0.0475 0.1810 0.2379 Columns 57 through 64 0.2326 0.0493 -0.2721 -0.4759 -0.3237 0.1190 0.4919 0.4759 Columns 65 through 71 0.1039 -0.2872 -0.4009 -0.2379 -0.0128 0.1190 0.1810

En color rojo se ha resaltado la parte de la trama que constituye la señal de

sincronismo. Hay que decir, que esta señal de sincronismo será modificada para el programa final, donde los parámetros serán los que siguen: SINCpre = 200; SINCchi = 100; SINCf0 = 0; SINCf1 = .5; SINCpos = 200; sincro = [ zeros(1,SINCpre) chirp(0:(SINCchi-1), SINCf0, SINCchi, SINCf1) zeros(1,SINCpos) ]; sincro = sincro/max(abs(sincro));

Se normaliza tanto la señal de sincronismo como la señal de muestras para que

ocupen el rango dinámico del transmisor.


83

3.4.3 Receptor

El siguiente diagrama de bloques muestra las principales funciones de MATLAB que conforman cada bloque del receptor así como los vectores o matrices entrada y salida a estos bloques. Esto nos servirá para explicar más claramente el funcionamiento conjunto del receptor COFDM programado.

RECEPTOR MATLAB

Conversor

Serie/

Paralelo

Elimina–

ción del

Intervalo

de Guarda

FFT

Detecta Señal de

Sincronismo

Reducción

del

Espectro

Igualador

de canal

Demodulador

QAM

Extrae Supersímbolo

de Entrenamiento

Conversor

Paralelo/

Serie

Decodificador

Convolu-

cional

Decodificador

Reed-

Solomon

rxDatos

rxMUE rxTrama

rxGUA rxTIE

rxESP rxCOM

rxCOM

rxPAR

rxSS

rxCOM

rxCC rxRS

qguard_ ser2par

fft_ redesp_

detec p2s vitdec depuncture_unquant

rsdec


84

A continuación se presenta el código MATLAB del receptor completo: function [totaldatosRX,rxSinProt,EspectroRX,ConstelacionRX] = receptor(totaltramas,sincro,SINCss,GUAmue,ESPginf,ESPbanda,ESPgsup,ESPtam, QAMm,QAMtam,CCtrellis,model,CCPtam,CCtam,RSn,RSk,RSm,BloqueRSTrama,txSS,RStam,AUDIOfrec) %%%%%%%%%%%%%%%%%% % Deteccion de sincronismos %%%%%%%%%%%%%%%%%% cor = xcorr(totaltramas, sincro); cor = cor((length(totaltramas)-length(sincro)+1):end); SINCumbral=0.6*max(cor); %figure(6) x=1:length(cor); line=ones(1,length(cor))*SINCumbral; %plot(x,cor,x,line,'r'),title('Deteccion de sincronismos'),xlabel('Indice %temporal n'),ylabel('Amplitud'); %legend('Correlacion con señal de sincronismo','Umbral de deteccion'); SINCtamtram = SINCss * ( GUAmue + 2 * ( ESPginf + ESPbanda + ESPgsup ) ); indice = 1; detec = []; while 1, superan = find(cor(indice:end)>SINCumbral) + indice; if length(superan) == 0 break end detec = [ detec superan(1) ]; indice = superan(1) + SINCtamtram; end rxSinProt = []; %%%%%%%%%%%%%%%%%% % Bucle del receptor %%%%%%%%%%%%%%%%%% totaldatosRX = []; for inicio = detec rxMUE = totaltramas(inicio:(inicio+SINCtamtram-1)); %figure(3) esp=(fft(rxMUE)); f = 0:AUDIOfrec/(length(esp)/2-1)/2:AUDIOfrec/2; %subplot(2,1,2),plot(f, 20*log(abs(esp(1:floor(length(esp)/2)))),'r'); %title('Espectro COFDMrecibido'), %xlabel('Frecuencia(Hz)'),ylabel('Magnitud(dB)'); EspectroRX = 20*log(abs(esp(1:floor(length(esp)/2)))); %%%%%%%%%%%%%%%%%% % Pasa de muestras a supersimbolos %%%%%%%%%%%%%%%%%% rxGUA = ser2par( rxMUE, GUAmue + 2 * ( ESPginf + ESPbanda + ESPgsup ) );


85

%%%%%%%%%%%%%%%%%% % Quita guarda %%%%%%%%%%%%%%%%%% rxTIE = qguard_(rxGUA, GUAmue); %%%%%%%%%%%%%%%%%% % FFT %%%%%%%%%%%%%%%%%% rxESP = fft_(rxTIE); %%%%%%%%%%%%%%%%%% % Reduccion espectro %%%%%%%%%%%%%%%%%% rxCOM = redesp_(rxESP, ESPginf, ESPgsup); % Quita padding rxCOM = rxCOM(1:ESPtam); %%%%%%%%%%%%%%%%%% % Extrae SuperSimbolo Entrenamiento %%%%%%%%%%%%%%%%%% rxSS = rxCOM(1:ESPbanda); rxCOM = rxCOM(ESPbanda+1:end); %figure(2) %subplot(1,3,2),plot(rxCOM,'.r'); %title('Constelacion recibida'),xlabel('Eje de fase'),ylabel('Eje de %cuadratura'); %axis square; %axis equal; %grid on; % Aplica el igualador igualador = txSS./rxSS; %figure(5) %subplot(2,1,1),plot(abs(igualador)); %subplot(2,1,2),plot(phase(igualador)); for i = 1:size(rxCOM) j = mod(i-1, size(igualador,1))+1; rxCOM(i) = rxCOM(i) * igualador(j); end %figure(2) %subplot(1,3,3),plot(rxCOM,'.g'); %title('Constelacion recibida'),xlabel('Eje de fase'),ylabel('Eje de %cuadratura'); %axis square; %axis equal; %grid on; ConstelacionRX = rxCOM; %%%%%%%%%%%%%%%%%% % Decodificacion QAM %%%%%%%%%%%%%%%%%% rxPAR = detec_(rxCOM, QAMm); rxCC = p2s_(rxPAR); % Quita padding rxCC = rxCC(1:QAMtam); rxSinProt = [rxSinProt rxCC];


86

%%%%%%%%%%%%%%%%%% % Decodificacion Convolucional %%%%%%%%%%%%%%%%%% %rxRS = vitdec(rxCC, CCtrellis, 1, 'trunc', 'hard'); rxCC = depuncture_unquant(rxCC,model,CCPtam); rxRS = vitdec(rxCC, CCtrellis, 1, 'trunc', 'unquant'); % Quita padding rxRS = rxRS(1:CCtam); %%%%%%%%%%%%%%%%%% % Decodificacion RS %%%%%%%%%%%%%%%%%% % Pasa de 0s y 1s rxRS = reshape(rxRS, BloqueRSTrama * RSn, RSm); rxRS = bi2de(rxRS, 'left-msb')'; rxDatos = []; j = 1; for i=1:BloqueRSTrama bloqueRS = rxRS(j:j+RSn-1); bloqueGalois = gf(bloqueRS, RSm); bloqueDatos = rsdec(bloqueGalois, RSn, RSk); j = j + RSn; rxDatos = [ rxDatos double(bloqueDatos.x) ]; end %%%Quita el Padding rxDatos = rxDatos(1:RStam); %%%%%%%%%%%%%%%%%% % Fin bucle del receptor %%%%%%%%%%%%%%%%%% totaldatosRX = [ totaldatosRX rxDatos ]; end

Se explican ahora, por bloques, las distintas funciones del receptor. 3.4.3.1 Detección de sincronismo %%%%%%%%%%%%%%%%%% % Deteccion de señal de sincronismo %%%%%%%%%%%%%%%%%% cor = xcorr(totaltramas, sincro); cor = cor((length(totaltramas)-length(sincro)+1):end); SINCtamtram = SINCss * ( GUAmue + 2 * ( ESPginf + ESPbanda + ESPgsup ) ); indice = 1; detec = []; while 1, superan = find(cor(indice:end)>SINCumbral) + indice; if length(superan) == 0 break end


87

detec = [ detec superan(1) ]; indice = superan(1) + SINCtamtram; end

Este es el primer bloque del receptor y se encargará de detectar la señal de sincronismo de cada trama para poder demodular los datos correctamente. Como ya se ha comentado, todo lo referente al sincronismo se va a explicar en el capítulo 4 por lo que no detallaremos aquí cómo funciona el código de detección de sincronismo.

A continuación se presenta el código que extrae los datos de la trama recibida, una vez nos hemos sincronizado a la misma. >> inicio=detec; >> rxMUE = tolastramas(inicio:(inicio+SINCtamtram-1)); rxMUE = Columns 1 through 8 0.0281 0.0957 -0.4390 0.3249 0.5865 -0.2889 -0.1563 0.5089 Columns 9 through 16 -0.1379 -0.7766 -0.3872 0.2153 0.7273 0.7487 -0.4551 -0.7545 Columns 17 through 24 -0.0248 0.0912 0.1321 -0.4852 0.0298 0.7047 0.0341 -0.5401 Columns 25 through 32 -0.3826 -0.2451 0.4164 0.9333 -0.1247 -0.9278 -0.0298 0.3285 Columns 33 through 40 -0.0933 0.0815 0.1783 0.2359 0.1984 -0.0202 -0.3352 -0.4790 Columns 41 through 48 -0.2567 0.1958 0.5040 0.4093 0.0078 -0.3345 -0.3948 -0.1960 Columns 49 through 51 0 0.1382 0.1379 3.4.3.2 Conversor Serie/Paralelo %%%%%%%%%%%%%%%%%% % Pasa de muestras a supersimbolos %%%%%%%%%%%%%%%%%% [rxGUA] = ser2par( rxMUE, GUAmue + 2 * ( ESPginf + ESPbanda + ESPgsup ) );

El receptor, una vez que se ha sincronizado a la trama rxMUE, debe pasar este vector de muestras a una matriz donde cada fila contenga un supersímbolo. Se trata en definitiva de una conversión serie/paralelo pero no se ejecuta de igual forma que en el transmisor porque el vector de entrada al bloque no es binario. Por eso, este bloque ejecuta una función diferente llamada ser2par. Esta función recibe como parámetros de entrada el vector de muestras rxMUE y el tamaño de los supersímbolos (intervalo de guarda más dos veces el número de bandas con las que contamos para la transmisión).

El código de la función ser2par se muestra a continuación:


88

%Funcion que transforma un vector de entrada ser, a una matriz de tam columnas. function [par] = ser2par(ser, tam) bloq = floor( length(ser) / tam); par = []; if bloq > 0, par = reshape( ser(1:(bloq * tam)), tam, bloq).'; end

A diferencia de la función s2p_ del transmisor esta función no ejecuta la función

de MATLAB bi2de ya que el vector que recibe como entrada ya está en decimal. Se puede ver que este código lo que hace es calcular el número de supersímbolos que contiene el vector serie y forma una matriz de tamaño bloqxtam (esto es así ya que se traspone (operador .’) la matriz obtenida por la función reshape de MATLAB).

A continuación se muestra un ejemplo de la ejecución de este bloque donde tomamos como vector de entrada el vector de salida del transmisor txMUE y los parámetros se conservan los mismos del transmisor: rxGUA = Columns 1 through 8 0.0281 0.0957 -0.4390 0.3249 0.5865 -0.2889 -0.1563 0.5089 0.0912 0.1321 -0.4852 0.0298 0.7047 0.0341 -0.5401 -0.3826 0.1783 0.2359 0.1984 -0.0202 -0.3352 -0.4790 -0.2567 0.1958 Columns 9 through 16 -0.1379 -0.7766 -0.3872 0.2153 0.7273 0.7487 -0.4551 -0.7545 -0.2451 0.4164 0.9333 -0.1247 -0.9278 -0.0298 0.3285 -0.0933 0.5040 0.4093 0.0078 -0.3345 -0.3948 -0.1960 0 0.1382 Column 17 -0.0248 0.0815 0.1379

3.4.3.3 Eliminación del intervalo de guarda %%%%%%%%%%%%%%%%%% % Quita guarda %%%%%%%%%%%%%%%%%% [rxTIE] = qguard_(rxGUA, GUAmue);

Este bloque tiene como función eliminar de cada supersímbolo o fila de la matriz de entrada rxGUA el prefijo cíclico que se añadió en el transmisor para aumentar la protección del sistema frente a desvanecimientos por multitrayecto. A la salida del bloque obtendremos la matriz rxTIE donde cada fila es un supersímbolo de muestras temporales, ya sin intervalo de guarda y preparado para el siguiente bloque, el bloque FFT.

La función que ejecuta este bloque es qguard_ y el código de la misma se presenta a continuación:


89

%Funcion qguard_. Extrae el intervalo de guarda que se inserto en transmisor. function [tie] = qguard_(par, IntGuar) tie = par(:, (1:(size(par,2)-IntGuar)) + IntGuar);

Esta función recibe como parámetros de entrada la matriz de salida del bloque serie/paralelo (par) y el número de muestras del intervalo de guarda (IntGuar) y devuelve la matriz tie que tendrá el mismo número de filas o supersímbolos pero con IntGuar menos columnas, al haberse eliminado el prefijo cíclico.

Un ejemplo del funcionamiento de este bloque es el siguiente, donde el intervalo de guarda es de 1 muestra (el mismo que en el transmisor) y que el vector de entrada al bloque es el que se obtuvo a la salida del conversor serie/paralelo: rxTIE = Columns 1 through 8 0.0957 -0.4390 0.3249 0.5865 -0.2889 -0.1563 0.5089 -0.1379 0.1321 -0.4852 0.0298 0.7047 0.0341 -0.5401 -0.3826 -0.2451 0.2359 0.1984 -0.0202 -0.3352 -0.4790 -0.2567 0.1958 0.5040 Columns 9 through 16 -0.7766 -0.3872 0.2153 0.7273 0.7487 -0.4551 -0.7545 -0.0248 0.4164 0.9333 -0.1247 -0.9278 -0.0298 0.3285 -0.0933 0.0815 0.4093 0.0078 -0.3345 -0.3948 -0.1960 0 0.1382 0.1379

Se puede comprobar que la matriz rxTIE ya no contiene la primera columna de

rxGUA puesto que se le ha indicado que el intervalo de guarda de cada supersímbolo es una muestra. 3.4.3.4 FFT %%%%%%%%%%%%%%%%%% % FFT %%%%%%%%%%%%%%%%%% [rxESP] = fft_(rxTIE);

Este bloque va a realizar la transformada de Fourier mediante el algoritmo FFT a la señal de tiempo (matriz rxTIE) que recibe como entrada. A la salida del bloque obtendremos los coeficientes espectrales o números complejos correspondientes (matriz rxESP).

La función principal de este bloque es fft_ . Esta función realiza la FFT de cada supersímbolo (la fft por filas de la matriz de entrada), es decir, por cada fila obtiene una serie de números complejos que se corresponden con el espectro en frecuencia de cada supersímbolo. El código de esta función se presenta a continuación: %Funcion fft_. Realiza la transformada de Fourier a la señal de tiempo que %recibe como entrada (tie) y devuelve la matriz (esp) con los coeficientes de %espectrales correspondientes. function [esp] = fft_(tie) esp = []; for k = 1:size(tie,1), esp = [ esp ; fft(tie(k,:)) ];


90

end

Un ejemplo del funcionamiento de este bloque es el siguiente, donde la señal en tiempo que se le pasa como entrada es la obtenida a la salida del bloque de eliminación del intervalo de guarda rxTIE:

rxESP = Columns 1 through 5 -0.2131 -0.0553 - 0.0161i -2.3367 - 1.6780i 2.1178 - 1.7956i -0.5157 + 2.5887i -0.1681 -0.0223 - 0.0065i 1.0527 - 0.8054i -3.3268 + 2.0637i 1.1237 - 0.6231i -0.1891 -0.0331 - 0.0109i 2.6177 + 1.3314i -0.7143 - 1.1357i -0.0090 - 0.0377i Columns 6 through 10 1.2586 + 2.2212i 0.0551 - 0.1064i 0.1681 - 0.1498i 0.3600 0.1681 + 0.1498i 2.1304 + 1.7454i 0.0357 - 0.0434i 0.0812 - 0.0694i 0.1322 0.0812 + 0.0694i 0.0045 - 0.0438i 0.0227 - 0.0458i 0.0493 - 0.0511i 0.0882 0.0493 + 0.0511i Columns 11 through 15 0.0551 + 0.1064i 1.2586 - 2.2212i -0.5157 - 2.5887i 2.1178 + 1.7956i -2.3367 + 1.6780i 0.0357 + 0.0434i 2.1304 - 1.7454i 1.1237 + 0.6231i -3.3268 - 2.0637i 1.0527 + 0.8054i 0.0227 + 0.0458i 0.0045 + 0.0438i -0.0090 + 0.0377i -0.7143 + 1.1357i 2.6177 - 1.3314i

Column 16 -0.0553 + 0.0161i -0.0223 + 0.0065i -0.0331 + 0.0109i

3.4.3.5 Reducción del espectro %%%%%%%%%%%%%%%%%% % Reduccion espectro %%%%%%%%%%%%%%%%%% [rxCOM] = redesp_(rxESP, ESPginf, ESPgsup); % Quita padding rxCOM = rxCOM(1:ESPtam);

Recordemos que en el transmisor, antes del bloque IFFT, debíamos realizar una

extensión del espectro para añadir la parte simétrica conjugada de este. Esto se hacía con la intención de obtener, una vez realizada la IFFT, una señal real en tiempo. En el receptor necesitaremos por tanto, un bloque que elimine esta parte simétrica conjugada del espectro que se añadió, y esta es la función de este bloque, reducción de espectro.

La función principal de este bloque es redesp_ cuyo código en MATLAB se muestra a continuación: %Funcion redesp_.Elimina la parte simetrica conjugada del espectro que se le %pasa como entrada, teniendo en cuenta las bandas de guarda que se han %utilizado en la comunicacion function [com] = redesp_(esp, Ginf, Gsup) com = []; for k = 1:size(esp,1) %Para cada fila de la matriz esp

red = zeros(1, size(esp,2) / 2); %formamos un vector con la mitad de columnas


91

red(1) = esp(k,1) + esp(k,size(esp,2)/2+1)* i; %el primer elemento del vector de espectro reducido se forma tomando como %parte real el primer elemento de la fila y como parte imaginaria el elemento %mitad más uno de la fila red(2:(size(esp,2)/2)) = esp(k, 2:(size(esp,2) / 2)); %El resto de elementos de del vector red se forman tomando desde el segun- %do elemento de la fila hasta el elemento mitad red = red((1 + Ginf):(size(esp,2) / 2 - Gsup)); % Quita las bandas de guarda com = [ com ; red.' ]; %com sera un vector columna. Una vez calculado el espectro reducido para %cada %supersímbolo (fila) se va añadiendo al vector de salida pero traspuesto end

Esta función toma como argumentos de entrada, el espectro ampliado de la señal, el número de bandas de guarda inferiores y el número de bandas de guarda superiores. Devuelve el vector com, formado por los coeficientes espectrales de los supersímbolos.

A continuación se muestra el resultado de la ejecución de este bloque en MATLAB, para ello se han tomado como parámetros de entrada, la matriz rxESP que se obtuvo como resultado del bloque anterior, y ESPginf y ESPgsup con valor dos, es decir en la comunicación se han tomado dos bandas de guarda inferior y dos de guarda superior. rxCOM = -2.3367 - 1.6780i 2.1178 - 1.7956i -0.5157 + 2.5887i 1.2586 + 2.2212i 1.0527 - 0.8054i -3.3268 + 2.0637i 1.1237 - 0.6231i 2.1304 + 1.7454i 2.6177 + 1.3314i -0.7143 - 1.1357i -0.0090 - 0.0377i 0.0045 - 0.0438i

Se puede comprobar que en este caso, los números complejos que forman el

vector ya no son enteros, al haberse visto alterados por el canal de transmisión. 3.4.3.6 Extracción del supersímbolo de entrenamiento %%%%%%%%%%%%%%%%%% % Extrae SuperSimbolo entrenamiento %%%%%%%%%%%%%%%%%% rxSS = rxCOM(1:ESPbanda); rxCOM = rxCOM(ESPbanda+1:end);

Este bloque tiene como función principal extraer el supersímbolo de entrenamiento que se añadió en el transmisor al principio de la trama, para poder realizar ahora en el receptor la igualación del canal. Este supersímbolo es un vector columna de valores pseudoaleatorios conocido por ambos extremos de la comunicación.


92

En este punto del receptor lo extraemos para ver los cambios de amplitud y fase que ha sufrido y así poder corregir el vector de coeficientes complejos recibido, para que la detección posterior sea correcta.

Este bloque guarda por un lado el supersímbolo de entrenamiento en rxSS, y por otro el vector de complejos rxCOM.

Vemos un ejemplo del funcionamiento de este bloque, tomando como rxCOM el que se ha obtenido a la salida del bloque anterior: rxSS = -2.3367 - 1.6780i 2.1178 - 1.7956i -0.5157 + 2.5887i 1.2586 + 2.2212i rxCOM = 1.0527 - 0.8054i -3.3268 + 2.0637i 1.1237 - 0.6231i 2.1304 + 1.7454i 2.6177 + 1.3314i -0.7143 - 1.1357i

A continuación ya podemos pasar al bloque igualador de canal con la señal de

sincronismo extraída rxSS. 3.4.3.7 Igualador de canal %%%%%%%%%%%%%%%%% % Calcula y aplica el igualador %%%%%%%%%%%%%%%%% %calcula el igualador igualador = txSS./rxSS; %aplica el igualador a cada supersímbolo for i = 1:size(rxCOM) j = mod(i-1, size(igualador,1))+1; rxCOM(i) = rxCOM(i) * igualador(j); end

La función de este bloque es no es otra que calcular la desviación que sufren los símbolos al atravesar el canal. Para esto se transmite un supersímbolo conocido al principio de cada trama, y en el receptor se calcula el igualador del canal dividiendo el supersímbolo de entrenamiento transmitido entre el recibido.

Como muestra el código MATLAB de este bloque, una vez conocida la desviación (igualador), no tenemos más que multiplicar cada símbolo (de cada supersímbolo) por su desviación correspondiente. Con esto nos aseguramos que el vector de salida del bloque sea apropiado antes de realizarse la detección.

A continuación se muestra el resultado de ejecutar este bloque en MATLAB siguiendo con el ejemplo de comunicación considerado por lo que rxSS se ha obtenido del bloque anterior y txSS es un parámetro de entrada del receptor:


93

igualador = 1.0310 - 0.1566i 1.0588 - 0.2154i 1.0821 - 0.3475i 1.1006 - 0.4117i rxCOM = 0.9592 - 0.9952i -3.0780 + 2.9015i 0.9994 - 1.0647i 3.0632 + 1.0439i 2.9073 + 0.9629i -1.0009 - 1.0487i

Vemos que el nuevo rxCOM contiene valores complejos más próximos a los de la

constelación QAM de 4 bits/símbolo. Estos valores no son exactamente iguales a los puntos de la constelación (valores de la tabla QAM calculada) debido al ruido del canal, pero al no ser este muy importante, son valores muy próximos a los exactos por lo que la detección se podrá llevar a cabo fácilmente. 3.4.3.8 Demodulador QAM %%%%%%%%%%%%%%%%%% % Demodulacion QAM %%%%%%%%%%%%%%%%%% [rxPAR] = detec_(rxCOM, QAMm); [rxCC] = p2s_(rxPAR); % Quita padding rxCC = rxCC(1:QAMtam);

Este bloque recibe como entrada el vector rxCOM obtenido tras aplicarse la igualación de canal y el parámetro QAMm, que es el número de bits por símbolo que se usan para la modulación y demodulación.

En primer lugar, realiza una detección de los símbolos que recibe como entrada

obteniéndose una matriz de valores binarios que representan los puntos de la constelación correspondientes.

A continuación realiza una conversión de esta matriz a un vector fila y

finalmente elimina el relleno que pudiese contener este vector. A la salida del bloque obtenemos el vector binario fila rxCC preparado para la decodificación convolucional.

El código MATLAB de la función que realiza la detección se muestra a continuación:

%Funcion detec_. Realiza la deteccion de los simbolos que se enviaron. %Recibe como parametros de entrada el vector con los coeficientes complejos y %el numero de bits por cada simbolo de la constelacion y devuelve un matriz %binaria donde cada fila representa el valor del símbolo enviado function [par] = detec_(com, BitSimb) iBits = floor(BitSimb/2); %bits que se tomaron para el eje de fase qBits = ceil(BitSimb/2); %bits que se tomaron para el eje de cuadratura par = [];


94

ifron = (0:2îBits - 2) * 2 - (2îBits - 2); %umbrales de decision en i qFron = (0:2^qBits - 2) * 2 - (2^qBits - 2); %umbrales de decision en q for k = 1:size(com,1), %para cada fila de com o cada simbolo iLin = quantiz(real(com(k)),ifron); %region en que se encuentra segun i qLin = quantiz(imag(com(k)),qFron); %region en que se encuentra segun q %pasa de la posicion (lin) al valor gray en binario

i = de2bi(lin2gray_(iLin),'left-msb'); q = de2bi(lin2gray_(qLin),'left-msb'); par = [ par ; zeros(1,iBits-length(i)) i zeros(1,qBits-length(q)) q ]; %se rellena con ceros hasta completar el numero de bits de cada eje end Esta función detecta los puntos de la constelación que se transmitieron. Para ello, tiene en cuenta, en primer lugar, el número de bits que se asignaron para la codificación de cada eje y calcula los valores de los umbrales o fronteras de las regiones de decisión para cada componente (fase y cuadratura). A continuación, para cada fila de la matriz o símbolo, calcula la región en la que se encuentra dicho símbolo haciendo uso de la función de MATLAB quantiz . Esta función es de la forma:

indx=quantiz(sig,partition) y produce un índice de cuantización indx de la señal de entrada sig basándose en los puntos de decisión de partition. Cada elemento de indx es uno de los N enteros en el rango [0:N-1]. partition es un vector de tamaño N-1 estrictamente ordenado de forma ascendente que especifica los límites o umbrales. Finalmente, una vez conocida la posición del punto de la constelación, se pasa a su codificación gray en binario, rellenándose el valor con ceros, en caso de que sea necesario antes de introducirlo como fila de la matriz par. Esta matriz contiene los valores de cada símbolo. Se muestra a continuación el código MATLAB de la función lin2gray_. %Funcion lin2gray_. Pasa un numero en decimal a su codificacion gray. function gray = lin2gray_(lin) bin = de2bi(lin,'left-msb'); %pasa a binario invierte = 0; new_bin = []; for k = 1:length(bin), if invierte new_bin(k) = ~ bin(k); %realiza la not del bit correspondiente else new_bin(k) = bin(k); end if new_bin(k) invierte = ~ invierte; %invierte pasa de 0 a 1 o viceversa end end gray = bi2de(bin,'left-msb'); %pasa a numero


95

Esta función es la inversa de la función comentada en el transmisor gray2lin_, es decir, esta función realiza la codificación gray de un número decimal. La función, en primer lugar, pasa el número a codificar a binario. Al igual que ocurría en lin2gray_, invierte será la bandera que indique si hay que invertir el bit o se queda tal cual. El vector new_bin almacenará el vector

El código MATLAB de la función que realiza la conversión paralelo serie se muestra a continuación: %Funcion p2s_.Funcion que serializa una matriz que se le pasa como entrada %(par). La salida sera el vector fila (ser). function [ser] = p2s_(par) %Trasponemos la matriz par, ya que reshape toma los elementos por columnas %Forma un vector fila con todos los elementos de la matriz par ser = reshape( par.', 1, size(par,1) * size(par,2) ); Continuando con el ejemplo que se está desarrollando, el vector de entrada a este bloque será el obtenido a la salida del bloque igualador de canal y se le pasará como parámetro de entrada a la función detec_ .Esta función recibe también como argumento de entrada el parámetro general QAMm, es decir el número de bits por símbolo que usa la modulación QAM: rxPAR = 1 1 0 1 0 0 1 0 1 1 0 1 1 0 1 1 1 0 1 1 0 1 0 1 rxCC = Columns 1 through 14 1 1 0 1 0 0 1 0 1 1 0 1 1 0 Columns 15 through 24 1 1 1 0 1 1 0 1 0 1

3.4.3.9 Decodificador Convolucional %%%%%%%%%%%%%%%%%% % Decodificacion Convolucional %%%%%%%%%%%%%%%%%% rxCC = depuncture_unquant(rxCC,model,CCPtam); rxRS = vitdec(rxCC, CCtrellis, 1, 'trunc', 'unquant'); % Quita padding rxRS = rxRS(1:CCtam);

Este bloque realiza la decodificación convolucional del vector de entrada rxCC utilizando un decodificador de Viterbi y devuelve en rxRS el vector decodificado. Antes de realizar la decodificación se debe realizar la operación inversa al perforado del transmisor ya que el decodificador Viterbi supone una tasa 1/2. Este bloque toma


96

además el parámetro CCtrellis, es decir, la estructura trellis que utiliza también el transmisor a la hora de la codificación convolucional.

La primera operación que realiza este bloque es, por tanto, deshacer el perforado

del código. La función que la lleva a cabo es la siguiente: %Función depunture_unquant. Realiza el rellenado del vector rxCC para obtener %un vector de tasa 1/2. function rxCOD = depuncture_unquant(rxCC,model,tam) j = 1; k = 1; rxCOD = [zeros(1,tam)]; for i=1:length(rxCOD) if model(k)==1 if(rxCC(j)), rxCOD(i)=-1; else rxCOD(i)=+1; end j=j+1; end if k==length(model) k=1; else k=k+1; end end

Esta función recibe como parámetros de entrada el vector rxCC, el modelo

correspondiente a la tasa de codificación empleada y el tamaño del vector txCOD, ya que será este tamaño el que debe tener el vector de salida, antes de realizarse la decodificación Viterbi. El vector rxCOD que se obtiene a la salida contendrá 1’s en las posiciones donde rxCC tenía 0’s y -1’s en las posiciones donde tenía un 1 pero hay que tener en cuenta el modelo e intercalar ciertas posiciones con relleno. Este relleno se hará con ceros.

Veamos con un ejemplo el funcionamiento de esta función:

>> rxCC rxCC = 1 1 1 0 1 0 0 0 0 0 1 1 >> model model = 1 1 0 1 1 0 >> tam = length(txCOD) tam = 18 >> rxCOD = depuncture_unquant(rxCC,model,tam) rxCOD = Columns 1 through 12 -1 -1 0 -1 1 0 -1 1 0 1 1 0 Columns 13 through 18 1 1 0 -1 -1 0

El método usado para deshacer el perforado podría ser distinto, ya que cada estándar define el más conveniente en cada caso. Se ha elegido este porque es el


97

apropiado en la decodificación Viterbi tipo ‘unquant’ que será la que se use y más adelante se explicará las ventajas que tiene esta elección.

La función de MATLAB que se encarga de la decodificación convolucional es vitdec. Esta función tiene la forma:

decoded = vitdec(code,trellis,tblen,opmode,dectype)

Esta función decodifica el vector code usando el algoritmo de Viterbi. La

estructura de MATLAB trellis especifica el codificador convolucional que produjo code. tblen es un escalar entero positivo que indica la profundidad de traceback de la estructura. La cadena opmode indica el modo de operación del decodificador y sus suposiciones sobre la operación del codificador correspondiente. Las opciones se muestran a continuación:

‘trunc’: supone que el codificador ha empezado en el estado todo-ceros. El decodificador vuelve hacia atrás desde el estado con la mejor métrica.

‘term’: supone que el codificador ha empezado y terminado en el estado todo-ceros. El decodificador vuelve hacia atrás desde el estado todo-ceros.

‘cont’: supone que el codificador ha empezado en el estado todo-ceros. El decodificador vuelve hacia atrás desde el estado con la mejor métrica. Hay un retraso igual a tblen símbolos antes de que el primer símbolo decodificado aparezca a la salida.

La cadena dectype indica el tipo de decision que toma el decodificador, y tiene influencia en el tipo de datos que el decodificador espera en code (palabra codificada). Las opciones de estos parámetros son:

‘unquant’: code contiene valores de entrada reales, donde 1 representa un cero lógico y –1 representa el 1 lógico.

‘hard’: code contiene valores de entrada binarios. ‘soft’: para una decodificación por decisión suave es necesario también el

parámetro nsdec. code está formado por enteros entre 0 y 2^nsdec-1, donde 0 representa el 0 de mayor probabilidad y 2^nsdec-1 representa el 1 de mayor probabilidad.

En el decodificador que se ha implementado se ha elegido un modo de operación

‘trunc’ (que tiene menos restricciones), una tblen de 1 y una decodificación con decisión ‘unquant’. La decodificación de tipo unquant es básicamente una decodificación dura ya que decide los valores 1 y -1 como 0 y 1 respectivamente, solo que cuando aparece un 0 no decide con total probabilidad su valor.

No se ha elegido la decodificación tipo ‘soft’ que sería la más apropiada en

sistemas OFDM porque requeriría una estimación de la potencia del ruido en cada banda y usándose el tipo ‘unquant’ se obtiene una solución correcta también, en este caso.

La última línea de código de este bloque se limita a eliminar el relleno antes de enviar el vector al decodificador Reed-Solomon. Para esto utiliza el parámetro de entrada al receptor, CCtam.


98

A continuación se muestra el resultado que da MATLAB al ejecutar este bloque. Los parámetros se han tomado siguiendo el ejemplo que se está desarrollando, es decir, el vector rxCC será el que se ha obtenido en el ejemplo del bloque anterior: rxCC = Columns 1 through 14 1 1 0 1 0 0 1 0 1 1 0 1 1 0 Columns 15 through 24 1 1 1 0 1 1 0 1 0 1

Tras deshacer el perforado: rxCC = Columns 1 through 14 -1 -1 0 1 0 -1 0 1 1 0 -1 0 1 0 Columns 15 through 28 -1 -1 0 1 0 -1 0 -1 1 0 -1 0 -1 0 Columns 29 through 42 -1 1 0 -1 0 -1 0 1 -1 0 1 0 -1 0

Tras la decodificación de Viterbi: rxRS = Columns 1 through 14 1 0 0 1 1 1 0 1 0 0 0 1 0 1 Columns 15 through 21 1 0 0 0 1 0 1

3.4.3.10 Decodificador Reed-Solomon %%%%%%%%%%%%%%%%%% % Decodificacion RS %%%%%%%%%%%%%%%%%% % Pasa de 0s y 1s rxRS = reshape(rxRS, BloqueRSTrama * RSn, RSm); rxRS = bi2de(rxRS, 'left-msb')'; rxDatos = []; j = 1; for i=1:BloqueRSTrama bloqueRS = rxRS(j:j+RSn-1); bloqueGalois = gf(bloqueRS, RSm); bloqueDatos = rsdec(bloqueGalois, RSn, RSk); j = j + RSn; rxDatos = [ rxDatos double(bloqueDatos.x) ]; end


99

Este bloque es el último del receptor y lleva a cabo la decodificación Reed-Solomon del vector de entrada rxRS. A la salida de este bloque obtendremos, por tanto, el vector de datos recibidos.

La función que realiza la decodificación Reed-Solomon de cada bloque de la trama recibido es rsdec y toma la forma:

decoded = rsdec(code,n,k) rsdec intenta decodificar la señal recibida en code usando un proceso de decodificación Reed-Solomon [n,k] con el generador polynomial. code es una estructura Galois de símbolos de m bits. Cada fila de n elementos de code representa una palabra de código sistemática, donde los símbolos de paridad están al final y el símbolo más a la izquierda es el más significativo. n es como máximo 12 −m . Si n no es exactamente 12 −m , entonces rsdec supone que code es una versión degradada de un código acortado (shortened code). En la estructura Galois decodificada, cada fila representa la tentativa de decodificar la fila correspondiente de code. Ocurre un fallo de decodificación si una fila de code contiene más de (n-k)/2 errores. En este caso, rsdec forma la correspondiente fila de decoded simplemente eliminando n-k símbolos del final de la fila de code.

El siguiente ejemplo codifica tres palabras de información usando un codificador Reed-Solomon (7,3). Se degradará después el código introduciendo un error en la primera palabra de código, dos errores en la segunda palabra de código, y tres errores en la tercera palabra de código. Después rsdec intenta decodificar el código degradado. m = 3; % Numero de bits por simbolo n = 2^m-1; k = 3; % Longitud de las palabras para code msg = gf([2 7 3; 4 0 6; 5 1 1],m); % Tres filas de símbolos de m-bits code = rsenc(msg,n,k); errors = gf([2 0 0 0 0 0 0; 3 4 0 0 0 0 0; 5 6 7 0 0 0 0],m); noisycode = code + errors; [dec,cnumerr] = rsdec(noisycode,n,k) dec = GF(2^3) array. Primitive polynomial = D^3+D+1 (11 decimal) Array elements = 2 7 3 4 0 6 4 0 0 cnumerr = 1 2 -1

La salida muestra que rsdec corrige con éxito los errores en las dos primeras palabras de código y recupera las dos primeras palabras de información originales. Sin embargo, un código Reed-Solomon (7,3) puede corregir como máximo dos errores de cada palabra, por lo tanto rsdec no puede recuperar la tercera palabra de información. Los elementos del vector cnumerr indica el número de errores corregidos en las dos primeras palabras y también indica el fallo de decodificación de la tercera palabra.


100

Para finalizar presentamos el resultado que se obtiene de ejecutar este bloque de

decodificación Reed-Solomon, cuando el código usado es (7,3) y el vector a decodificar (code) es rxRS.

rxRS = Columns 1 through 14 1 0 0 1 1 1 0 1 0 0 0 1 0 1 Columns 15 through 21 1 0 0 0 1 0 1 rxRS = 1 1 1 0 0 0 0 0 0 1 0 0 1 1 1 1 0 0 0 1 1 rxRS = 7 0 0 4 7 4 3 bloqueRS = 7 0 0 4 7 4 3 bloqueGalois = GF(2^3) array. Primitive polynomial = D^3+D+1 (11 decimal) Array elements = 7 0 0 4 7 4 3 bloqueDatos = GF(2^3) array. Primitive polynomial = D^3+D+1 (11 decimal) Array elements = 7 0 0 rxDatos = 7 0 0 rxDatos = 7 0

Se puede comprobar que el vector obtenido es idéntico al vector de datos transmitidos por lo que la comunicación de la trama se ha realizado de forma correcta y con cero errores, que es lo que se pretendía. SER = 0 BERSinProt = 0

101

Capítulo 4 Sincronización

Para lograr una detección y demodulación precisa de la señal OFDM es necesario que las subportadoras sean ortogonales. Variaciones en el oscilador de la portadora, la frecuencia de muestreo o la temporización de símbolo alteran la ortogonalidad del sistema y complican la sincronización.

Mientras que variaciones de la frecuencia de muestreo inferiores a 50 ppm

tienen un ligero efecto en el rendimiento del sistema, la temporización de símbolo y los offsets de frecuencia pueden causar interferencia entre símbolos (ISI) e interferencia entre portadoras (ICI) por lo que deben ser tenidos en cuenta.

Uno de los argumentos en contra de OFDM es este, ya que se trata de una

modulación muy sensible a errores de sincronización, en particular, a errores de frecuencia. Aquí se hace una revisión de estos tres problemas de la sincronización: la sincronización de símbolo, de frecuencia de portadora y de frecuencia de muestreo. También, se tratan los efectos de los offsets de fase y del ruido de fase. 4.1 Sincronización de símbolo 4.1.1 Errores de temporización

En los sistemas OFDM se le presta mucha atención a la sincronización de símbolo. Sin embargo, usando el periodo de guarda (prefijo cíclico), los requerimientos temporales de algún modo se relajan. Una dispersión temporal da lugar a una rotación de fase de las subportadoras. Esta rotación de fase es más acusada en los extremos de la banda de frecuencia. Si un error temporal es lo suficientemente pequeño como para mantener la respuesta impulsiva del canal dentro del prefijo cíclico, la ortogonalidad de las subportadoras se mantiene. En este caso el retraso temporal del símbolo puede ser visto como un desplazamiento de fase introducido por el canal, y las rotaciones de fase se pueden estimar con un estimador de canal. Si el desplazamiento en tiempo es mayor que el prefijo cíclico, entonces tendremos ISI.

Hay dos métodos principales de sincronización en tiempo: uno basado en señales piloto y otro basado en el prefijo cíclico. Warner y Leung [11] sugirieron un algoritmo para resolver este problema. Ellos usan un esquema donde la señal OFDM se transmite mediante una modulación en frecuencia (FM). El transmisor codifica con fases y amplitudes conocidas un número de subcanales reservados. La técnica de

Sincronización

102

sincronización, con modificaciones, se aplica a las señales OFDM transmitidas mediante modulación de amplitud. Su algoritmo consta de tres fases: detección de potencia, sincronización grosera y sincronización fina.

La primera fase (detección de potencia) detecta si la señal OFDM está presente, midiendo la potencia recibida y comparándola con un umbral. La segunda fase (detección grosera) se usa para adquirir un alineamiento de sincronización con un error de ±0.5 muestras. Esta desviación no es aceptable, pero esta fase sirve para simplificar el algoritmo de seguimiento (que puede asumir que el error de temporización es pequeño).

La sincronización grosera se realiza correlando la señal recibida con una copia

de la señal de sincronización transmitida. Para encontrar el pico de esta correlación con suficiente exactitud, se usa un filtro digital para proporcionar valores interpolados a cuatro veces la tasa de datos original. En la última fase (sincronización fina) de la sincronización, los subcanales con señales piloto se ecualizan con el canal estimado obtenido de los pilotos. Como la sincronización grosera garantiza que el error de temporización es menor que ±0.5, la respuesta impulsiva del canal está dentro del prefijo cíclico. Los errores de fase que permanecen en los subcanales piloto se deben al error de temporización y pueden ser estimados mediante regresión lineal.

Hay también algoritmos basados en el prefijo cíclico [12]. La diferencia entre muestras recibidas separadas por N muestras se forma como )()( Nkrkr +− . Si una de las muestras pertenece al prefijo cíclico y la otra al símbolo OFDM del que se copia, la diferencia debería ser pequeña. De otra forma, la diferencia (entre dos variables aleatorias incorreladas) tendrá el doble de potencia, y por tanto, de media, será mayor. Enventanando esta diferencia con una ventana rectangular con la misma longitud que el prefijo cíclico, la señal de salida tiene un mínimo en el comienzo de un nuevo símbolo OFDM.

Podemos maximizar la función de probabilidad dada la señal observada )(kr , con un error de temporización y de frecuencia (esta función se obtiene en [13,14]) para obtener simultáneamente una estimación de ambos offsets, el de tiempo y el de frecuencia. Si no tenemos en cuenta el offset de frecuencia la función de probabilidad con respecto al offset de temporización θ es

21

)()(1

)}(*)(Re{1

2)( NkrkrSNR

SNRNkrkrSNR

L

k

+−+

−++

=Λ ∑−+

=

θ

θ

θ [4.1]

Para SNRs medias y altas (SNR>>1) un estimador de máxima probabilidad

(ML) basado en )(θΛ aplica esencialmente un promediado móvil a el término 2)()( Nkrkr +− . Sin embargo para valores bajos de SNR también debe tenerse en

cuenta el término de correlación cruzada )(*)( Nkrkr + . Se puede usar también un procedimiento similar [15] con la diferencia de que las partes de fase y cuadratura de la señal observada )(kr se cuantizan con 1 bit antes de estimar θ . Esto nos lleva a un sincronizador de símbolo de baja complejidad y que puede ser usado en un modo de adquisición.

Sincronización

103

La sincronización en el enlace ascendente es más difícil que en el enlace descendente o en difusión. Esto es debido al hecho de que habrá un offset separado para cada usuario. Todavía no se le ha dado mucha importancia a este problema. Sin embargo, se usa una secuencia de acceso aleatorio para sincronizar la estación base con la móvil. 4.1.2 Sincronización de trama y símbolo en el sistema implementado La sincronización temporal será fundamental para el correcto funcionamiento del sistema de transmisión y, como ya se ha visto, en sistemas OFDM es incluso más compleja usándose algoritmos que se basan en señales piloto o el prefijo cíclico.

El sistema de transmisión que se ha implementado en este proyecto utiliza como medio de transmisión el cable de audio, que introduce poco ruido y tiene una característica frecuencial prácticamente ideal, como ya se ha visto en el capítulo 2. Esto nos permite sincronizar el sistema de una forma más sencilla, ya que nos limitaremos a sincronizarnos a cada trama.

La sincronización de trama se lleva a cabo mediante la inserción, al comienzo de

cada trama, de una señal de sincronismo en el transmisor. En el receptor se detectará esta señal de cada trama realizando una correlación cruzada entre la señal de datos recibida y la señal de sincronismo que es conocida, ya que al hacer esto se obtienen picos al comienzo de cada trama. La señal de sincronismo utilizada es la señal chirp, señal generadora de un coseno con barrido en frecuencia, que se ha escogido por sus buenas características a la hora de la correlación. Una vez sincronizados a la trama, la sincronización de símbolo (supersímbolo en este caso) se hará tomándose las muestras correspondientes a cada supersímbolo ya que el tamaño de cada uno de estos es conocido por el receptor, es decir, se realiza lo que antes se ha denominado como sincronización grosera.

Como ya se ha comentado, este tipo de sincronización puede lograr un alineamiento con un error de ±0.5 muestras por lo que en la mayoría de los casos habrá que realizar posteriormente una sincronización fina debido a que los relojes del transmisor y receptor están desfasados al muestrear y esto provocará un giro de la constelación lo que producirá numerosos errores en la comunicación. En nuestro caso, como se verá en el apartado 4.2, no existe desjuste en las frecuencias de muestreo del transmisor y receptor por lo que una sincronización grosera será suficiente para obtener un funcionamiento correcto del modem. Dado que el desvío de alineamiento de ±0.5 muestras se produce en todos los supersímbolos, y este será bastante importante en frecuencias altas del espectro, usaremos el supersímbolo de entrenamiento para corregir este error en el igualador. Por lo tanto, tras el bloque igualador todos los símbolos estarán en su posición correcta aunque no se correspondan con los puntos exactos de la constelación debido al ruido del canal.

Sincronización

104

-5 0 5-4

-2

0

2

4Constelacion transmitida

Eje de fase

Eje

de

cuad

ratu

ra

-2 0 2-2

-1

0

1

2Constelacion recibida pre-igualador

Eje de fase

Eje

de

cuad

ratu

ra

-5 0 5-4

-2

0

2

4Constelacion recibida pos-igualador

Eje de fase

Eje

de

cuad

ratu

ra

Figura 4.1. En color rojo se representa la constelación recibida antes de la ecualización y en verde después de la ecualización. Se puede observar que el giro de la constelación

producido por el desfase de ±0.5 muestras es corregido por el igualador. A continuación se muestra el código MATLAB de la parte de sincronización del

sistema de transmisión implementado:

% Parametros de configuracion de sincronismo SINCpre = 10; SINCchi = 100; SINCf0 = 0; SINCf1 = .5; SINCpos = 10; SINCk = 1; sincro = [ zeros(1,SINCpre) SINCk * chirp(0:(SINCchi-1), SINCf0, SINCchi, SINCf1) zeros(1,SINCpos) ]; %En el transmisor %%%%%%%%%%%%%%%%%% % Añade señal sincronismo %%%%%%%%%%%%%%%%%% txMUE = [ sincro txMUE]; %En el receptor %%%%%%%%%%%%%%%%%% % Deteccion de sincronismos %%%%%%%%%%%%%%%%%% cor = xcorr(totaltramas, sincro); cor = cor((length(totaltramas)-length(sincro)+1):end); SINCumbral=0.8*max(cor) %Se utiliza el tamaño de la trama para avanzar más rápido en el bucle de %detección de las señales de sincronismo SINCtamtram = SINCss * ( GUAmue + 2 * ( ESPginf + ESPbanda + ESPgsup ) ); indice = 1; detec = []; while 1, superan = find(cor(indice:end)>SINCumbral) + indice; if length(superan) == 0 break end

Sincronización

105

detec = [ detec superan(1) ]; indice = superan(1) + SINCtamtram; end %%%%%%%%%%%%%%%%%% % Bucle del receptor %%%%%%%%%%%%%%%%%% totaldatosRX = []; for inicio = detec rxMUE = totaltramas(inicio:(inicio+SINCtamtram-1)); %%%%%%%%%%%%%%%%%% % Pasa de muestras a supersimbolos %%%%%%%%%%%%%%%%%% rxGUA = ser2par( rxMUE, GUAmue + 2 * ( ESPginf + ESPbanda + ESPgsup ) ); La señal de sincronismo como se ha comentado es una señal chirp, esta señal se puede generar en MATLAB fácilmente y tiene la siguiente forma:

y = chirp(t,f0,t1,f1)

Esta función genera muestras de una señal de barrido en frecuencia lineal en los

instantes definidos en el vector t. La frecuencia instantánea en el tiempo 0 es f0 y la frecuencia instantánea f1 se consigue en t1.

Se puede ver que la amplitud de la señal chirp es un parámetro que se podrá

modificar según los parámetros de transmisión escogidos. La señal de sincronismo está formada por una secuencia de ceros al comienzo, la

señal chirp en medio, y una secuencia de ceros al final. Estos ceros no tienen otra finalidad que la de añadir una cierta guarda para separar las tramas. Se observa que el transmisor no hace más que añadir la señal de sincronismo al comienzo de cada trama antes de enviarla por el canal de transmisión.

900 950 1000 1050 1100 1150 1200 1250 1300

-0.8

-0.6

-0.4

-0.2

0

0.2

0.4

0.6

0.8

Trama con señal de sincronismo

Indice temporal n

Am

plitu

d

Figura 4.2. Esta figura se ha hecho un zoom de una trama con su señal de sincronismo donde se aprecia la forma de la señal chirp

Sincronización

106

0 500 1000 1500 2000 2500 3000 3500

-1

-0.5

0

0.5

1

Tramas transmitidas por el canal

Indice temporal n

Am

plitu

d

2.15 2.2 2.25 2.3 2.35 2.4 2.45 2.5

x 104

-1

-0.5

0

0.5

1

Tramas recibidas tras el canal

Indice temporal n

Am

plitu

d

Figura 4.3. Distintas tramas separadas por su señal de sincronismo

Se puede observar que tanto las tramas como la señal de sincronismo están

normalizadas a la unidad para ajustarse al rango dinámico del transmisor. El receptor lleva a cabo la detección de las diversas señales de sincronismo. En

primer lugar realiza la correlación de la señal recibida formada por todas las tramas transmitidas con la señal de sincronismo. Con esto obtiene máximos al comienzo de cada trama como se puede ver en la siguiente figura:

Figura 4.4. Detección de las señales de sincronismo

0 2 4 6 8 10 12 14 16

x 104

-10

-5

0

5

10

15

20

25

30

35Deteccion de sincronismos

Indice temporal n

Am

plitu

d

Correlacion con señal de sincronismoUmbral de deteccion

Sincronización

107

A continuación el receptor toma un umbral de decisión7 para poder detectar las señales de sincronismo. El siguiente bucle almacena en la variable detec las posiciones temporales de las señales de sincronismo que se han detectado. Una vez detectadas estas señales se van tomando las tramas de la señal recibida a partir de las posiciones indicadas en detec y tomándose un tamaño de trama SINCtamtram. Seguidamente se forma una matriz donde cada fila es un supersímbolo, ya que el tamaño de los mismos es conocido para el receptor por lo que ya puede comenzar el proceso de demodulación. 4.1.3 Ruido de fase de la portadora

El ruido de fase de la portadora lo causan las imperfecciones en los osciladores del transmisor y el receptor. Para canales selectivos en frecuencia, no se puede hacer una distinción entre la rotación de fase introducida por un error de temporización y un offset de fase de la portadora [16]. En un estudio realizado del impacto del ruido de fase de la portadora [17] se modela este como un proceso de Wiener )(tθ con 0)}({ =tE θ y

ttttE πβθθ 4}))()({( 200 =−+ , donde β (en Hz) denota la anchura de línea lateral del

espectro densidad de potencia Lorentziano del generador de portadoras de libre ejecución. La degradación de la SNR, i.e., el aumento de la SNR necesario para compensar el error, se puede aproximar por

0

410ln6

11)(NE

WNdBD s

≈

βπ [4.2]

donde W es el ancho de banda y 0NEs es la SNR por símbolo. Notar que la degradación aumenta con el número de portadoras. Debido a las rápidas variaciones del ruido de fase, puede causar graves problemas. 4.2 Sincronización de la frecuencia de muestreo

La señal continua en tiempo recibida se muestrea en unos instantes determinados por el reloj del receptor. Hay dos formas de tratar este desajuste de la frecuencia de muestreo. En sistemas de muestreo sincronizado un algoritmo de temporización controla un cristal oscilador controlado por tensión para alinear el reloj del receptor con el reloj del transmisor. El otro método es el muestreo no sincronizado donde la tasa de muestreo permanece fija, lo que requiere un post-procesado en el dominio digital.

El efecto de un offset en la frecuencia del reloj es doble: la componente de señal

útil se rota y atenúa y además, se introduce ICI (interferencia entre portadoras). Se ha investigado el rendimiento de un sistema OFDM con muestreo no sincronizado [18] y se muestra que estos sistemas son mucho más sensibles a offset de frecuencia, comparados con los sistemas de muestreo sincronizado. Para los sistemas de muestreo no sincronizado resulta que la degradación (en dB) debida al offset de muestreo de

7 Existen tarjetas de sonido que invierten la polaridad de la señal, por lo que la gráfica anterior aparecería invertida. En las pruebas que se han realizado en PC´s con este tipo de tarjetas no ha habido problemas de sincronización, pero posiblemente haya casos en que sí falle, por lo que en estos casos habrá que cambiar el programa inviertíendose la señal antes de realizarse la detección de las señales de sincronismo

Sincronización

108

frecuencia depende del cuadrado del índice de la portadora y del cuadrado del offset de la frecuencia relativa.

4.2.1 Sincronización de la frecuencia de muestreo en el sistema implementado En el diseño y realización de un sistema de transmisión es fundamental tener en cuenta la posible desviación que puede ocurrir entre la frecuencia de muestreo del transmisor y el receptor, ya que esta desviación puede provocar que la comunicación se realice de forma incorrecta y con una alta tasa de errores. En el sistema de transmisión que se está usando para la simulación de la modulación COFDM se utiliza la tarjeta de sonido en modo full-duplex (o dos tarjetas de sonido distintas en el caso de utilizar dos ordenadores) y es con ella con la que se transmiten y reciben los datos. La tarjeta de sonido posee dos convertidores D/A y A/D para la transmisión y recepción respectivamente, y cada uno de estos realizará la conversión a la tasa que indica la frecuencia de muestreo. Las tarjetas de sonidos actuales poseen la capacidad de poder generar sonidos utilizando una amplia gama de frecuencias de muestreo, es decir se puede variar la frecuencia de los osciladores que utilizan los convertidores A/D y D/A. Recordemos que la frecuencia de muestreo que se usa en este proyecto es 44100 Hz (la básica del formato PCM) pero puede ocurrir un leve desajuste en esta frecuencia, es decir es posible que los osciladores del transmisor y receptor no permitan esta frecuencia exacta sino que:

♦ El oscilador del transmisor funcionará a una frecuencia de 44100 ± Tδ Hz ♦ El oscilador del receptor funcionará a una frecuencia de 44100 ± Rδ Hz

donde Tδ y Rδ son cantidades relativamente pequeñas en relación a la

frecuencia base de 44100 Hz y dependen, en todo caso, de la calidad de las tarjetas de sonido empleadas. Se debe considerar también, que este desajuste de las frecuencias de muestreo es más probable que se de cuando se usan dos tarjetas distintas, una para transmitir y otra para recibir, pero cuando sólo se usa una tarjeta, es lógico pensar que se use el mismo oscilador para los dos convertidores por lo que no habría desajuste y no tendríamos que resolver este problema. 4.2.1.1 Cálculo del desajuste de frecuencias de muestreo Para calcular el posible desajuste que puede haber entre las frecuencias de muestreo del transmisor y el receptor, enviaremos a través del canal dos deltas de Dirac separadas una cierta distancia conocida. Al recibirlas volvemos a medir esta distancia por lo que obtendremos el número de muestras de diferencia entre lo transmitido y lo recibido. El siguiente programa de MATLAB realiza este cálculo: %Funcion desajuste_. Calcula la diferencia entre la frecuencia de muestreo del %transmisor y la del receptor en partes por millon.

Sincronización

109

frecMue = 48000; dur = 60; gua = 1; tx = [ zeros(1,gua*frecMue) 1 zeros(1,dur*frecMue) 1 zeros(1,gua*frecMue) ]; wavplay(tx, frecMue,'async'); %%%%%%%%%%%%%%%% rx = wavrecord(length(tx), frecMue, 1,'double')'; figure(1); subplot(2,1,1); plot(tx),title('Señal transmitida'); subplot(2,1,2); plot(rx),title('Señal recibida'); tx1=tx(1:length(tx)/2); tx2=tx(length(tx)/2:length(tx)); txd1=find(tx1==max(tx1)); txd2=find(tx2==max(tx2)); rx1=rx(1:length(rx)/2); rx2=rx(length(rx)/2:length(rx)); rxd1=find(rx1==max(rx1)); rxd2=find(rx2==max(rx2)); disp(['Desajuste: ' num2str(1000000*((txd1-rxd1)-(txd2-rxd2))/(dur*frecMue+1)) ' ppm Precision: ' num2str(1000000/(dur*frecMue+1)) ' ppm']);

Si ejecutamos esta rutina obtenemos: >>desajuste_ Desajuste: 0 ppm Precision: 0.34722 ppm

En cambio si cambiamos la frecuencia de muestreo a 44100 Hz: >>desajuste_ Desajuste: 43 ppm Precision: 0.75586 ppm

Es interesante resaltar que cuando se utiliza una frecuencia de muestreo de 44100 Hz se obtiene un desajuste entre las frecuencias de 43 ppm, en cambio si utilizamos la frecuencia de 48000 Hz no se obtiene desajuste alguno entre frecuencias. Este hecho nos hace pensar no existe un desajuste real en las frecuencias de muestreo del transmisor y receptor, ya que al usarse un única tarjeta, esta utiliza un único oscilador para ambos convertidores (A/D y D/A). La explicación a lo anterior es la siguiente: El oscilador de la tarjeta de sonido funciona a una frecuencia base de 48000 Hz. El resto de frecuencias de muestreo que se pueden utilizar se obtienen mediante divisores de frecuencia digitales. Cabe pensar que si la tarjeta es de mala calidad, y dado que 44100 Hz no es divisor de 48000 Hz, la conversión de frecuencia no se realice de forma correcta obteniéndose una ligera desviación respecto del valor nominal, esto explicaría la obtención del desajuste de 43 ppm en el caso de utilizar la frecuencia de

Sincronización

110

muestro de 44100 Hz. Por lo tanto, y para evitar problemas de sincronización, para las pruebas de simulación del sistemas se ha empleado la frecuencia de 48000 Hz. 4.3 Sincronización de la frecuencia de la portadora

A continuación se presentan los errores de frecuencia que se pueden dar en un sistema OFDM cuando el sistema no es paso-baja (LP) sino paso-banda (BP), por lo que será necesario el uso de una portadora que suba la señal OFDM a la frecuencia del canal en el transmisor y después la baje (la traslade a la banda base) en el receptor. Este proceso, cuando ocurren offsets o errores en la frecuencia de la portadora, puede provocar los efectos destructivos en el sistema que se presentan en este apartado.

Dado que el sistema COFDM que se ha implementado usa un canal prácticamente LP, se trabajará en banda base y por lo tanto, no habrá que tener en cuenta los posibles problemas de sincronización de la frecuencia de portadora. Aún así, presentamos cuáles podrían ser estos errores y su posible solución para el caso de que el canal de transmisión que se use sea paso-banda.

4.3.1 Errores de frecuencia

Los offsets de frecuencia se crean por las diferencias entre los osciladores del transmisor y del receptor, desplazamientos Doppler, o ruido de fase introducido por canales no lineales. Hay dos efectos destructivos causados por un offset en la frecuencia de portadora en sistemas OFDM. Uno es la reducción de la amplitud de la señal (se produce un desplazamiento de las funciones sinc y no se vuelven a muestrear en el pico) y el otro es la introducción de ICI proveniente del resto de portadoras. Este último efecto está causado por la pérdida de la ortogonalidad entre los subcanales. Pollet [17] evalúa analíticamente la degradación de BER causada por la presencia de offset de frecuencia de la portadora y ruido de fase de la portadora para un canal AWGN. Se encuentra que un sistema multiportadora es mucho más sensible que uno de portadora única. Denota el offset relativo de frecuencia, normalizado por el espaciado entre subportadoras, como

NWFf ∆

=∆ , donde F∆ es el offset de frecuencia, W el ancho de

banda y N el número de subportadoras.

La degradación D de la SNR (en dB) se puede aproximar por

0

2

0

2 )(10ln3

10)(10ln3

10)(NE

WFN

NE

fdBD ss ∆⋅=∆≈ ππ [4.3]

Notar que la degradación (en dB) aumenta con el cuadrado del número de

subportadoras, si F∆ y W están fijados.

Sincronización

111

Figura 4.1. Efectos de un offset de frecuencia F∆ : reducción de la amplitud de la señal

)(o e interferencia entre portadoras )(• .

En la investigación realizada por Moose [19] estudia la relación señal-interferencia (SIR) en un canal con desvanecimiento y dispersivo. La SIR se define como la relación entre la potencia de la señal útil y la potencia de la señal de interferencia (ICI con ruido aditivo). Él supone que todas las atenuaciones del canal

kh tienen la misma potencia, }{ 2khE . Una cota superior de la degradación es

)sin

sin5947.01(log10)( 2

2

010 fc

fNE

dBD

s

∆

∆+≤

π [4.4]

donde sinc )()(sin xxx ππ= . En la figura 4.2 la degradación se representa como

una función del offset de frecuencia normalizado f∆ , i.e. relacionada con el espaciado entre subportadoras.

Offset de frecuencia relativo

Figura 4.2. Degradación de la SNR debido al offset de frecuencia (normalizado con respecto al espaciado entre subportadoras). La expresión analítica para AWGN (rayado) y canales con desvanecimiento (línea continua).

Frecuencia

Amplitud ∆F

Deg

rada

ción

D e

n dB

Sincronización

112

Las conclusiones sobre los requerimientos de sincronización de un sistema

OFDM [20] son que para evitar una degradación severa, la precisión de la frecuencia de sincronización debería ser mejor que el 2%. 4.3.2 Estimadores de frecuencia

Se sugieren varios esquemas para la sincronización de la portadora. Al igual que con la sincronización de símbolo, se pueden dividir en dos categorías: los que se basan en señales piloto o los que se basan en el prefijo cíclico.

A continuación se presenta una breve explicación de algunos de ellos.

Los algoritmos basados en pilotos [21] usan algunas de las subportadoras para la

transmisión de las señales piloto (normalmente estas son secuencias pseudo-ruidosas (PN)). Usando estos símbolos conocidos se pueden estimar las rotaciones de fase causadas por el offset de frecuencia. Si asumimos que el offset de frecuencia es menor que la mitad del espaciado entre subportadoras, hay una correspondencia unívoca entre las rotaciones de fase y el offset de frecuencia. Para asegurar esto, se debe aplicar un algoritmo de adquisición. Este algoritmo se puede construir formando una función con la forma de la función sinc y con un pico para 0=−

∧

ff . Se ha encontrado que evaluando esta función en puntos separados por 0.1/T, la adquisición se puede obtener maximizando esta función. Este algoritmo de adquisición se ha comprobado, mediante simulaciones por ordenador, que funciona bien tanto para canales AWGN como para canales con desvanecimiento.

Una técnica relacionada es el uso del prefijo cíclico, el cual se puede ver también como pilotos. La redundancia del prefijo cíclico se puede usar de varias formas: por ejemplo, creando una función que tenga un pico en offset cero y encontrando el valor donde se maximiza [22,12] o haciendo una estimación de máxima probabilidad [22, 24, 19, 14]. Si suponemos que el prefijo cíclico tiene el mismo tamaño que el símbolo OFDM (i.e. el símbolo útil se transmite dos veces), se podría hacer un promediado que eliminaría la dependencia con los datos o usar una dirección de decisión. También podemos encontrar la función de probabilidad para los offsets de tiempo y frecuencia si asumimos un canal no dispersivo y considerando los símbolos de datos transmitidos kx incorrelados.

Maximizando esta función, se puede obtener una estimación simultánea de los

offsets en tiempo y frecuencia. Si el error de frecuencia varía despacio comparado con la tasa de símbolo OFDM, se puede usar un PLL (phase-locked loop) [24] para reducir errores adicionales.

Es interesante hacer notar la relación entre la sincronización de tiempo y frecuencia. El problema de la sincronización de frecuencia se puede reducir disminuyendo el número de subportadoras, lo cual aumentará el espaciado entre portadoras. Esto, sin embargo, aumentará las demandas de la sincronización de tiempo, ya que la longitud del símbolo se hace menor, por lo tanto tendremos un error de temporización relativo mayor. Todo esto pone de manifiesto que las sincronizaciones de tiempo y frecuencia están estrechamente relacionadas.

113

Capítulo 5 Interfaz gráfico

En este capítulo se explica el diseño y programación del entorno gráfico que se ha creado para recibir los parámetros del modulador/demodulador COFDM y mostrar los resultados y las gráficas que se obtienen tras la simulación.

Dado que el modem se ha programado por completo en MATLAB, se ha elegido

este programa también para el diseño del interfaz gráfico por simplicidad, aunque se podría haber elegido otro lenguaje de programación visual como VisualC (C++) o VisualBasic. El interfaz gráfico se utilizará para realizar diversas simulaciones del modem y obtener resultados variando determinados parámetros. 5.1 Interfaz Gráfico de Usuario de MATLAB (GUI)

En MATLAB los interfaces gráficos se llaman GUIs (Grafical User Interface),

están formados por objetos gráficos (componentes) tales como botones, campos de texto, menús, etc. Si la GUI está bien diseñada debería ser muy intuitivo y obvio para el usuario el modo en que se usan los componentes de la misma.

Cuando se proporciona un interfaz entre el usuario y el código de programación

de una aplicación, se permite al usuario operar con esa aplicación sin conocer los comandos que se requieren para llevar a cabo una operación. Por esta razón, las aplicaciones que proporcionan GUIs son más fáciles de aprender y usar que las que se ejecutan desde la línea de comandos.

MATLAB implementa las GUIs como ventanas figura que contienen varios

objetos o componentes (uicontrol: botones, listas desplegables, cuadros de texto…). Se debe programar cada objeto para que lleve a cabo una acción determinada cuando un usuario activa el componente. Además, debemos ser capaces de salvar y ejecutar la GUI. Todas estas tareas vienen simplificadas por GUIDE (Grafical User Interface Development Environment) el entorno de desarrollo de interfaces gráficos de MATLAB. 5.1.1 Entorno de desarrollo de la GUI

Crear una GUI implica dos tareas básicas:

Disponer (laying out) los componentes de la GUI en el entorno.

Interfaz gráfico

114

Programar los componentes de la GUI.

GUIDE es básicamente un conjunto de herramientas de layout. Sin embargo, GUIDE también genera un fichero-M (.m de MATLAB) que contiene el código que se encarga de la inicialización y el lanzamiento de la GUI. Este fichero-M proporciona un marco de trabajo para la implementación de las llamadas o callbacks que son las funciones que ejecuta cuando el usuario activa los componentes de la GUI. 5.1.2 Ficheros generados por el GUIDE

Es posible escribir un fichero-M que contenga todos los comandos para disponer gráficamente los componentes de la GUI pero es mucho más fácil usar GUIDE para disponer los componentes (layout) de forma interactiva. Cuando se salva o ejecuta la GUI, GUIDE automáticamente genera dos ficheros:

Un fichero-FIG (fichero con extensión .fig), que contiene una descripción completa de la figura o entorno gráfico de la GUI y todos sus hijos (llamados children): uicontrol and axes, así como los valores de las propiedades de todos los objetos. Se pueden hacer cambios en el fichero-FIG editando la GUI en el editor de layout (Layout Editor). Este editor no es más que una ventana donde a la izquierda aparecen una serie de controles, que se pueden seleccionar haciendo doble clic sobre ellos. Esto hace que aparezca el componente sobre la cuadrícula. Este objeto se puede cambiar de tamaño y se puede posicionar donde se desee.

Un fichero-M, fichero con extensión .m, que contiene las funciones que ejecutan y controlan la GUI y las llamadas o callbacks.

5.1.3 Características del fichero-M

GUIDE simplifica el proceso de crear GUIs generando automáticamente el fichero-M de la GUI a partir del layout. GUIDE genera llamadas para cada componente de la GUI. Inicialmente, GUIDE genera solamente una línea de definición de la función para cada llamada o callback. Se puede añadir código a la misma para que lleve a cabo la operación deseada.

Interfaz gráfico

115

El fichero-M contiene otras dos funciones donde posiblemente sea necesario añadir código:

Función de apertura (opening function) que lleva a cabo tareas antes de que la GUI se haga visible al usuario, tales como crear datos para la GUI. GUIDE nombra esta función my_gui_OpeningFcn, donde my_gui es el nombre de la GUI.

Función de salida (output function) que saca variables a la línea de comandos si

fuera necesario. GUIDE nombra esta función my_gui_OutputFcn, donde my_gui es el nombre de la GUI.

5.1.4 Creación de la GUI Para crear un interfaz gráfico lo primero que se debe hacer es diseñarlo. Es decir, antes de comenzar, debemos tener una estructura dibujada en papel que muestre la apariencia que deseamos para nuestra GUI. Una vez diseñada la GUI, debemos editarla, y para esto debemos recurrir al editor de layout. Lo más sencillo a la hora de editar una GUI es usar el GUIDE, por lo que antes de comenzar debemos llamarlo desde la línea de comandos de MATLAB: >>guide

Al hacer esto nos aparece la siguiente ventana (GUIDE Quick Start) que nos permite elegir entre abrir una nueva GUI o por el contrario, seleccionar una que haya sido creada con anterioridad.

Además tenemos la posibilidad de elegir plantillas (templates) de GUI’s que incluyen una serie de componentes, por lo que pueden ser de utilidad en determinados casos. Para la creación de la GUI de este proyecto se elige Blank GUI (Default), para que nos aparezca un interfaz en blanco donde podamos colocar todos los componentes que deseemos.

Interfaz gráfico

116

Esto nos permite ya seleccionar los objetos de la GUI de la paleta de componentes que aparece a la izquierda de la ventana y posicionarlos sobre la cuadrícula. Como vemos, se puede cambiar el tamaño de la cuadrícula, que será el tamaño real del entorno gráfico, mediante el ratón o usando el property inspector del menú view. Este inspector de propiedades nos servirá también para modificar y establecer las propiedades de todos los objetos o componentes que forman la GUI.

Una vez colocados los componentes sobre la GUI, estos se pueden alinear e

incluso se puede programar el modo en que el usuario los puede seleccionar cuando se use el tabulador.

La GUI que se ha creado para este proyecto se muestra a continuación y

contiene los siguientes componentes: menús desplegables, texto estático, texto editable, botones radio, botones de pulsado, marcos, listas y ejes.

Interfaz gráfico

117

5.1.4.1 Programación de la GUI Para llevar a cabo la programación de la GUI se hará uso del llamado inspector de propiedades o property inspector. Este inspector se puede seleccionar, o bien, en la barra de herramientas que aparece en la parte superior de la ventana figura o bien, seleccionándolo en el menú view. El property inspector aparece al hacer click con el botón derecho sobre cualquier componente y nos permitirá modificar las propiedades del mismo. Las más importantes son String, Callback y Tag.

La propiedad String contendrá los nombres que aparecen en los componentes de la GUI. En caso de menús o listas desplegables, contendrá varios nombres o valores numéricos, uno para cada opción que se presente. Internamente String no es más que un vector con un tamaño igual al número de cadenas o valores enteros que se introduzcan por lo que se podrá acceder a estos campos en el fichero-M.

La propiedad callback aparece por defecto como %automatic y será la función a la que se llama en el fichero-M de la GUI cuando un usuario activa un componente. GUIDE usa la propiedad Tag del componente para asociar el componente con la función. Para que la programación de esta función sea más fácil e intuitiva, debemos cambiar la propiedad Tag del objeto, ya que por defecto aparecen nombres genéricos, como el tipo de componente y un número. En nuestro caso, se han cambiado los nombres a ListaBDT, ListaMuestreo, TextoTiempo… Esto permite que cuando se salve o ejecute la GUI, GUIDE establezca la propiedad de los distintos componentes a ListaBDT_callback, ListaMuestreo_callback, TextoTiempo_callback... Ya tan solo queda programar las distintas funciones de la GUI. Para ello, debemos acceder al fichero-M, que se genera automáticamente cuando se salva el layout, o se ejecuta. Podemos acceder al mismo desde el icono de MATLAB de la barra de herramientas superior, o desde la línea de comandos si la GUI ya ha sido salvada anteriormente. Una vez obtenido el fichero-M, comprobamos que aparece una gran cantidad de código con numerosos comentarios que se genera automáticamente a partir del layout. Cabe destacar que las funciones de creación de los componentes que aparecen no se modificarán, tan sólo las propiedades de estos componentes. Podemos acceder a las distintas funciones que aparecen en el fichero desde el icono con forma de f, que

Interfaz gráfico

118

aparece en la barra de herramientas superior y haciendo click sobre cualquiera de estas funciones, accedemos directamente a la línea de código donde se encuentra la función.

Lo más importante a tener en cuenta a la hora de programar las llamadas de la GUI son los parámetros de entrada que contienen la mayoría de las funciones. Estos parámetros (hObject, eventdata, handles) serán las referencias o manejadores de los distintos componentes y servirán para acceder a las distintas propiedades de los mismos.

− hObject: referencia o manejador del componente. − eventdata: reservado. − handles: estructura con los manejadores o referencias y los datos de usuario.

Mediante las funciones set o get y accediendo a los campos de la estructura

handles estableceremos propiedades o tomaremos valores e inicializaremos los distintos componentes. Un ejemplo de esto es el siguiente: %En este ejemplo se establece que el cuadro de texto donde se introduce la %imagen a transmitir sea de color blanco mientras que el cuadro de texto donde %se introduce el número de tramas sea del color del resto de la ventana, color %por defecto. Además se habilita el cuadro de texto de la imagen y se %deshabilita el cuadro de texto de las tramas de datos aleatorias. set(handles.TextoTramas,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); set(handles.TextoImagen,'BackgroundColor','white'); set(handles.TextoImagen,'Enable','on'); set(handles.TextoTramas,'Enable','off');

El interfaz gráfico que se ha creado para este proyecto pretende tomar valores que introduzca el usuario y llamar a la función principal_ del modem programado con estos valores como argumentos de entrada. Una vez obtenidos los resultados los imprimirá en los cuadros correspondientes y mostrará las distintas gráficas en los cuadros de ejes. Para hacernos una idea cómo se programa todo esto en MATLAB se presenta a continuación, la parte de código que realiza la toma de parámetros introducidos en el interfaz y la llamada al modem COFDM. % --- Executes on button press in BotonSimular. function BotonSimular_Callback(hObject, eventdata, handles)

Interfaz gráfico

119

% hObject handle to BotonSimular (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %Se toman los valores introducidos por el usuario %y para todos se comprueba que el valor del %parametro es aceptable %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% imag = get(handles.RadioImagen,'Value'); imagen = get(handles.TextoImagen,'String'); NumTramas = str2double(get(handles.TextoTramas,'String')); contents = get(handles.ListaBDT,'String'); BDT = str2double(contents{get(handles.ListaBDT,'Value')}); contents = get(handles.ListaMuestreo,'String'); AUDIOfrec = str2double(contents{get(handles.ListaMuestreo,'Value')}); val = get(handles.ListaRS, 'Value'); RSkL = [ 188 3 ]; RSnL = [ 204 7 ]; RSk = RSkL(val); RSn = RSnL(val); val = get(handles.ListaCC,'Value'); CCkL = [ 1 2 3 5 7 ]; CCnL = [ 2 3 4 6 8 ]; CCk = CCkL(val); CCn = CCnL(val); contents = get(handles.ListaGuarda,'String'); GUAint = str2num(contents{get(handles.ListaGuarda,'Value')}); contents = get(handles.ListaQAM,'String'); QAMm = str2num(contents{get(handles.ListaQAM,'Value')}); ESPbanda = str2double(get(handles.TextoBandas,'String')); ESPginf = str2double(get(handles.TextoGInf,'String')); ESPgsup = str2double(get(handles.TextoGSup,'String')); set(handles.BotonSimular,'Enable','off'); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Llamar a la funcion principal_ del modem %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% [ Tiempo TasaNeta BER SER esImagen DatosTX DatosRX EspectroTX EspectroRX ConstelacionTX ConstelacionRX ] = principal_(imag,imagen,NumTramas,RSn,RSk,CCk,CCn,QAMm,ESPbanda,ESPginf,ESPgsup,GUAint,AUDIOfrec); %%%%%%%%%%%%%%%%%%%%%%%%%% set(handles.BotonSimular,'Enable','on'); %%%%%%%%%%%%%%%%%%%%%%%%%% %Representación de resultados %%%%%%%%%%%%%%%%%%%%%%%%%% set(handles.TextoTiempo,'String',num2str(Tiempo)); set(handles.TextoTasa,'String',num2str(TasaNeta));

Interfaz gráfico

120

set(handles.TextoBER,'String',num2str(BER)); set(handles.TextoSER,'String',num2str(SER)); handles.esImagen = esImagen; handles.DatosTX = DatosTX; handles.DatosRX = DatosRX; handles.EspectroTX = EspectroTX; handles.EspectroRX = EspectroRX; handles.ConstelacionTX = ConstelacionTX; handles.ConstelacionRX = ConstelacionRX; handles.AUDIOfrec = AUDIOfrec; %%%%%%%%%%%%%%%%%%%%%%%%%%% %Se habilitan los botones de representación gráfica %%%%%%%%%%%%%%%%%%%%%%%%%%% set(handles.BotonDatos,'Enable','on'); set(handles.BotonEspectro,'Enable','on'); set(handles.BotonConstelacion,'Enable','on');

A continuación se presentan diversos aspectos que se han tenido en cuenta a la hora de la programación del interfaz gráfico pero no se detallará el código, ya que este puede ser consultado en el apéndice C. Estos aspectos son los siguientes.

1. Se permite que el usuario seleccione la transmisión de una secuencia aleatoria de datos o una imagen. Para esto se han programado los botones radio de forma que esta selección sea excluyente. Además, esta selección deshabilita o habilita los cuadros editables donde se escribe la imagen o el número de tramas aleatorias a transmitir. En el caso de que se seleccione la transmisión de una imagen, se fuerza que el código Reed-Solomon que se utilice sea el (204,188), ya que la imagen tomará valores de 0 a 255 y son los mismos valores que permite este código8.

2. Se han proporcionado listas desplegables con los valores de los distintos códigos

Reed-Solomon, las tasas de código convolucional, los intervalos de guarda, los bytes de datos por trama, los bits/símbolo de la QAM y las frecuencias de muestreo que se permiten. Y se ha proporcionado libertad para que el usuario introduzca el número de bandas o subportadoras que intervendrán en la modulación.

3. Se han deshabilitado los cuadros de texto que mostrarán los resultados de la

simulación y se les ha cambiado el color (pasando de blanco al color gris por defecto) para que queden del color del resto de la ventana y así sea más intuitivo para el usuario el que no se pueda introducir valores en dichos campos.

4. Se han programado funciones que comprueban que los valores de los parámetros

introducidos sean correctos, no permitiéndose números decimales o caracteres.

5. Se han introducido dos tipos de ejes, los horizontales y los verticales. Los horizontales se usarán para mostrar las tramas de datos y los espectros de frecuencia (siempre el superior mostrará lo que se transmite y el inferior lo que

8 Recordemos que el bloque Galois toma valores entre 0 y )12( −RSm

Interfaz gráfico

121

se recibe). Los ejes horizontales tienen forma más cuadrada y se usarán para representar las imágenes y las constelación (el de la izquierda muestra la transmitida y el de la derecha la recibida).

6. Para visualizar las distintas gráficas se han añadido tres botones, el primero para

ver las tramas o imágenes (según lo que se elija), el segundo para mostrar los espectros, y el tercero para mostrar las constelaciones.

7. Se han programado los botones simular y salir. El botón simular será el que

llame a la rutina principal del modulador/demodulador y una vez pulsado, deshabilita el resto de botones. El botón salir cierra la ventana del interfaz gráfico.

Como ya se ha comentado, el código completo de la programación de la GUI se muestra en el apéndice C. Para la programación de la misma se ha hecho uso de la ayuda de MATLAB para la creación de interfaces gráficos y gracias a esto, se han podido realizar todas las modificaciones de las distintas propiedades de los componentes y se han llevado a cabo todas las operaciones explicadas anteriormente.

Interfaz gráfico

122

5.2 Resultados de las pruebas realizadas: Se han realizado diversas pruebas prácticas del sistema implementado modificándose ciertos parámetros de la comunicación (y dejándose otros fijos) para comprobar su influencia en la robustez de la modulación COFDM.

A continuación se presentan una serie de tablas que muestran los resultados obtenidos para el siguiente caso de transmisión/recepción para el que se han dejado fijos ciertos parámetros de la modulación COFDM y se ido variando el intervalo de guarda y la tasa del código convolucional:

Tramas de datos aleatorias = 4 Bytes de datos por trama = 100 Modulación 64-QAM Frecuencia de muestreo = 44100 Hz Bandas útiles = 100 Bandas de guarda inferior = 10 Bandas de guarda superior = 20 Código Reed-Solomon (204,188)

TASA NETA DE TRANSMISIÓN Rb (bps)

CÓDIGO REED-SOLOMON (204,188) INTERVALO DE GUARDA TASA DEL

CÓDIGO CONVOLUCIONAL 1/4 1/8 1/16 1/32

1/2 23901.4 26000.15 27194.09 27833.15 2/3 27072 29373.95 30678.26 31374.83 3/4 31212.4 33753.89 35186.41 35949.26 5/6 31212.4 33753.89 35186.41 35949.26 7/8 31212.4 33753.89 35186.41 35949.26

Se comprueba que la tasa neta de transmisión, es decir, la tasa binaria que se

obtiene sin contar los bits que se meten de relleno como datos útiles, va aumentando y llega a valores de hasta 36 Mbps conforme se disminuye la duración del intervalo de guarda. Esto es lógico ya que un intervalo de guarda menor implica menos datos redundantes.

Cabe destacar en esta tabla que a partir de la tasa de código convolucional 3/4

las velocidades binarias netas9 no varían al varíar la tasa de código. Esto ocurre así porque no se ha tenido en cuenta para el cálculo de la misma los datos de padding que se introducen a lo largo del transmisor. Esto implica que al realizarse el ajuste de los bloques, aunque unas tasas metan más relleno que otras los datos útiles siguen siendo los mismos en todos los casos. Por lo tanto, si contásemos el padding como datos la tasa neta variaría según el tipo de código convolucional empleado. 9 bitDatos = BloqueRSTrama * RSk * RSm * NumTramas; tasaNeta = bitDatos/(length(totaltramas)/AUDIOfrec)

Interfaz gráfico

123

La siguiente tabla muestra la tasa de error de símbolo Reed-Solomon del modem COFDM donde se ha tenido en cuenta la protección que añade al sistema la codificación para el control de errores. Esta tabla muestra que la modulación es muy robusta incluso al cambiar el código Reed-Solomon empleado. Se ha comentado con anterioridad que el código RS (204, 188) proporciona mucha protección ya que puede corregir hasta 8 errores, en cambio, el código RS (7,3) sólo puede corregir hasta 3 errores en cada bloque. En pruebas realizadas con este código que es menos potente se muestra que sólo se producen errores cuando se usan tramas muy largas y constelaciones de muchos puntos (256-QAM).

TASA DE ERROR DE SÍMBOLO (CON CODIFICACIÓN) SER

CÓDIGO REED-SOLOMON (204,188) INTERVALO DE GUARDA TASA DEL

CÓDIGO CONVOLUCIONAL 1/4 1/8 1/16 1/32

1/2 0 0 0 0

2/3 0 0 0 0

3/4 0 0 0 0

5/6 0 0 0 0

7/8 0 0 0 0

Este hecho se muestra también en las siguientes figuras. En estas figuras se

representan los datos transmitidos10, el espectro COFDM de los mismos y la constelación. Tanto la 16-QAM como la 64-QAM no produjeron errores en la comunicación.

10 El programa se modificó finalmente para que apareciesen las tramas transmitidas y recibidas en lugar del valor de los datos de estas tramas.

Interfaz gráfico

124

A continuación se presenta un ejemplo de tranmsión de una imagen de 6,4 KB. Se puede apreciar a simple vista, que usándose una modulación 16-QAM los símbolos están lo suficientemente espaciados como para que no se produzcan fallos en la comunicación.

En cambio, cuando se usa la modulación 256-QAM los errores que se producen son apreciables incluso a simple vista como muestra la imagen recibida.

Interfaz gráfico

125

Para comprobar la diferencia de usar un código Reed-Solomon (204,188) o uno

(7,3), se han representado 7 tramas de 100 bytes. En ambos casos se usó el mismo tipo de modulación 16-QAM y no se obtuvieron errores.

Las siguientes figuras muestran que las tramas del código Reed-Solomon

(204,188) presentan muchos picos provocados por el relleno de ceros, ya que al tomarse los datos en bloques de mucho mayor tamaño el padding que se introduce también es mucho mayor. Este hecho sería conveniente solucionarlo y para ello se podrían cambiar los datos de relleno que ahora son ceros por valores aleatorios para que se aprovechara más el rango dinámico de transmisión. La figura muestra que al normalizarse la señal teniendo en cuenta los picos el rango real que ocupa es muy reducido.

Código RS (7,3) Código RS (204,188)

A continuación se muestra el espectro de la señal COFDM cuando se cambia el número de bandas útiles que se utilizan para la transmisión de la misma. Se han tomado las mismas bandas de guarda en los tres casos:

Número de bandas de guarda inferior = 10 Número de bandas de guarda superior = 20

Interfaz gráfico

126

Estas bandas son las elegidas que aparezcan por defecto en la GUI, debido a que se ha comprobado que es una elección óptima dadas las características del canal. Recordemos que en el capítulo 2 se comprobó que el canal tiene un pico negativo a frecuencias muy bajas y decae abruptamente un poco antes de los 20 KHz aproximadamente. Es por esto, que resulta conveniente no transmitir información útil por estas bandas.

En las siguientes figuras se pueden apreciar bien tanto las bandas útiles como las

de guarda, que en el caso de usarse solamente 10 bandas útiles ocupan la mayor parte del espectro. Así mismo se comprueba que el número de bandas también afecta al relleno, por lo que vemos que al aumentar el número de bandas, los picos debidos al padding casi desaparecen, pero el rango dinámico que ocupa la señal es menor. Caso: 10 bandas

Caso: 100 bandas

Interfaz gráfico

127

Caso: 1000 bandas

128

Capítulo 6 Conclusiones

Este proyecto ha tratado de forma general todos los aspectos de la modulación COFDM profundizando solo en aquellos que son relevantes a la hora de realizar una implementación práctica de la misma. La modulación COFDM es una modulación compleja por lo que es objeto de numerosos estudios más específicos. Hay estudios que basan su análisis tan sólo en el prefijo o intervalo de guarda, otros que tratan en profundidad la compleja sincronización de estos sistemas, otros simplemente estudian el modulador/demodulador básico OFDM, obteniéndose en todos los casos conclusiones que puedan mejorar las características de esta modulación.

Este proyecto ha pretendido dejar claro las ventajas de COFDM mediante la

implementación práctica o simulación de un sistema de transmisión de datos. Las simulaciones realizadas han demostrado la robustez de la modulación y mediante la transmisión y recepción de ficheros que contienen imágenes, se han podido visualizar las repercusiones que tienen los errores de transmisión en la representación de las mismas.

Además de todo esto, destaco el importante valor de ver en la práctica conceptos

estudiados teóricamente en transmisión de datos como son: la constelación de la modulación QAM, la codificación para el control de errores o la representación frecuencial del espectro cuando se usa el ancho de banda de un canal real.

6.1 Posibles mejoras o líneas de continuación En primer lugar, el canal de comunicaciones que se usa no es el más apropiado para probar esta modulación ya que se trata de un canal prácticamente ideal y la modulación COFDM está preparada para trabajar en entornos muy hostiles donde se producen desvanecimientos por multitrayecto por lo que la corrección de errores es muy importante. Por lo tanto, opino que se debería usar otro sistema de transmisión o bien, en caso de usar el mismo, se deberían simular estos desvanecimientos para que el estudio pueda adecuarse más a los sistemas reales que usan esta modulación. Por otro lado la utilización de MATLAB para programar el modulador/demodulador hace que la transmisión/recepción sea muy lenta por lo que este programa no es adecuado para que el sistema funcione en tiempo real.

Además, se pueden realizar mejoras al modem diseñado para hacerlo más parecido utilizados en la realidad en sistemas de radiodifusión digital. Es decir, se

Conclusiones

129

podrían incluir bloques de entrelazado y aleatorizadores de energía que redujesen el problema de la PAR. Este problema se podría solucionar también, como ya se ha comentado, cambiando el padding o relleno con ceros que se va introduciendo en el modulador, por un relleno de datos aleatorios.

Otra posible mejora sería cambiar el tipo de la decodificación de Viterbi, y usar

la decodificación tipo ‘soft’ en lugar de ‘unquant’. Las ventajas de la decodificación soft ya se han comentado pero usar este tipo de codificación implicaría una estimación del ruido en cada banda.

Para finalizar, también sería posible modificar el modulador para que no se use

la misma modulación QAM en todas las bandas, sino que cada una de ellas pueda usar una distinta, dependiendo del ruido de cada banda.

130

Apéndice A Códigos lineales de bloques: códigos Reed-Solomon Codificación lineal por bloques

La codificación lineal por bloques incluye los siguientes tipos de códigos:

Códigos lineales de bloques

Códigos cíclicos

Códigos BCH Códigos Hamming Códigos Reed-Solomon

Cuando se codifica un mensaje, se toman k bits de datos y se le agregan r bits redundantes de manera que se crean nuevos bloques de datos o palabras de código de longitud n ( rkn += ). Si suponemos 3=k , 3=r , entonces a este código se le llama código ( n , k )=(6,3).

Llamemos los datos originales o bits del mensaje 1m 2m 3m . Los bits redundantes se construyen usando relaciones entre los bits de mensaje. Por ejemplo:

m1+m3 m1+m2 m2+m3 m1 m2 m3 0 0 0 0 0 0 1 0 1 0 0 1 0 1 1 0 1 0 1 1 0 0 1 1 1 1 0 1 0 0 0 1 1 1 0 1 1 0 1 1 1 0

Códigos lineales de bloques: códigos Reed-Solomon

131

0 0 0 1 1 1

Donde la suma es módulo 2. Se observa que se tienen k2 (8) combinaciones de las n2 (64) posibles. Cuando el mensaje forma parte de la palabra código, se dice que este es sistemático. Se quiere que las combinaciones enviadas estén lo mas alejadas posible para disminuir la probabilidad de error, por otra parte hay que agregar pocos bits adicionales para que no crezca indefinidamente el ancho de banda.

Se puede pensar en una matriz generadora [G], a partir de la cual pueda generarse el mensaje codificado.

[m][G] = [C] donde la matriz

[G] =

p11 P12 . p1r | 1 0 0 . . 0

p21 P22 . p2r | 0 1 0 . . 0

. . . . . . . . . . .

pk1 pk2 . pkr | 0 0 0 . . 1

I------------------- P-----------| ----------------------- Ik ---------------------|

El proceso de codificar un mensaje con un código lineal de bloque ( n , k ) viene determinado por una matriz generadora nk × , [G]. Específicamente, el vector mensaje [m] k×1 se codifica con el vector palabra de código [C] n×1 . Si G tiene la forma [Ik P] o [P Ik], P es una matriz cualquiera e Ik es la matriz identidad kk × , entonces se dice que [G] está en forma estándar. La primera parte de la matriz [G] la llamaremos porción de arreglo de paridad, y la ultima parte es la matriz identidad. Obsérvese que para generar los códigos solo hay que almacenar la porción de paridad ([P]), de la matriz [G]. En el receptor se tendría una matriz llamada [H] (matriz de chequeo de paridad) que permitiría decodificar los vectores recibidos, y cuya traspuesta sería: [HT] =


132

1 0 . 0

0 1 . 0

. . . .

0 0 . 1

p11 p12 . p1r

p22 . p2r

. . . .

pk2 pkr

Si se multiplica el mensaje codificado (sin errores) por esta matriz, el resultado será nulo.

[C] [HT] = [m][G] [HT] = 0

Si esto ocurre se tiene la garantía que el código que llego es válido. Si, en cambio, el vector [C] se corrompe con un vector [e], la señal recibida será:

[r] = [C]+ [e]

Por lo tanto, si en el receptor multiplicamos por la matriz [HT] obtendremos:

[S] = [r] [HT] = ( [C]+ [e] ) [HT] = [C] [HT]+ [e] [HT] = [e] [HT]

A [S] se le llama el síndrome. Si [r] pertenece al conjunto de palabras válidas, [S]=0. Si [r] tiene un error, [S] dará una pista sobre donde está dicho error. El síndrome sobre [r] es igual al síndrome sobre [e]. Tiene que haber una correspondencia uno a uno entre los patrones de error y el síndrome.

Por lo tanto, decodificar un código lineal de bloque ( n , k ) requiere una matriz de chequeo de paridad [H], nkn ×− )( . Esta matriz satisface [G] [HT] = 0 , donde [HT] denota la matriz traspuesta de [H], [G] es la matriz generadora de código y esta matriz cero es )( knk −× . Si [G] = [Ik P] entonces H = [-PT In-k]. Fortaleza del código

Definiciones:

Peso Hamming de un vector U = w(U) =Numero de elementos no nulos de U. Distancia Hamming entre dos vectores U y V = d(U,V)= Numero de elementos

en los cuales difieren .


133

w(U+V) = d(U,V) w(V) = d(V,0)

La mínima distancia de un código define su fortaleza frente al ruido. Dado que la

suma de dos vectores de un subespacio dará otro elemento del subespacio.

d( U,V) = w(U+V) = w(Z)

Solo necesitamos ver el peso de cada vector y se elige el menor. Esto será la mínima distancia, dmin.

¿Qué hace el receptor?

U. r1. . . . .V (Aquí se decide por U) U. . r2. . . .V (Aquí también se decide por U)

Sin embargo, si transmito V y se producen 3 errores, se convierte en U.

La distancia mínima define la capacidad de detectar y corregir errores. En

general un código ( n , k ) es capaz de corregir 2 r patrones de error o t errores ( t = capacidad de corrección de un código). Códigos cíclicos

Son un tipo de códigos lineales más fáciles de implementar. Un código lineal es llamado cíclico si cumple:

Linealidad: La suma de 2 palabras códigos es otra palabra código Desplazamiento cíclico: Cualquier desplazamiento cíclico de una palabra código

es otra palabra código. Las componentes de un vector de código C0, C1, C2, ... ,Cn-1, pueden ser tratadas

como un polinomio:

C(X) = C0 X0+C1 X1+C2 X2+ ... +Cn-1Xn-1

Si Cn-1es no nulo, se dice que el grado de C(X) es n-1. Si C(X) representa una palabra de un código cíclico, el desplazamiento cíclico del mismo i veces C(i) (X), se puede representar como:

C(i) (X) = Xi C(X) mod (Xn +1) O lo que es lo mismo, C(i) (X) es el residuo que resulta de dividir Xi C(X) por (Xn +1). Supongamos:

C(X) = C0 X0+C1 X1+C2 X2+ ... +Cn-1Xn-1 XC(X) = C0 X+C1 X2+C2 X3+ ... +Cn-1Xn


134

Ahora sumamos 2 veces Cn-1 (ojo 1+1=0)

XC(X) = Cn-1+C0 X+C1 X2+C2 X3+ ... +Cn-2Xn-1 +Cn-1(Xn +1) = XC(X) = C(1)(X)+ Cn-1(Xn +1) C(1)(X) = XC(X)mod(Xn +1)

Por extensión se llega a:

C(i)(X)= X i C(X)mod(Xn +1) El termino (Xn +1) juega un papel clave en la generación de códigos cíclicos. Para generar un código cíclico se puede usar un polinomio generador en forma parecida a como en códigos lineales por bloques usábamos una matriz generadora.

g(X) = Polinomio de grado ( kn − ) m(X) = Polinomio mensaje de grado ( 1−k ) C(X) = Código resultante C(X) = (b0, b1, b2, ... b n-k-1 ,m0, m1, m2, ... m k-1) = b(X)+ X n-km(X) b(X) es el residuo que queda después de dividir X n-km(X) entre g(X))

Procedimiento:

Multiplicar X n-km(X) Dividir X n-km(X)/g(X) Tomar el residuo b(X) Sumar b(X)+ X n-km(X) y este será el código.

Códigos BCH (Bose-Chaudhuri-Hocquenghem)

Los más comunes son los llamados BCH primitivos los cuales tienen: Longitud del bloque: 12 −= mn ( m mayor o igual a 3) Numero de bits del mensaje: mtnk −≥ Distancia mínima ≥ 12 +t

Cada código BCH es un código corrector de t errores.

Códigos Reed-Solomon Son códigos cíclicos no binarios. Un código RS( kn, ) expande un bloque de k símbolos a n símbolos agregando kn − símbolos redundantes. Estos códigos corrigen cualquier combinación de t o menos errores y necesitan no más de t2 bits de paridad. Los parámetros son tckn 2==− y 12 += td siendo d la distancia mínima entre cualesquiera palabras de código (distancia de Hamming), es decir, el número mínimo de cambios de bits necesario para convertir una palabra de código en otra.

135

Apéndice B Códigos Convolucionales

Se pueden ver como una convolución en tiempo discreto entre la palabra de información y la respuesta impulsiva del codificador.

Se diferencian de los códigos de bloque en su forma estructural y las

propiedades para corregir errores. Los códigos de bloque suelen tener limitada la capacidad de corrección de errores alrededor de 1 o 2 símbolos erróneos por palabra de código. Estos códigos son buenos para utilizar en canales con baja probabilidad de error. Los códigos convolucionales son adecuados para usar sobre canales con mucho ruido (alta probabilidad de error).

Los códigos convolucionales son códigos lineales, donde la suma de dos

palabras de código cualesquiera también es una palabra de código. Y al contrario que los códigos lineales se prefieren los códigos no sistemáticos. La probabilidad de error que se puede conseguir con estos códigos (al igual que con los de bloques) es similar a la de los códigos de formas de onda pero en cuanto a ancho de banda son mejores.

El sistema tiene memoria: la codificación actual depende de los datos que se envían ahora y que se enviaron en el pasado. Un código convolucional queda especificado por tres parámetros (n,k,m):

n es el número de bits de la palabra codificada k es el número de bits de la palabra de datos m es la memoria del código o longitud restringida

Ejemplos

- Código (2,1,3)

La palabra codificada tiene 2 bits de longitud La entrada son bloques de 1 bit La salida depende de los dos bloques anteriores y del actual

- Código (4,2,3)

La palabra codificada tiene 4 bits de longitud La entrada son bloques de 2 bits La salida depende de los bloques anteriores y del actual

Códigos convolucionales

136

Proceso de codificación El proceso de codificación de estos códigos se realiza utilizando un dispositivo lógico en el codificador.

Ejemplo: Codificador convolucional (4,3,5)

La palabra codificada se obtendría como el resultado de realizar una serie de operaciones lógicas entre determinados bits que están almacenados en los registros intermedios.

Ejemplo: Codificador convolucional (2,1,3)

El conmutador con las dos entradas hace el papel de un registro de desplazamiento de dos estados. El código convolucional es generado introduciendo un bit de datos y dando una revolución completa al conmutador. Inicialmente se supone que los registros intermedios contienen ceros.

En este ejemplo la palabra codificada se obtiene como resultado de sumas módulo-2 entre los bits indicados que están almacenados en los registros intermedios.

Las secuencias de salida para el código anteriormente descrito:

Entrada (S3,S2,S1)

Salida (O1,O2)

000 00 001 11


137

010 01 011 10 100 10 101 01 110 11 111 00

Como ejemplo del funcionamiento de este codificador, supongamos que se

quiere enviar la secuencia de bits 0101 (donde los bits más a la derecha son los más antiguos).

El proceso de codificación es el siguiente: Se introduce el primer bit de la secuencia en el codificador:

Se introduce el segundo bit de la secuencia en el codificador:

Se introduce el tercer bit de la secuencia en el codificador:

Se introduce el cuarto bit de la secuencia en el codificador:


138

Al final del proceso de codificación obtenemos que la secuencia codificada es 01

01 01 11. Sigamos con la exposición del proceso de codificación. Debido a la memoria del

código es necesario de disponer de medios adecuados para determinar la salida asociada a una determinada entrada.

Hay tres métodos gráficos:

Diagrama árbol o árbol del código: representación mediante un árbol binario de las distintas posibilidades.

Diagrama de estados: es la forma menos utilizada. Diagrama de Trellis o enrejado: es la forma más utilizada porque es la que

permite realizar la decodificación de la forma más sencilla. Para el ejemplo del codificador (2,1,3) anteriormente especificado tenemos el

siguiente Árbol del código:


139

La profundidad del árbol es )1(2 −⋅ m , y el número de estados es km ⋅−⋅ )1(2 La interpretación del árbol del código es la siguiente:


140

Hay dos ramas en cada nodo. La rama superior corresponde a una entrada de un 0. La rama inferior corresponde a la entrada de un 1. En la parte exterior de cada rama se muestra el valor de salida. El número de ramas se va multiplicando por dos con cada nueva entrada.

A partir del segundo nivel el árbol se vuelve repetitivo. En realidad, solo hay

cuatro tipos de nodos: A,B,C,D. Estos tipos de nodos en realidad son estados del codificador. A partir de estos nodos, se producen los mismos bits de salida y el mismo estado. Por ejemplo, de cualquier nodo etiquetado como C se producen el mismo par de ramas de salida: Salida 10 y estado A Y Salida 01 y estado B

A partir de la identificación de los estados del codificador se puede incorporar esta información en el DIAGRAMA DE TRELLIS.

El diagrama de Trellis es un diagrama en forma de red. Cada línea horizontal se corresponde con uno de los estados del codificador. Cada línea vertical se correspondería con uno de los niveles del árbol del código.

Partimos del estado inicial del codificador en el primer nivel del árbol. A partir de aquí se trazan dos líneas desde este estado. Una para el caso de que la siguiente entrada fuera un 0 y otra para el caso de que fuera un 1. Estas líneas irán hasta el siguiente nivel del árbol al estado en el que queda el codificador después de haber codificado las correspondientes entradas. Encima de cada una de estas líneas escribiremos la salida del codificador para esa codificación.

Para cada nivel del árbol hacemos lo mismo desde todos los estados en los que el codificador se puede encontrar.

Según todo esto, el diagrama de Trellis para el codificador (2,1,3) de nuestro ejemplo será:

Vamos a seguir en el diagrama de Trellis que acabamos de construir la codificación de la secuencia de bits 0101.


141

Proceso de decodificación

El proceso de decodificación consiste en buscar un camino en el diagrama de Trellis (o en el árbol del código) que nos dé la secuencia de bits más probable (si no hay errores obtendremos la secuencia exacta).

El codificador convolucional añade una estructura a la secuencia de bits. Incluso

aunque la entrada sea totalmente aleatoria, se fuerza a que la salida siga unas determinadas secuencias. Esta restricción es la que da la capacidad correctora a los códigos convolucionales.

El procedimiento de decodificación es equivalente a comparar la secuencia recibida con todas las posibles secuencias que pueden obtenerse con el correspondiente codificador y seleccionando la secuencia que está más próxima a la secuencia recibida. Para realizar la decodificación se utiliza un algoritmo denominado Algoritmo de Viterbi.

El fundamento de este algoritmo está en que no se almacenan todas las

secuencias a las que da lugar el codificador. Se basa en el principio de optimalidad: el mejor camino (menor distancia de Hamming) a través del diagrama de Trellis que pasa por un determinado nodo, necesariamente incluye el mejor camino desde el principio del diagrama de Trellis hasta este nodo.

El principio anterior implica que para cada uno de los nodos del diagrama de Trellis sólo es necesario guardar el mejor camino (secuencia) hasta ese nodo. De esta forma, como mucho se tendrán tantos caminos como estados diferentes (el número de estados es km ⋅−⋅ )1(2 ).


142

Descripción del Algoritmo de Viterbi: Paso 1: en el nivel j, calcular la distancia de Hamming de cada camino entrante

en cada nodo (estado) desde el nodo del nivel j-1 hasta el nodo del nivel j a través del camino superviviente.

Paso 2: para cada nodo (estado) del diagrama de Trellis en el nivel j, descartar

todos los caminos que entran en el nodo, excepto el de distancia mínima.Cuando a un nodo llegan dos caminos con la misma distancia se toma el superior.

Paso 3: pasar al nivel j+1 y repetir los pasos 1 y 2.

Estos pasos se aplican para j mayor o igual que 2. Hasta ese valor se expanden los caminos.

143

Apéndice C Codigo MATLAB del interfaz gráfico A continuación se presenta el código MATLAB completo del archivo demoCOFDM.m para aquellos que estén interesados en conocer detalles concretos o deseen ejecutarlo: function varargout = demoCOFDM(varargin) % DEMOCOFDM M-file for demoCOFDM.fig % DEMOCOFDM, by itself, creates a new DEMOCOFDM or raises the existing % singleton*. % % H = DEMOCOFDM returns the handle to a new DEMOCOFDM or the handle to % the existing singleton*. % % DEMOCOFDM('CALLBACK',hObject,eventData,handles,...) calls the local % function named CALLBACK in DEMOCOFDM.M with the given input arguments. % % DEMOCOFDM('Property','Value',...) creates a new DEMOCOFDM or raises the % existing singleton*. Starting from the left, property value pairs are % applied to the GUI before demoCOFDM_OpeningFunction gets called. An % unrecognized property name or invalid value makes property application % stop. All inputs are passed to demoCOFDM_OpeningFcn via varargin. % % *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one % instance to run (singleton)". % % See also: GUIDE, GUIDATA, GUIHANDLES % Edit the above text to modify the response to help demoCOFDM % Last Modified by GUIDE v2.5 09-Sep-2003 23:13:33 % Begin initialization code - DO NOT EDIT gui_Singleton = 1; gui_State = struct(‘gui_Name’, mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @demoCOFDM_OpeningFcn, ... 'gui_OutputFcn', @demoCOFDM_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin & isstr(varargin{1}) gui_State.gui_Callback = str2func(varargin{1}); end if nargout [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:}); else gui_mainfcn(gui_State, varargin{:}); end % End initialization code - DO NOT EDIT % --- Executes just before demoCOFDM is made visible. function demoCOFDM_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure

Código MATLAB del interfaz gráfico

144

% eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to demoCOFDM (see VARARGIN) % Choose default command line output for demoCOFDM handles.output = hObject; set(handles.BotonDatos,'Enable','off'); set(handles.BotonEspectro,'Enable','off'); set(handles.BotonConstelacion,'Enable','off'); set(handles.TextoTiempo,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); set(handles.TextoSER,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); set(handles.TextoBER,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); set(handles.TextoTasa,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); set(handles.TextoTiempo,'Enable','inactive'); set(handles.TextoTasa,'Enable','inactive'); set(handles.TextoBER,'Enable','inactive'); set(handles.TextoSER,'Enable','inactive'); set(handles.EjeH1,'Visible','on'); set(handles.EjeH2,'Visible','on'); set(handles.EjeV1,'Visible','off'); set(handles.EjeV2,'Visible','off'); ActivaSecuencia(handles); % Update handles structure guidata(hObject, handles); % UIWAIT makes demoCOFDM wait for user response (see UIRESUME) % uiwait(handles.figure1); % --- Outputs from this function are returned to the command line. function varargout = demoCOFDM_OutputFcn(hObject, eventdata, handles) % varargout cell array for returning output args (see VARARGOUT); % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Get default command line output from handles structure varargout{1} = handles.output; % --- Executes on button press in BotonSimular. function BotonSimular_Callback(hObject, eventdata, handles) % hObject handle to BotonSimular (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) imag = get(handles.RadioImagen,'Value'); MensajeDepuracion(handles, ['imag = ' num2str(imag)]); imagen = get(handles.TextoImagen,'String'); MensajeDepuracion(handles, ['imagen = "' imagen '"']); NumTramas = str2double(get(handles.TextoTramas,'String')); MensajeDepuracion(handles, ['NumTramas = ' num2str(NumTramas)]); contents = get(handles.ListaBDT,'String'); BDT = str2double(contents{get(handles.ListaBDT,'Value')});


145

MensajeDepuracion(handles, ['BDT = ' num2str(BDT)]); contents = get(handles.ListaMuestreo,'String'); AUDIOfrec = str2double(contents{get(handles.ListaMuestreo,'Value')}); MensajeDepuracion(handles, ['AUDIOfrec = ' num2str(AUDIOfrec)]); val = get(handles.ListaRS, 'Value'); RSkL = [ 188 3 ]; RSnL = [ 204 7 ]; RSk = RSkL(val); RSn = RSnL(val); MensajeDepuracion(handles, ['RS = ' num2str(RSn) ',' num2str(RSk)]); val = get(handles.ListaCC,'Value'); CCkL = [ 1 2 3 5 7 ]; CCnL = [ 2 3 4 6 8 ]; CCk = CCkL(val); CCn = CCnL(val); MensajeDepuracion(handles, ['CC = ' num2str(CCn) ',' num2str(CCk)]); contents = get(handles.ListaGuarda,'String'); GUAint = str2num(contents{get(handles.ListaGuarda,'Value')}); MensajeDepuracion(handles, ['GUAint = ' num2str(GUAint)]); contents = get(handles.ListaQAM,'String'); QAMm = str2num(contents{get(handles.ListaQAM,'Value')}); MensajeDepuracion(handles, ['QAMm = ' num2str(QAMm)]); ESPbanda = str2double(get(handles.TextoBandas,'String')); MensajeDepuracion(handles, ['ESPBanda = ' num2str(ESPbanda)]); ESPginf = str2double(get(handles.TextoGInf,'String')); MensajeDepuracion(handles, ['ESPGinf = ' num2str(ESPginf)]); ESPgsup = str2double(get(handles.TextoGSup,'String')); MensajeDepuracion(handles, ['ESPGsup = ' num2str(ESPgsup)]); set(handles.BotonSimular,'Enable','off'); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % Llamar al simulador %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %imag=0; %imagen = 'vente.gif'; %NumTramas=1; %RSk=188; %RSn=204; %CCk=7; %CCn=8; %QAMm=6; %ESPbanda=100; %ESPginf=1; %ESPgsup=21; %GUAint=1/32; %AUDIOfrec = 48000; [ Tiempo TasaNeta BER SER esImagen DatosTX DatosRX EspectroTX EspectroRX ConstelacionTX ConstelacionRX ] = principal_(imag,imagen,NumTramas,RSn,RSk,CCk,CCn,QAMm,ESPbanda,ESPginf,ESPgsup,GUAint,AUDIOfrec); %%%%%%%%%%%%%%%%%%%%%%%%%% set(handles.BotonSimular,'Enable','on'); set(handles.TextoTiempo,'String',num2str(Tiempo)); set(handles.TextoTasa,'String',num2str(TasaNeta)); set(handles.TextoBER,'String',num2str(BER)); set(handles.TextoSER,'String',num2str(SER));


146

handles.esImagen = esImagen; handles.DatosTX = DatosTX; handles.DatosRX = DatosRX; handles.EspectroTX = EspectroTX; handles.EspectroRX = EspectroRX; handles.ConstelacionTX = ConstelacionTX; handles.ConstelacionRX = ConstelacionRX; % handles.AUDIOfrec = AUDIOfrec; set(handles.BotonDatos,'Enable','on'); set(handles.BotonEspectro,'Enable','on'); set(handles.BotonConstelacion,'Enable','on'); %Pinta los datos BotonDatos_Callback(hObject, eventdata, handles); % Update handles structure guidata(hObject, handles); % --- Executes on button press in pushbutton2. function pushbutton2_Callback(hObject, eventdata, handles) % hObject handle to pushbutton2 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % --- Executes on button press in BotonSalir. function BotonSalir_Callback(hObject, eventdata, handles) % hObject handle to BotonSalir (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) close(demoCOFDM); % --- Executes on button press in RadioSecuencia. function RadioSecuencia_Callback(hObject, eventdata, handles) % hObject handle to RadioSecuencia (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) ActivaSecuencia(handles); % Hint: get(hObject,'Value') returns toggle state of RadioSecuencia % --- Executes on button press in RadioImagen. function RadioImagen_Callback(hObject, eventdata, handles) % hObject handle to RadioImagen (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hint: get(hObject,'Value') returns toggle state of RadioImagen ActivaImagen(handles); % --- Executes during object creation, after setting all properties. function TextoImagen_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoImagen (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc


147

set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function TextoImagen_Callback(hObject, eventdata, handles) % hObject handle to TextoImagen (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of TextoImagen as text %str2double(get(hObject,'String')) returns contents of TextoImagen as a double % --- Executes during object creation, after setting all properties. function TextoTram_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoTramas (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject, 'BackgroundColor','white'); else set(hObject, 'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function TextoTram_Callback(hObject, eventdata, handles) % hObject handle to TextoTramas (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of TextoTramas as text %str2double(get(hObject,'String')) returns contents of TextoTramas as a double % --- Executes during object creation, after setting all properties. function edit3_CreateFcn(hObject, eventdata, handles) % hObject handle to edit3 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject, 'BackgroundColor','white'); else set(hObject, 'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function edit3_Callback(hObject, eventdata, handles) % hObject handle to edit3 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit3 as text % str2double(get(hObject,'String')) returns contents of edit3 as a double % --- Executes during object creation, after setting all properties. function ListaMuestreo_CreateFcn(hObject, eventdata, handles)


148

% hObject handle to ListaMuestreo (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject, 'BackgroundColor','white'); else set(hObject, 'BackgroundColor'get(0, 'defaultUicontrolBackgroundColor')); end % --- Executes on selection change in ListaMuestreo. function ListaMuestreo_Callback(hObject, eventdata, handles) % hObject handle to ListaMuestreo (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: contents = get(hObject,'String') returns ListaMuestreo contents as %cell array % contents{get(hObject,'Value')} returns selected item from ListaMuestreo % --- Executes during object creation, after setting all properties. function ListaRS_CreateFcn(hObject, eventdata, handles) % hObject handle to ListaRS (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject, 'BackgroundColor','white'); else set(hObject, 'BackgroundColor'get(0, 'defaultUicontrolBackgroundColor')); end % --- Executes on selection change in ListaRS. function ListaRS_Callback(hObject, eventdata, handles) % hObject handle to ListaRS (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: contents = get(hObject,'String') returns ListaRS contents as cell %array % contents{get(hObject,'Value')} returns selected item from ListaRS % --- Executes during object creation, after setting all properties. function ListaCC_CreateFcn(hObject, eventdata, handles) % hObject handle to ListaCC (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject, 'BackgroundColor','white'); else set(hObject, 'BackgroundColor'get(0, 'defaultUicontrolBackgroundColor')); end % --- Executes on selection change in ListaCC. function ListaCC_Callback(hObject, eventdata, handles)


149

% hObject handle to ListaCC (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: contents = get(hObject,'String') returns ListaCC contents as cell %array % contents{get(hObject,'Value')} returns selected item from ListaCC % --- Executes during object creation, after setting all properties. function ListaGuarda_CreateFcn(hObject, eventdata, handles) % hObject handle to ListaGuarda (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject, 'BackgroundColor','white'); else set(hObject, 'BackgroundColor'get(0, 'defaultUicontrolBackgroundColor')); end % --- Executes on selection change in ListaGuarda. function ListaGuarda_Callback(hObject, eventdata, handles) % hObject handle to ListaGuarda (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: contents = get(hObject,'String') returns ListaGuarda contents as cell array % contents{get(hObject,'Value')} returns selected item from ListaGuarda % --- Executes during object creation, after setting all properties. function ListaBDT_CreateFcn(hObject, eventdata, handles) % hObject handle to ListaBDT (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject, 'BackgroundColor','white'); else set(hObject, 'BackgroundColor'get(0, 'defaultUicontrolBackgroundColor')); end % --- Executes on selection change in ListaBDT. function ListaBDT_Callback(hObject, eventdata, handles) % hObject handle to ListaBDT (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: contents = get(hObject,'String') returns ListaBDT contents as cell array % contents{get(hObject,'Value')} returns selected item from ListaBDT % --- Executes during object creation, after setting all properties. function TextoBandas_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoBandas (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows.


150

% See ISPC and COMPUTER. if ispc set(hObject, 'BackgroundColor','white'); else set(hObject, 'BackgroundColor'get(0, 'defaultUicontrolBackgroundColor')); end function TextoBandas_Callback(hObject, eventdata, handles) % hObject handle to TextoBandas (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) CompruebaEntero(handles, handles.TextoBandas); % Hints: get(hObject,'String') returns contents of TextoBandas as text %str2double(get(hObject,'String')) returns contents of TextoBandas as a double % --- Executes during object creation, after setting all properties. function TextoGInf_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoGInf (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject, 'BackgroundColor','white'); else set(hObject, 'BackgroundColor'get(0, 'defaultUicontrolBackgroundColor')); end function TextoGInf_Callback(hObject, eventdata, handles) % hObject handle to TextoGInf (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of TextoGInf as text % str2double(get(hObject,'String')) returns contents of TextoGInf as a double CompruebaEntero(handles, handles.TextoGInf); % --- Executes during object creation, after setting all properties. function TextoGSup_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoGSup (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor'get(0, 'defaultUicontrolBackgroundColor')); end function TextoGSup_Callback(hObject, eventdata, handles) % hObject handle to TextoGSup (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)


151

% Hints: get(hObject,'String') returns contents of TextoGSup as text % str2double(get(hObject,'String')) returns contents of TextoGSup as a double CompruebaEntero(handles, handles.TextoGSup); % --- Executes on button press in BotonDatos. function BotonDatos_Callback(hObject, eventdata, handles) % hObject handle to BotonDatos (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) LimpiaPlots(handles); if handles.esImagen, set(handles.EjeH1,'Visible','off'); set(handles.EjeH2,'Visible','off'); set(handles.EjeV1,'Visible','on'); set(handles.EjeV2,'Visible','on'); subplot(handles.EjeV1),imagesc(handles.DatosTX,[0 255]),colormap(gray); subplot(handles.EjeV2),imagesc(handles.DatosRX,[0 255]),colormap(gray); else set(handles.EjeH1,'Visible','on'); set(handles.EjeH2,'Visible','on'); set(handles.EjeV1,'Visible','off'); set(handles.EjeV2,'Visible','off'); subplot(handles.EjeH1),plot(handles.DatosTX,'b'),title('TRAMAS DE DATOS TRANSMITIDAS'),xlabel('Indice Temporal n'),ylabel('Valor'); subplot(handles.EjeH2),plot(handles.DatosRX,'r'),title('TRAMAS DE DATOS RECIBIDAS'),xlabel('Indice Temporal n'),ylabel('Valor'); end % --- Executes on button press in BotonEspectro. function BotonEspectro_Callback(hObject, eventdata, handles) % hObject handle to BotonEspectro (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) set(handles.EjeH1,'Visible','on'); set(handles.EjeH2,'Visible','on'); set(handles.EjeV1,'Visible','off'); set(handles.EjeV2,'Visible','off'); LimpiaPlots(handles); f = 0:handles.AUDIOfrec/(length(handles.EspectroTX)-1)/2:handles.AUDIOfrec/2; subplot(handles.EjeH1),plot(f,handles.EspectroTX,'b'),title('ESPECTRO TRANSMITIDO'),xlabel('Frecuencia (Hz)'),ylabel('Magnitud (dB)'); subplot(handles.EjeH2),plot(f,handles.EspectroRX,'r'),title('ESPECTRO RECIBIDO'),xlabel('Frecuencia (Hz)'),ylabel('Magnitud (dB)'); % --- Executes on button press in BotonConstelacion. function BotonConstelacion_Callback(hObject, eventdata, handles) % hObject handle to BotonConstelacion (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) set(handles.EjeH1,'Visible','off'); set(handles.EjeH2,'Visible','off'); set(handles.EjeV1,'Visible','on'); set(handles.EjeV2,'Visible','on'); LimpiaPlots(handles);


152

subplot(handles.EjeV1),plot(handles.ConstelacionTX,'.b'),title('CONSTELACION TRANSMITIDA'),xlabel('Eje fase I'),ylabel('Eje cuadratura Q'); axis square; axis equal; grid on; subplot(handles.EjeV2),plot(handles.ConstelacionRX,'.r'),title('CONSTELACION RECIBIDA'),xlabel('Eje fase I'),ylabel('Eje cuadratura Q'); axis square; axis equal; grid on; % --- Executes during object creation, after setting all properties. function edit7_CreateFcn(hObject, eventdata, handles) % hObject handle to edit7 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function edit7_Callback(hObject, eventdata, handles) % hObject handle to edit7 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of edit7 as text % str2double(get(hObject,'String')) returns contents of edit7 as a double % --- Executes during object creation, after setting all properties. function TextoTiempo_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoTiempo (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function TextoTiempo_Callback(hObject, eventdata, handles) % hObject handle to TextoTiempo (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,’String’) returns contents of TextoTiempo as text %str2double(get(hObject,’String’)) returns contents of TextoTiempo as a double % --- Executes during object creation, after setting all properties. function TextoSER_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoSER (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB


153

% handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function TextoSER_Callback(hObject, eventdata, handles) % hObject handle to TextoSER (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of TextoSER as text % str2double(get(hObject,'String')) returns contents of TextoSER as a double % --- Executes during object creation, after setting all properties. function TextoBER_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoBER (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function TextoBER_Callback(hObject, eventdata, handles) % hObject handle to TextoBER (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of TextoBER as text % str2double(get(hObject,'String')) returns contents of TextoBER as a double % --- Executes during object creation, after setting all properties. function ListaQAM_CreateFcn(hObject, eventdata, handles) % hObject handle to ListaQAM (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end % --- Executes on selection change in ListaQAM. function ListaQAM_Callback(hObject, eventdata, handles) % hObject handle to ListaQAM (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA)


154

% Hints: contents = get(hObject,'String') returns ListaQAM contents as cell %array % contents{get(hObject,'Value')} returns selected item from ListaQAM % --- Executes during object creation, after setting all properties. function TextoTramas_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoTramas (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function TextoTramas_Callback(hObject, eventdata, handles) % hObject handle to TextoTramas (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of TextoTramas as text %str2double(get(hObject,'String')) returns contents of TextoTramas as a double CompruebaEntero(handles, handles.TextoTramas); % --- If Enable == 'on', executes on mouse press in 5 pixel border. % --- Otherwise, executes on mouse press in 5 pixel border or over %RadioSecuencia. function RadioSecuencia_ButtonDownFcn(hObject, eventdata, handles) % hObject handle to RadioSecuencia (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) disp('Radio'); function ActivaSecuencia(handles) set(handles.TextoTramas,'BackgroundColor','white'); set(handles.TextoImagen,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); set(handles.TextoTramas,'Enable','on'); set(handles.TextoImagen,'Enable','off'); ' set(handles.RadioSecuencia,'Value',1); set(handles.RadioImagen,'Value',0); function ActivaImagen(handles) set(handles.TextoTramas,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); set(handles.TextoImagen,'BackgroundColor','white'); set(handles.TextoImagen,'Enable','on'); set(handles.TextoTramas,'Enable','off'); set(handles.RadioSecuencia,'Value',0); set(handles.RadioImagen,'Value',1); function MensajeDepuracion(handles, mensaje) %mensaje = [ get(handles.Mensajes,'String') mensaje 13 ];


155

%set(handles.Mensajes,'String',mensaje); % --- Executes during object creation, after setting all properties. function edit11_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoTiempo (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function edit11_Callback(hObject, eventdata, handles) % hObject handle to TextoTiempo (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of TextoTiempo as text %str2double(get(hObject,'String')) returns contents of TextoTiempo as a double % --- Executes during object creation, after setting all properties. function TextoTasa_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoTasa (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function TextoTasa_Callback(hObject, eventdata, handles) % hObject handle to TextoTasa (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of TextoTasa as text % str2double(get(hObject,'String')) returns contents of TextoTasa as a double % --- Executes during object creation, after setting all properties. function edit13_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoBER (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function edit13_Callback(hObject, eventdata, handles)


156

% hObject handle to TextoBER (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of TextoBER as text % str2double(get(hObject,'String')) returns contents of TextoBER as a double % --- Executes during object creation, after setting all properties. function edit14_CreateFcn(hObject, eventdata, handles) % hObject handle to TextoSER (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles empty - handles not created until after all CreateFcns called % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end function edit14_Callback(hObject, eventdata, handles) % hObject handle to TextoSER (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % Hints: get(hObject,'String') returns contents of TextoSER as text % str2double(get(hObject,'String')) returns contents of TextoSER as a double function CompruebaNumero(texto) val = str2double(get(texto,'String')); if isnan(val), set(texto,'String',''); errordlg('Los parametros tienen que ser numeros',''); end function CompruebaEntero(handles, texto) val = str2double(get(texto,'String')); if isnan(val), set(texto,'String',''); errordlg('Los parametros tienen que ser numeros'); return; end MensajeDepuracion(handles, ['val = ' num2str(val)]); if floor(val) ~= ceil(val), set(texto,'String',''); errordlg('Los parametros tienen que ser enteros'); end function LimpiaPlots(handles) handlePlot=get(handles.EjeH1,'Children'); if length(handlePlot)==1, delete(handlePlot(1)); end handlePlot=get(handles.EjeH2,'Children'); if length(handlePlot)==1, delete(handlePlot(1)); end handlePlot=get(handles.EjeV1,'Children'); if length(handlePlot)==1,


157

delete(handlePlot(1)); end handlePlot=get(handles.EjeV2,'Children'); if length(handlePlot)==1, delete(handlePlot(1)); end

158

Referencias

[1] Timing Synchronization of the WIND-FLEX OFDM prototype. http://www.vtt.fi/ele/research/els/projects/windflexdocs/ist2002_synch_mpl.pdf

[2] The suitability of OFDM as a modulation technique for wireless

telecommunications, with a CDMA comparison. http://www.skydsp.com/resources/OFDM_thesis_lawrey.PDF

[3] Sistemas de difusión.

http://wgpi.tsc.uvigo.es/libro/difusion/difusion.htm [4] Cuaderno Técnico nº 6. Parte 1: Introducción al COFDM.

http://www.canal9-mendoza.com.ar/CuadernoT6_1.htm [5] Explaining some of the magic of COFDM.

http://www.bbc.co.uk/rd/pubs/papers/paper_15/paper_15.html

[6] Codificación por bloques. http://prof.usb.ve/tperez/docencia/3413/contenido/codifico/codifico.htm

[7] Seccion 2.Códigos convolucionales.

http://trabajospracticos.4mg.com/cod/secc2.htm [8] Design and implementation of OFDM signaling.

http://cegt201.bradley.edu/projects/proj2001/ofdmabsh/Research_Proj_Description.pdf

[9] Apuntes de Sistemas de Radiodifusión Digital.

http://www.grc.ssr.upm.es/docencia/RDCM/normativa/normativa_rdcm03.pdf

[10] J. Proakis. Digital communications. Prentice-Hall, 3ª edición, 1995. [11] W.D. Warner y C. Leung. OFDM/FM frame syncronization for mobile radio

data communication. Agosto 1993. [12] P.J. Tourtier, R. Monnier y P. López. Multicarrier modem for digital HDTV

terrestrial broadcasting. Diciembre 1993. [13] J.-J. Van de Beek, M. Sandell y P.O. Börjesson. ML estimation of timing and

frequency offset in multicarrier systems. Research Report 1996-99, Division of Signal Processing. Lulea University of Technology, 1996.

Referencias

159

[14] J.-J. Van de Beek, M. Sandell y P.O. Börjesson. Timing and frequency synchronization in OFDM systems using the cyclic prefix. Diciembre 1995.

[15] J.-J. Van de Beek, M. Sandell, M. Isaksson y P.O. Börjesson. Low complex

frame synchronization in OFDM systems. Noviembre 1995. [16] T. Pollet y M. Moeneclaey. Synchronizability of OFDM signals. Noviembre

1995.

[17] T. Pollet, M. Van Bladel y M. Moeneclaey. BER sensitivity of OFDM systems to carrier frequency offset and Wiener phase noise. Febrero-Abril 1995.

[18] T. Pollet, P. Spruyt y M. Moeneclaey. The BER performance of OFDM

systems using non-synchronized sampling. Noviembre 1995.

[19] P. Moose. A technique for orthogonal frequency-division multiplexing frequency offset correction. Octubre 1994.

[20] L. Wei y C. Schlegel. Synchronization requirements for multi-user OFDM on

satellite mobile and two-path Rayleigh-fading channels. Febrero-Abril 1995.

[21] F. Classen y H. Meyr. Frequency synchronization algorithms for OFDM systems suitable for communication over frequency-selective fading channels. Junio 1994.

[22] F. Daffara y O. Adami. A new frequency detector for orthogonal multicarrier

transmission techniques. Julio 1995.

[23] F. Daffara y A. Chouly. Maximum-likelihood frequency detectors for orthogonal multicarrier systmes. Mayo 1993.

[24] K. W. Kang, J. Ann y H. S. Lee. Decision-directed maximum-likelihood

estimation of OFDM frame synchronization offset. Diciembre 1994.

Documents

106929435 Diseno y Realizacion de Un Modulador Demodulador COFDM Sobre SoundBlaster Copia