Ejemplos Jercicios de Comunicaciones en Matlab

APOYOS DIDACTICOS PARA LA CLASE DE COMUNICACIONES

CON MATLAB

por

Sandra Ivonne Lara Sotelo

Presentado a la academia de Sistemas Digitales y Comunicaciones

del Instituto de Ingeniería y Tecnología de

La Universidad Autónoma de Ciudad Juárez

para su evaluación

LA UNIVERSIDAD AUTÓNOMA DE CIUDAD JUÁREZ

Marzo del 2010

Mtra. Alejandra Mendoza Presidente de la academia

___________________________________________

Dr. Víctor Manuel Hinostroza Zubia Asesor

___________________________________________

Sandra Ivonne Lara Sotelo Alumno

___________________________________________

Justificación de la investigación:

Hasta ahora los métodos que se han utilizado para facilitar el aprendizaje de los alumnos en

las clases de comunicaciones han sido simples. Actualmente la información que se tiene

acerca del área de comunicaciones se imparte mediante un glosario definido, y para

esclarecer las definiciones de estas materias los recursos son insuficientes. En esta

investigación se da una breve información acerca de programas que pueden ser utilizados

por el profesor en las clases de comunicaciones. Todo esto con el fin de que los alumnos

tengan una clara idea de muchos de los conceptos en las clases.

La habilidad para usar herramientas tales como Matlab se convirtió rápidamente en un

requisito para muchas actividades de Ingeniería. Este software es muy sencillo de utilizar y

tiene muchas aplicaciones. Además cuenta con muchas librerías y herramientas que son

útiles a la hora de resolver problemas matemáticos. Los profesores de comunicaciones

impartirían su clase de manera más interpretativa para los alumnos con programas en donde

pudieran simular cada uno de los conceptos de comunicaciones. Estos programas pueden

emplearse no sólo para reforzar y visualizar conceptos de comunicaciones, sino también

para resolver problemas y para el diseño avanzado [1].

Antecedentes:

Hasta hace poco, la mayoría de los usuarios de Matlab eran personas que tenían

conocimientos previos sobre lenguajes de programación como Fortran o C, y que

decidieron cambiarse a Matlab una vez que este software se hizo suficientemente popular

[2]. En los últimos años, sin embargo, Matlab se enseña como el primer lenguaje, sobre

todo si se trata de clases en donde se manejan conceptos de comunicaciones. Las clases de

comunicaciones que se imparten en la universidad son: Comunicaciones I, Comunicaciones

II y Comunicaciones Digitales. En estas clases se ha utilizado Matlab para graficar señales

y hacer operaciones sencillas con ellas con el objetivo de identificar claramente como es la

señal. Un ejemplo es el sumar dos señales y ver cuál es la señal resultante. En algunos

programas se inicializa una frecuencia y una fase para luego introducirlas a una señal y

percibirla en una gráfica. Pero más allá de esos programas sencillos, los demás conceptos

de estas clases hasta ahora se explican en el pizarrón.

Existen muchas funciones o programas que nos ayudan en el conocimiento de las

comunicaciones. En Matlab los comandos para realizar operaciones son muy sencillos, solo

hay que poner el nombre del comando con sus respectivas entradas para que arroje un

resultado. Por ejemplo, para realizar la correlación de dos señales solamente hay que

introducir la función xcorr (x, y) y asignarla a una variable. También existen otras

funciones como la de la convolución, Transformada de Fourier, Transformada de Laplace,

etc.

Planteamiento del problema:

Los profesores que imparten las materias de comunicaciones, en la mayoría de los casos

cuando realizan gráficas u operaciones lo hacen en el pizarrón, esta por demás decir que

esta manera la más explícita para los alumnos. Esto se debe a que los trazos no son exactos,

la precisión del profesor para dibujar no es buena, la gráfica es muy difícil de dibujar, el

espacio para dibujar la gráfica no es suficiente, etc. Es por eso que en muchas ocasiones

los profesores recurren a medios electrónicos para impartir su clase.

Matlab es el recurso más importante que utilizan los profesores de las clases de

comunicaciones de la UACJ para resolver problemas. Pero cuando se utiliza Matlab se

hacen operaciones muy sencillas, como por ejemplo la graficación de una señal dada.

Cuando el profesor imparte su clase se apoya de un proyector para plasmar sus

conocimientos a sus alumnos. Este medio es efectivo ya que se muestra la señal graficada

de una manera muy precisa; La señal es clara debido a que la imagen es obtenida de algún

programa de computadora; sin embargo, se necesitan programas en los que se vea cómo se

va formando dicha señal dependiendo del concepto de comunicaciones que se esté

enseñando.

Marco teórico:

Matlab es una de las muchas sofisticadas herramientas de computación disponibles en el

comercio para resolver problemas de matemáticas. Sus aplicaciones comprenden la

mayoría de las áreas de ciencia e ingeniería [3]. Matlab es una abreviatura de Matrix

Laboratory, laboratorio matricial. En muchas clases de ingeniería, la realización de cálculos

con un programa de computación matemático como Matlab sustituye la programación de

computadoras más tradicional. Matlab se escribió originalmente en Fortran y después se

reescribió en C. Matlab es un instrumento muy útil al trabajar con matrices y gráficos.

Brinda una eficiente base de cálculo para un “laboratorio de sotware” donde se exploran los

conceptos y se prueban los diseños de sistemas [4].

Para realizar un programa en Matlab los pasos son los siguientes:

1. Plantear el problema. Se tiene que tener una idea clara de que es lo que se quiere.

2. Describir las entradas y salidas. Se debe saber cuáles son los datos de los que

queremos partir y su relación con las salidas y también las constantes que requiera

el cálculo. Además es importante manejar bien las unidades que se van a utilizar.

3. Desarrollar algoritmo. Tener un algoritmo ayuda a aclarar y ordenar las ecuaciones

que se utilizaran y cada uno de los pasos que se llevarán a cabo, luego reflejarlo en

Matlab.

4. Resolver el problema. Este paso implica encontrar la solución al problema.

5. Probar la solución. Comparar los resultados obtenidos con los que se esperaban.

El lenguaje que Matlab utiliza es de alto nivel. Cuenta con comandos de visualización en

2D y 3D así como numerosas instrucciones, funciones y librerías. Matlab crea archivos

para manipulación con extensión .m, archivos para interfaz gráfica del usuario .gui,

archivos gráficos .fig, además el usuario puede crear sus variables y funciones. El Simulink

es una parte de Matlab que nos sirve para simular Sistemas Dinámicos No Lineales. Este

simulador tiene Blocksets, que sirven para poder trabajar con procesamiento de señales y

comunicaciones. El conjunto de herramientas para procesamiento de señales de Matlab

tiene una gran variedad de funciones para generar señales, la mayor parte de las cuales

requieren representación vectorial del tiempo t o n.

Objetivo general:

Desarrollar e implementar materiales de apoyo didáctico en Matlab para las clases de

comunicaciones.

Metodología

Objetivos específicos:

1 Investigar bibliográfica sobre los temas de la clase de comunicaciones digitales

2 Practicar programación en Matlab

3 Realizar análisis de los programas que se van a implementar

4 Desarrollar algoritmos para los programas

5 Realizar los programas para cada una de las clases

6 Probar los programas en clase

7 Documentar el proyecto

Metas:

1.1 Investigar un mínimo de 8 fuentes bibliográficas de y 8 fuentes electrónicas

de información acerca de los temas de comunicaciones para el 20 de agosto.

2.1 Investigar por lo menos 3 manuales de Matlab en fuentes bibliográficas y

electrónicas para el 20 de agosto.

3.1 Plantear los problemas basados en los temas de comunicaciones para los

cuales se va a programar para el 27 de agosto.

4.1 Desarrollar algoritmos de todos los programas de comunicaciones para el 10

de septiembre.

5.1 Realizar los diagramas de flujo basados en los algoritmos para el 17 de

septiembre.

7.1 Programar, verificar y depurar los problemas para el 5 de noviembre.

7.1 Documentar el proyecto para el 19 de noviembre.

Acciones:

Meta 1.1

1.1.1 Investigar en Internet, revistas y libros

1.1.2 Investigar en biblioteca UACJ/ UTEP

Meta 2.1

2.1.1 Investigar en Internet, libros y manuales

2.1.2 Investigar en biblioteca UACJ/UTEP

Meta 3.1

3.1.1 Definir cuáles van a ser los temas a programar

3.1.2 Definir datos de entrada y salida

Meta 4.1

4.1.1 Investigar en internet y libros

4.1.2 Investigar en biblioteca UACJ/UTEP

4.1.3 Diseñar el algoritmo para cada uno de los programas

Meta 5.1

5.1.1 Diseñar los diagramas de flujo basados en los algoritmos

Meta 6.1

7.1.1 Escribir el código de los programas

7.1.2 Depurar los programas

7.1.3 Correr los programas y verificar resultados

Meta 7.1

7.1.1. Acudir con el asesor para la revisión de los programas

7.1.2. Documentar la información y resultados obtenidos del proyecto

Requerimientos:

Meta 1.1

• Computadora con Internet

• Acceso a UACJ/UTEP

• Apuntes de clases de comunicaciones

Meta 2.1



Meta 3.1

• Anotaciones (libreta y lápiz)

• Computadora

Meta 4.1




Meta 5.1

• Computadora


Meta 6.1

• Computadora


• Software Matlab 7.0

Meta 7.1


• Impresora

Plan de trabajo:

A continuación se muestra un cronograma con las actividades a realizar antes mencionadas:

Cronograma de acciones Agosto Septiembre Octubre Noviembre Diciembre

Acciones Semana Semana Semana Semana Semana Numero 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4

Acción 1.1.1 Acción 1.1.2 Acción 2.1.1 Acción 2.1.2 Acción 3.1.1 Acción 3.1.2 Acción 4.1.1 Acción 4.1.2 Acción 4.1.3

Acción 5.1.1 Acción 6.1.1 Acción 6.1.2 Acción 6.1.3 Acción 7.1.1 Acción 7.1.2

Referencias:

[1] Ashok Ambardar. Procesamiento de Senales analógicas y digitales. Thomson. 2002.

[2] Amos Gilat. Matlab una introducción con ejemplos prácticos. Reverté. 2005

[3] http://mat21.etsii.upm.es/ayudainf/aprendainf/Matlab70/matlab70primero.pdf, 26 febrero.

[4] Simon Haykin, BarryVan Veen. Señales y Sistemas. Limusa wiley. 2004.

AYUDAS DIDÁCTICAS DE LAS CLASES DE COMUNICACIONES EN MATLAB

Por


Presentado a la Academia de Sistemas Digitales y Comunicaciones

Del Instituto de Ingeniería y Tecnología de

La Universidad Autónoma de Ciudad Juárez

Para obtener el título de

INGENIERO EN SISTEMAS DIGITALES Y COMUNICACIONES

UNIVERSIDAD AUTÓNOMA DE CIUDAD JUÁREZ

Noviembre del 2010

I

UNIVERSIDAD AUTÓNOMA DE CIUDAD JUÁREZ Instituto de Ingeniería y Tecnología

EVALUACiÓN DE EXAMEN Fecha: 26 de Noviembre del 2010 PROFESIONAL INTRACURRICULAR Horario: 09:00 - 11 :00 HRS. NIVEL: LICENCIATURA

TEMA: "Apoyos didácticos para clase de comunicaciones con MATLAB " l La evaluación del examen profesional intracurricular consta de 4 partes: (Desarrollado en 1 hora)

1°._ Exposición por parte de los alumnos (máximo 20 minutos). 2°_ Réplica por parte del jurado. 3°.- Comentarios ylo recomendaciones. 4°._ Entrega de resultados.

Nombre del alumno: Sandra Ivonne Lara Sotelo

Calificación Maestro de la materia (30%) _-"Z",,--1-__

Calificación Director de Trabajo (40%) 3<1

Calificación del Jurado (30%)

TOTAL __0(5

Se recomienda que el documento se deposite para consulta en la BIBLIOTECA SiD NoD

Director de Trabajo Jurado Coordinador de la Materia "Proyecto de Titulación"

r. Viclor Manuel Hinoslrozo Zubia Dr. Viciar Manuel Hinoslrozo Zubia

/

/ a

/'

Oro' Nelly Gordillo Coslíllo •u·e DEP 11 ~ ENTO Dé

INGENIF FLECTRlc y CO, JTA\l r\

FIRMADO EN ORIGINAL

iii

Resumen

Matlab es un programa orientado al cálculo con matrices que tiene muchas

herramientas muy poderosas para trabajar en muchas ramas de la ingeniería. Matlab

se utiliza en este proyecto para hacer ayudas para los alumnos de las clases de

comunicaciones, tales como Comunicaciones I, Comunicaciones II y

Comunicaciones Digitales. Estas ayudas están implementadas en la Interfaz Gráfica

de Usuario (GUI) de Matlab. Los programas se eligieron de acuerdo a los temas que

tienen las clases de comunicaciones, y los que más trabajo cuesta entender a los

alumnos. Los programas son: Serie de Fourier, Transformada de Fourier,

Convolución y Correlación, Decibeles, Muestreo, Muestreo de una Señal PAM,

Modulación AM, FM y PM, Modulación PSK y QAM, Codificación de Bloque

Lineal, Codificación Hamming, Codificación Cíclica y Codificación Convolucional.

Estos programas se implementaron de acuerdo a ejercicios que se realizan en las

clases y a análisis previos de los temas de comunicaciones. Primero se investigaron y

analizaron los temas a implementar, luego se investigaron las posibles funciones de

Matlab que pudieran simplificar los cálculos. Al tener el análisis de parámetros de los

programas, se implementaron en un editor de textos para crear un archivo .m de

Matlab y proceder a realizar la depuración. Al final, dichos programas se

implementaron en la GUI de Matlab y se hicieron pruebas con ejemplos que se

aplican en las distintas clases de comunicaciones.

iv

Declaratoria de Originalidad

Yo Sandra Ivonne Lara Sotelo, declaro que el material contenido en este documento

es original y no ha sido copiado de ninguna otra fuente, ni ha sido usado para obtener

otro título o reconocimiento en ésta u otra institución de educación superior.

__________________________


v

Agradecimientos

A mis padres, por su apoyo. A mi padre por su coraje y palabras fuertes, porque sin

esas palabras yo nunca hubiera tenido el coraje de seguir adelante. A mi madre por su

comprensión, ayuda, cariño, paciencia, porque siempre creyó en mí, por todo. A mis

hermanos, Fabiola y Miguel, por que sin ellos no tendría a las dos personas más

importantes a quienes dar el ejemplo.

A mi familia por apoyarme incondicionalmente. A mi padrino y mi madrina, porque

siempre estuvieron ahí para felicitarme en mis logros, y eso me hacía comprometerme

a seguir adelante y a hacer más para que estuvieran orgullosos de mí. A mi prima

Maribel por su ejemplo, apoyo e interés. A toda mi familia materna por empujarme

con sus ánimos a ser la primer profesionista en la familia.

A mis profesores por su conocimiento y apoyo. A Juan Luna, Jesús Estrada y Valente

Barrón por sus palabras de apoyo y sus consejos, porque desde la preparatoria me

dijeron que sí podía y me dieron el ejemplo, me orientaron para ser lo que soy ahora.

A Víctor Hinostroza por toda su experiencia, sabiduría y consejos.

vi

Lista de Figuras

Figura 2.1 Controles de la GUI ................................................................................... 13

Figura 3.1 Función escalón unitario ............................................................................ 17 Figura 3.2 Función Rampa .......................................................................................... 17 Figura 3.3 Función sinc ............................................................................................... 17

Figura 3.4 Función seno .............................................................................................. 18 Figura 3.5 Función coseno .......................................................................................... 18

Figura 3.6 Función triangular...................................................................................... 18 Figura 3.7 Función diente de sierra ............................................................................. 18 Figura 3.8 Función cuadrática ..................................................................................... 19

Figura 3.9 Transformada de Fourier ........................................................................... 21 Figura 3.10 Modulación de una señal ......................................................................... 25

Figura 3.11 Demodulación de una señal ..................................................................... 25 Figura 3.12 Señal PAM ............................................................................................... 31 Figura 4.1 Tipos de modulación digital ...................................................................... 32

Figura 4.2 Diagramas de constelación de PSK. a) BPSK. b) QPSK........................... 34 Figura 4.3 Diagramas de constelación de QAM. a) 4-QAM. b) 8-QAM. c) 16-QAM.

d) 32-QAM .................................................................................................................. 36 Figura 6.1a Inicialización (Serie de Fourier) ............................................................. 48 Figura 6.1b Elementos del programa (Serie de Fourier) ............................................ 49

Figura 6.1c Ejemplo (Serie de Fourier) ...................................................................... 50 Figura 6.2a Inicialización (Transformada de Fourier) ............................................... 50 Figura 6.2b Elementos del programa (Transformada de Fourier) .............................. 51

Figura 6.2c Ejemplo (Transformada de Fourier) ....................................................... 52 Figura 6.3a Inicialización (Convolución y Correlación) ............................................ 52

Figura 6.3b Elementos del programa (Convolución y Correlación) .......................... 54 Figura 6.3c Ejemplo (Convolución y Correlación) .................................................... 55 Figura 6.4a Inicialización (Modulación AM, FM y PM) ........................................... 56

Figura 6.4b Elementos del programa (Modulación AM, FM y PM) ......................... 57 Figura 6.4c Ejemplo (Modulación AM) ..................................................................... 58

Figura 6.4d Ejemplo (Modulación FM) ..................................................................... 58 Figura 6.4e Ejemplo (Modulación PM) ..................................................................... 58 Figura 6.5a Inicialización (Decibeles y Watts) .......................................................... 59

Figura 6.5b Elementos del programa (Decibeles y Watts) ......................................... 59 Figura 6.5c Ejemplo (Decibeles y Watts) .................................................................. 60

Figura 6.6a Inicialización (Muestreo de señales) ....................................................... 61 Figura 6.6b Elementos del programa (Muestreo de señales) ..................................... 61 Figura 6.6c Ejemplo (Muestreo de señales) ............................................................... 62

Figura 6.7a Inicialización (Muestreo de señal PAM) ................................................ 62 Figura 6.7b Elementos del programa (Muestreo de señal PAM) ............................... 63

Figura 6.7c Ejemplo (Muestreo de señal PAM) ......................................................... 64 Figura 6.8a Inicialización (Modulación digital) ......................................................... 64 Figura 6.8b Elementos del programa (Modulación digital) ....................................... 66

vii

Figura 6.8c Ejemplo (Modulación PSK) .................................................................... 66 Figura 6.8d Ejemplo (Modulación QAM) .................................................................. 67 Figura 6.9a. Inicialización (Codificación de bloque lineal) ....................................... 67

Figura 6.9b. Elementos del programa (Codificación de bloque lineal) ..................... 69 Figura 6.9c. Ejemplo (Codificación de bloque lineal) ............................................... 70

Figura 6.10a. Inicialización (Codificación Hamming) ............................................... 70 Figura 6.10b. Elementos del programa (Codificación Hamming) ............................. 71 Figura 6.10c. Ejemplo (Codificación Hamming) ....................................................... 72

Figura 6.11a. Inicialización (Codificación Cíclica) ................................................... 73 Figura 6.11b. Elementos del programa (Codificación Cíclica) .................................. 74

Figura 6.11c. Ejemplo (Codificación Cíclica) ........................................................... 75 Figura 6.12a. Inicialización (Codificación Convolucional) ....................................... 75 Figura 6.12b. Elementos del programa (Codificación Convolucional) ..................... 76

Figura 6.12c. Ejemplo (Codificación Convolucional) ............................................... 77

viii

Índice

Declaración de originalidad ........................................................................................ VI

Agradecimientos........................................................................................................... V Lista de figuras ............................................................................................................ VI

CAPÍTULO 1. Introducción.......................................................................................... 1 CAPÍTULO 2. Matlab................................................................................................... 2

2.1 Introducción a Matlab ................................................................................. 2

2.2 Comandos básicos ....................................................................................... 5 2.2.1 Operadores Relacionales .............................................................. 6

2.2.2 Operadores Lógicos...................................................................... 6 2.3 Matrices ....................................................................................................... 7 2.4 Definición de funciones .............................................................................. 8

2.5 Interfaz Gráfica de Usuario (GUI) ............................................................ 10 CAPÍTULO 3. Conceptos básicos de comunicaciones ............................................... 15

3.1 Señales y sistemas ..................................................................................... 16 3.2 Serie de Fourier ......................................................................................... 19 3.3 Transformada de Fourier ........................................................................... 20

3.4 Correlación ................................................................................................ 22 3.5 Convolución .............................................................................................. 23

3.6 Modulación y demodulación ..................................................................... 24 3.6.1 Modulación AM ......................................................................... 26 3.6.2 Modulación FM.......................................................................... 27

3.6.3 Modulación PM.......................................................................... 27 3.7 Decibeles ................................................................................................... 28 CAPÍTULO 4. Modulación Digital............................................................................. 30

4.1 Muestreo .................................................................................................... 30 4.2 Modulación por Amplitud de Pulsos (PAM) ............................................ 30

4.3 Tipos de Modulación Digital..................................................................... 32 4.3.1 Modulación PSK ........................................................................ 33 4.3.2 Modulación QAM ...................................................................... 35

CAPÍTULO 5. Codificación para control de errores .................................................. 37 5.1 Fundamentos y definiciones...................................................................... 37

5.2 Códigos de bloque ..................................................................................... 39 5.2.1 Códigos de bloque lineales......................................................... 39 5.2.2 Código Hamming ....................................................................... 42

5.3 Códigos cíclicos ........................................................................................ 45 5.4 Códigos convolucionales........................................................................... 46

CAPÍTULO 6. Resultados........................................................................................... 48 6.1 Serie de Fourier ......................................................................................... 48

6.1.1 Elementos del programa ............................................................. 49

6.1.2 Ejemplo ...................................................................................... 49 6.2 Transformada de Fourier ........................................................................... 50

6.2.1 Funcion fft (x,N) ........................................................................ 51 6.2.2 Elementos del programa ............................................................. 51

ix

6.2.3 Ejemplo ...................................................................................... 52 6.3 Convolución y Correlación de señales ...................................................... 52

6.3.1 Función conv (x, h) .................................................................... 54

6.3.2 Función xcorr (x, h).................................................................... 54 6.3.3 Elementos del programa ............................................................. 54

6.3.4 Ejemplo ...................................................................................... 55 6.4 Modulación AM, FM y PM....................................................................... 56

6.4.1 Función amod (x,fc,fs, 'method')................................................ 56

6.4.2 Elementos del programa ............................................................. 56 6.4.3 Ejemplo de modulación AM ...................................................... 57

6.4.4 Ejemplo de modulación FM ....................................................... 58 6.4.5 Ejemplo de modulación PM ....................................................... 58

6.5 Conversión dB a Watts y Watts a dB ........................................................ 59

6.5.1 Elementos del programa ............................................................. 59 6.5.2 Ejemplo ...................................................................................... 60

6.6 Muestreo de señales .................................................................................. 60 6.6.1 Elementos del programa ............................................................. 61 6.6.2 Ejemplo ...................................................................................... 62

6.7 Muestreo de señal PAM ............................................................................ 62 6.7.1 Elementos del programa ............................................................. 63

6.7.2 Ejemplo ...................................................................................... 64 6.8 Modulación PSK y QAM .......................................................................... 64

6.8.1 Función dmod (x, Fc, Fd, Fs, 'method')...................................... 65

6.8.2 Elementos del programa ............................................................. 65 6.8.3 Ejemplo de modulación PSK ..................................................... 66 6.8.4 Ejemplo de modulación QAM ................................................... 67

6.9 Codificación de Bloque Lineal.................................................................. 67 6.9.1 Función encode (msg, n, k, 'method', genmat) ........................... 68

6.9.2 Elementos del programa ............................................................. 69 6.9.3 Ejemplo ...................................................................................... 69

6.10 Codificación Haming .............................................................................. 70

6.10.1 Elementos del programa ........................................................... 71 6.10.2 Ejemplo .................................................................................... 72

6.11 Codificación Cíclica ................................................................................ 72 6.11.1 Función cyclpoly (n, k, 'opt' ).................................................... 73 6.11.2 Elementos del programa ........................................................... 74

6.11.3 Ejemplo .................................................................................... 74 6.12 Codificación Convolucional.................................................................... 75

6.12.1 Elementos del programa ........................................................... 76 6.12.2 Ejemplo .................................................................................... 76 CAPÍTULO 7. Conclusiones....................................................................................... 78

Referencias .................................................................................................................. 79 APÉNDICE A. Archivo .m: Serie de Fourier ............................................................. 80

APÉNDICE B. Archivo .m: Transformada de Fourier ............................................... 83 APÉNDICE C. Archivo .m: Convolución y Correlación de señales .......................... 84

x

APÉNDICE D. Archivo .m: Modulación AM, FM y PM .......................................... 87 APÉNDICE E. Archivo .m: Conversión dB a Watts y Watts a dB ............................ 89 APÉNDICE F. Archivo .m: Muestreo de señal .......................................................... 90

APÉNDICE G. Archivo .m: Muestreo de señal PAM ................................................ 91 APÉNDICE H. Archivo .m: Modulación PSK y QAM .............................................. 92

APÉNDICE I. Archivo .m: Codificación de Bloque Lineal ....................................... 94 APÉNDICE J. Archivo .m: Codificación Hamming................................................... 97 APÉNDICE K. Archivo .m: Codificación Cíclica .................................................... 101

APÉNDICE L. Archivo .m: Codificación Convolucional ........................................ 103

1

CAPÍTULO 1. Introducción

Existen muchas funciones o programas que nos ayudan en el conocimiento de las

comunicaciones. Matlab es un programa orientado a Matrices. En Matlab los

comandos para realizar operaciones son muy sencillos, solo hay que poner el nombre

del comando con sus respectivas entradas para que arroje un resultado. Existen

muchas funciones para el procesamiento de señales, tales como la de Convolución,

Correlación, Transformada de Fourier, Transformada de Laplace, etc.

Este documento se divide por capítulos según las unidades o módulos impartidos en

las clases de comunicaciones. Primero, se hace un breve análisis sobre el programa

Matlab y sus comandos básicos, así como la Interfaz Gráfica de Usuario, que es una

parte de Matlab en la que se trabajó en este proyecto. Luego se analiza la teoría y

conceptos básicos de modulación análoga. Se revisan los conceptos de señales

eléctricas y sistemas lineales, además de los conceptos de Correlación y Convolución.

Se explican los conceptos de Modulación AM, FM y PM y sus diversas variantes.

La siguiente parte se refiere a una introducción a la modulación digital, empezando

con conceptos básicos de modulación digital tales como Muestreo y Señales PAM.

Enseguida se revisan los conceptos básicos de Modulación Digital, con sus tres

variantes: PSK, FSK y QAM.

Después se ven conceptos básicos referentes a la Codificación para Control de Errores

(codificación de canal), en donde se revisan los diversos códigos más utilizados y sus

características, además se exploran los códigos cíclicos, los códigos de bloque y los

códigos convolucionales.

Al final del documento se muestran y explican los resultados producidos del código en

Matlab.

2

CAPÍTULO 2. Matlab

Hasta hace poco, la mayoría de los usuarios de Matlab eran personas que tenían

conocimientos previos sobre lenguajes de programación como Fortran o C, y que

decidieron cambiarse a Matlab una vez que este software se hizo suficientemente

popular [1]. En los últimos años, sin embargo, Matlab se enseña como el primer

lenguaje, sobre todo si se trata de clases en donde se manejan conceptos de

comunicaciones.

2.1 Introducción a Matlab

MATLAB es un programa interactivo basado en matrices para cálculos c ientíficos y

de ingeniería. Es una abreviatura de Matrix Laboratory, laboratorio matricial. En

muchas clases de ingeniería, la realización de cálculos con un programa de

computación matemático como Matlab sustituye la programación de computadoras

más tradicional. Matlab se escribió originalmente en Fortran y después se rescribió en

C. Originalmente, Matlab fue escrito para simplificar los cálculos con matrices y

álgebra linear. Este software es un instrumento muy útil al trabajar con matrices y

gráficos. Brinda una eficiente base de cálculo para un “laboratorio de software”

donde se exploran los conceptos y se prueban los diseños de sistemas [2].

El lenguaje que Matlab utiliza es de alto nivel. Entre otras cosas integra computación,

visualización y programación en un entorno de fácil utilización donde tanto los

problemas como las soluciones se expresan en una notación matemática familiar [3].

La interacción en Matlab se realiza mediante instrucciones (comandos), funciones y

programas (scripts).

Las herramientas y utilidades de Matlab permiten diversas funcionalidades y están

agrupadas en "paquetes" o cajas de herramientas (toolboxes). Las cajas de

herramientas de Matlab son librerías de funciones que personalizan este software para

resolver clases específicas de problemas. Están escritas en código de Matlab para

poder visualizar los algoritmos fuente y agregar nuevos. La extensa selección de

3

toolboxes de Matlab nos permite comparar técnicas y escoger la apropiada para una

particular aplicación. A Matlab se le pueden añadir paquetes especializados para

algunas tareas.

El sistema de graficación de Matlab incluye una serie de comandos de muy alto nivel

para visualización de imágenes 2D y 3D, animaciones y presentaciones. También

posee comandos de más bajo nivel que permiten personalizar la presentación una

figura. Además permite que el usuario pueda construir una Interfaz Gráfica de

Usuario (GUI). Otra de las herramientas que proporciona, es la de Simulink, que es

una aplicación que permite simular en base a modelos y bloques de sistemas.

Cuando Matlab realiza un cálculo, lo hace usando los valores que conoce al momento

en que el comando que lo solicita es evaluado.

Una función de Matlab tiene nombre, valor de retorno y argumentos. Una función se

llama utilizando su nombre en una expresión o utilizándolo como un comando más.

Las funciones se definen en ficheros de texto *.m. Una característica de Matlab es que

las funciones que no tienen argumentos no llevan paréntesis, por lo que a simple vista

no siempre son fáciles de distinguir de las simples variables. Los nombres de las

funciones de Matlab no son palabras reservadas del lenguaje.

Matlab se compone de cuatro ventanas principales:

Ventana de comandos (Comand Window). Es la ventana sobre la que se introducen

todos los comandos.

Espacio de trabajo (Workspace). Ventana donde aparece información sobre los

elementos que se han creado. Contiene el conjunto de variables y funciones de

usuario que en un determinado momento están definidas en la memoria del programa.

Historial de comandos (Comand History). En esta ventana se pueden ver todos los

comandos introducidos.

4

Directorio Actual (Current Directory). Es el directorio donde están todos los ficheros

*.m de los programas que se ejecutan.

Como cualquier otro lenguaje de computación, Matlab tiene reglas para el nombre de

las variables. La simplicidad de Matlab implica pocas reglas sobre las variables, las

cuales son:

Matlab hace distinción entre mayúsculas y minúsculas.

Las variables pueden contener hasta 31 caracteres.

Las variables deben empezar con un caracter que sea una letra.

Los caracteres de puntuación no son permitidos.

Tipos de archivos

Archivos m: Son archivos de texto ASCII, con la extensión .m que contienen

conjuntos de comandos o definición de funciones, los cuales constituyen el

centro de la programación en Matlab. Estos ficheros se crean y modifican con

cualquier editor de textos.

Existen dos tipos de ficheros .m, los ficheros de comandos (scripts) y las

funciones. Los primeros contienen un conjunto de comandos que se ejecutan

sucesivamente cuando se teclea el nombre del fichero en la línea de comandos

de Matlab. Y las funciones permiten definir funciones totalmente análogas a

las de Matlab, con su nombre, sus argumentos y sus valores de retorno.

Archivos MAT: Son archivos que contienen datos binarios que se guardan

con extensión .mat.

Archivos MEX: Son archivos Matlab ejecutables compilados a partir de

Fortran o C. Se guardan con la extensión .mex.

5

Archivos MDL: Archivos con extensión .mdl. Corresponden a modelos

hechos con Simulink.

Archivos fig: Son archivos .fig que corresponden a la parte grafica de un

programa hecho en la Interfaz Gráfica de Usuario (GUI) de Matlab.

2.2 Comandos básicos

Matlab cuenta con muchos comandos de acuerdo a cada necesidad de usuario,

algunos de los más básicos son:

clear - borra la variables que se hayan usado.

help - muestra la ayuda de las funciones y comandos de Matlab.

who, whos - muestra las variables introducidas con sus valores.

plot - grafica los puntos especificados.

cos - función coseno.

sin - función seno.

square - función cuadrada.

sawtooth - función diente de sierra.

abs - calcula la magnitud de números complejos o el valor absoluto de números

reales.

exp - exponencial: ex.

log - logaritmo natural.

log10 - logaritmo.

rem - residuo de una división.

6

fix - redondea hacia cero.

floor - redondea hacia -∞.

round - redondea hacia el entero más cercano.

num2str(x,n) - convierte un número real x en su expresión por medio de una cadena de

caracteres, con cuatro cifras decimales por defecto (pueden especificarse más cifras,

con un argumento opcional n).

str2double - convierte una cadena de caracteres representando un número real en el

número real correspondiente en formato de punto decimal con doble precisión.

length - calcula la longitud de un vector o matriz.

Todo lo que esta seguido del comando % es interpretado por Matlab como

comentario.

2.2.1 Operadores relacionales

El lenguaje de programación de Matlab dispone de los siguientes operadores

relacionales:

< menor que

> mayor que

<= menor o igual que

>= mayor o igual que

== igual que

~= distinto que

2.2.1 Operadores lógicos

7

Los operadores lógicos de Matlab son los siguientes:

&& and

|| or

~ negación lógica

2.3 Matrices

Matlab está diseñado fundamentalmente para cálculo matricial. En Matlab se trabaja

básicamente con solo un tipo de objeto, una matriz numérica rectangular con posibles

entradas complejas; todas las variables son representadas con matrices. En algunos

casos, matrices de una fila y una columna interpretadas como escalares, o matrices de

una sola fila o una sola columna interpretadas como vectores.

Como la mayoría de las calculadoras científicas, Matlab ofrece muchas importantes

funciones para matemáticas, ingeniería y las ciencias. Además de funciones comunes,

Matlab ofrece cientos de funciones especializadas y algoritmos que son útiles para

resolver problemas específicos.

Como en casi todos los lenguajes de programación, en Matlab las matrices y vectores

son variables que tienen nombres. Para definir una matriz no hace falta establecer de

antemano su tamaño. Matlab determina el número de filas y de columnas en función

del número de elementos que se proporcionan (o se utilizan). Las matrices se definen

por filas; los elementos de una misma fila están separados por blancos o comas,

mientras que las filas están separadas por intro (Enter) o por caracteres punto y coma

(;). Un ejemplo es el siguiente:

A=[1 2 3; 4 5 6; 7 8 9]

A = 1 2 3

4 5 6

8

7 8 9

Matlab dispone de varias formas de definir matrices. El introducirlas por teclado sólo

es práctico en casos de pequeño tamaño y cuando no hay que repetir esa operación

muchas veces. Matlab accede a los elementos de una matriz por medio de los índices

de fila y de columna encerrados entre paréntesis y separados por una coma.

Matlab cuenta con varias funciones y operaciones orientadas a definir con gran

facilidad matrices de tipos particulares.

2.4 Definición de funciones

Las funciones en Matlab son programas que toman las variables que se les pasan

(variables de entrada), luego realiza cálculos y manipulaciones con ellas y devuelve

los resultados (variables de salida). Estas funciones definidas se caracterizan porque la

primera línea comienza por la palabra function, el formato es el siguiente:

function [variables de salida] = nombredefunción(variables de entrada)

Puede haber funciones sin valor de retorno y también sin argumentos. Los argumentos

son los datos de la función y los valores de retorno son sus resultados. Si no hay

valores de retorno se omiten los corchetes y el signo igual (=); si sólo hay un valor de

retorno no hace falta poner corchetes. Tampoco hace falta poner paréntesis si no hay

argumentos.

En Matlab no se modifican los argumentos que recibe en la función, esta es una

diferencia que presenta con C, C++ y Java. Los valores de retorno son los que mandan

los resultados de una función. Estos valores pueden ser múltiples y matriciales. El

número de argumentos y el de valores de retorno puedes ser fijos o no, esto depende

de cómo el usuario llama a la función.

Las variables definidas dentro de una función son variables locales, esto significa que

son inaccesibles desde otras partes del programa y no interfieren con variables del

9

mismo nombre definidas en otras funciones o partes del programa. Estas variables

pertenecen al propio espacio de trabajo de la función y no son vistas desde otros

espacios de trabajo. Para que la función tenga acceso a variables que no han sido

pasadas como argumentos es necesario declarar dichas variables como variables

globales, tanto en el programa principal como en las distintas funciones que deben

acceder a su valor.

Los argumentos que recibe una función de Matlab se copian a variables locales si no

son modificados por dicha función. Esto tiene importantes consecuencias en términos

de eficiencia y ahorro de tiempo de cálculo. Sin embargo, si dentro de la función se

realizan modificaciones sobre los argumentos recibidos, antes se sacan copias de

dichos argumentos a variables locales y se modifican las copias.

Los valores de retorno se calculan dentro de la función, pero en Matlab no hace falta

calcular siempre todos los posibles valores de retorno de la función, sino sólo los que

el usuario espera obtener en la sentencia de llamada a la función. En cualquier función

existen dos variables definidas de modo automático, llamadas nargin y nargout, que

representan respectivamente el número de argumentos y el número de valores de

retorno con los que la función ha sido llamada.

La ejecución de una función termina cuando se llega a su última sentencia ejecutable.

La sentencia return se utiliza para forzar a que una función termine de ejecutarse y

devuelva inmediatamente el control al entorno de llamada.

Matlab dispone de otra forma de pasar a una función un número variable de

argumentos por medio de la variable varargin, que es un vector de celdas (cell array).

Un vector de celdas es un vector cuyos elementos son cada uno de ellos una variable

de cualquier tipo. Esta variable recoge todos los argumentos a partir de una

determinada posición.

De igual forma, una función puede tener un número indeterminado de valores de

retorno utilizando varargout, que es también un vector de celdas que agrupa los

10

últimos valores de retorno de la función.

2.5 Interfaz Gráfica de Usuario (GUI)

Matlab Guide es un entorno de programación visual que ofrece Matlab para poder

realizar y ejecutar programas de simulación, tiene las características básicas de todos

los programas visuales como Visual Basic o Visual C++.

El lenguaje más habitual para crear GUI’s es Java, ya que tiene la enorme ventaja de

funcionar en cualquier máquina, sin embargo Java resulta muy lento para hacer

cálculos eficientemente. En comparación con Java, Matlab es más poderoso al

realizar cálculos grandes.

La GUI consta de dos archivos: uno .m que contiene el código del programa, y otro

.fig que es la parte gráfica. Las dos partes están unidas a través de las subrutinas de

llamada (callback). La cadena de invocación es una cadena que consiste en un

comando, un conjunto de órdenes o una llamada de función. En esta cadena se

especifican todas las tareas de cómputo que deben ejecutarse al elegirse la opción.

No siempre es necesario definir la propiedad callback, ya que algunos objetos no

ejecutan ningún comando de Matlab.

El archivo .m que se crea tiene una estructura predeterminada. Consta de un

encabezado y el código correspondiente a las subrutinas. Este archivo es construido

automáticamente por Matlab y las líneas de código que aparecen son las que crean la

interfaz que aparece en el archivo .fig. El archivo de inicialización define los

parámetros básicos de la interfaz y crea un conjunto de identificadores (handles) para

cada uno de los objetos que vayan apareciendo sobre la interfaz.

Cada uno de los objetos de Matlab tiene un identificador único. Algunos gráficos

tienen muchos objetos, por lo tanto tienen múltiples handles. El objeto raíz (pantalla)

es siempre único y su identificador es el cero. El identificador de las ventanas es un

entero, que aparece en la barra de nombre de dicha ventana. Los identificadores de

11

otros elementos gráficos son números flotantes (float), que pueden ser obtenidos como

valor de retorno y almacenados en variables de Matlab.

El objeto más general de una GUI es la pantalla (screen). Este objeto es la raíz de

todos los demás objetos y sólo puede haber un objeto pantalla. Una pantalla puede

contener una o más ventanas (figures). A su vez cada una de las ventanas puede tener

uno o más ejes de coordenadas (axes). Una ventana puede tener también controles

(uicontrol) tales como botones, barras de desplazamiento, botones de selección o de

opción, etc.) y menús (uimenu). Finalmente, los ejes pueden contener los seis tipos de

elementos gráficos que permite Matlab: líneas (line), rectángulos (rectangle),

polígonos (patches), superficies (surface), imágenes bitmap (image) y texto (text).

Todos los valores de las propiedades de los elementos de Matlab (ej. color, etiqueta,

valor, posición, texto, etc.) y los valores de las variables del programa se guardan en

una estructura, los cuales son accedidos mediante un único y mismo puntero. Una

estructura (struct) es una agrupación de datos de tipo diferente bajo un mismo nombre.

Estos datos se llaman miembros (members) o campos (fields).

En una GUI, el flujo de datos está controlado por las acciones en la interfaz. Los

comandos para crear una interfaz con el usuario se escriben en un guión, la interfaz

invoca el guión que se ejecute, mientras la interfaz del usuario permanece en la

pantalla aunque no se haya completado la ejecución del guión.

Cuando se interactúa con un control, el programa registra el valor de esa opción y

ejecuta los comandos prescritos en la cadena de invocación. Al completarse la

ejecución de las instrucciones de la cadena de invocación, el control vuelve a la

interfaz para que pueda elegirse otra opción del menú. Este ciclo se repite hasta que

se cierra la GUI.

El control guarda un string que describe la acción a realizar cuando se invoca, puede

consistir en un solo comando de Matlab o una secuencia de comandos, o en una

llamada a una función [4].

12

Las Componentes principales de GUIDE son:

Barra de Menús: Es donde se encuentran las funciones elementales de edición

de GUI’s.

Paleta de Componentes: Contiene los controles (uicontrols) que se muestran

en la GUI.

Barra de Herramientas: Es donde se encuentran los siguientes botones:

o Alineación de Componentes (Alignment tool): esta opción permite

alinear los componentes que se encuentra en el área de trabajo (Layout

Area) de manera personalizada.

o Propiedades del Inspector (Property Inspector): Contiene todas las

propiedades de cada objeto en forma personalizada.

o Navegador de Objetos (Object Browser): Muestra todos los objetos

que se encuentran en la figura (en forma de árbol).

o Editor de Menús (Menu Editor): El redactor de Menú crea menús de

ventana y menús de contexto.

o Editor de orden (Tab Order Editor): Es para editar el orden de los

objetos de la GUI.

o Editor de archivos M (M-File Editor): Despliega en pantalla el archivo

.m.

Controles de la GUI

Los controles de la interfaz con el usuario en Matlab se especifican con la orden

uicontrol, y se localizan en la parte izquierda de la pantalla principal de la GUI, son

los siguientes:

13

Figura 1. Controles de la GUI.

Menú desplegable (Popup Menu). Provee una lista de opciones.

Botones (Push Button). Invoca un evento inmediatamente.

Caja de listas (List Box). Muestra una lista deslizable.

Casilla de verificación (Check Box). Están diseñadas para realizar operaciones

de encendido/apagado. Indican el estado de una opción o atributo.

Botón de radio (Radio Button). Indica una opción que puede ser seleccionada.

Cuando sólo se usa un botón de radio, no existe ninguna diferencia funcional

con respecto a una casilla de verificación. Los botones de radio en grupo son

mutuamente exclusivos (es decir, si un botón esta encendido, todos los demás

botones se apagan), mientras que las casillas de verificación son

independientes entre sí.

Texto estático (Static Text). Muestra un string de texto en una caja.

Barra deslizadora (Slider). Usado para representar un rango de valores.

Texto editable (Text Edit). Permite al usuario teclear una cadena de entrada.

14

Panel de botones (Panel Button). Sirve para agrupar dispositivos.

Botón de palanca (Toggle Button). Genera una acción que indica un estado

binario. (encendido o apagado).

Grupo de botones (Button Group) Permite exclusividad de selección con los

radio button.

Active x. Permite crear aplicaciones exportables.

15

CAPÍTULO 3. Conceptos básicos de Comunicaciones.

Los elementos de un sistema de comunicación son:

Fuente de información. La fuente de información puede ser análoga, por ejemplo: voz

o video o puede ser digital, por ejemplo: información binaria proveniente de una

computadora.

Codificación de fuente. La codificación de fuente es un proceso que convierte la

información de la fuente a digital, si esta es análoga y además convierte esta

información binaria a otro código, que requiere menos cantidad de bits por fracción

de información.

Codificación de canal. Esta codificación agrega información redundante a la salida de

la codificación de fuente, para asegurar su integridad, corregir errores y a veces su

seguridad.

Modulador digital. La modulación realizada en esta parte se hace para adecuar la

información (banda base) al medio que se use para su transmisión. (pasa-banda)

Generalmente es una translación de frecuencia o una translación de nivel o ambas.

Canal de comunicación. Medio físico sobre el cual se envía la información de

transmisor a receptor. Este medio puede ser un cable, fibra óptica, el aire o un enlace

satelital.

De-modulador digital. Proceso inverso a la modulación, se hace una translación de

frecuencia de pasa-banda a banda base. La salida del de-modulador es una

aproximación de la información original.

Decodificador de canal. Reconstruye la aproximación de la salida del de-modulador a

la información original del modulador de canal, haciendo uso de la información

redundante agregada en el modulador de canal del transmisor.

Decodificador de fuente. Reconstrucción final de la información original de la fuente.

16

La diferencia entre la versión original de la fuente y la salida del decodificador de la

fuente es una medida de la distorsión del sistema de comunicación.

3.1 Señales y sistemas

Señales. Es una cantidad eléctrica que se define por una función que describe cómo se

desarrolla una variable física en el tiempo. Las señales están definidas por tres

características principales: amplitud, fase y frecuencia. La amplitud es el valor escalar

instantáneo que se indica en unidades, normalmente Volts de la señal. La frecuencia

es un valor que nos indica, asumiendo que una señal es periódica, el número de veces

que el periodo se repite en un intervalo de tiempo, las unidades de frecuencia son

Hertz. La fase es un valor que indica el valor instantáneo de la amplitud dentro del

periodo de la señal.

Clasificación de señales. Una señal puede ser aleatoria o determinística, puede ser

periódica o no periódica, puede ser continua o puede ser discreta. Las señales

aleatorias son en las que hay cierto grado de incertidumbre por su valor de amplitud

en cualquier tiempo. Las señales determinísticas, son aquellas que no hay

incertidumbre con respecto a su valor en cualquier tiempo. Las señales periódicas son

aquellas que sus valores se repiten en un cierto periodo de tiempo. Las señales no

periódicas no repiten sus valores en el tiempo. Las señales discretas son aquellas que

tiene un rango de valores contable y cada uno de estos valores puede ser asignado a un

número real. Las señales continuas tienen un rango de valores infinito y presentan

cambios de valores que se pueden asignar a un número.

Ejemplos de señales:

Función Escalón Unitario. Es una función matemática que tiene como característica el

tener un valor de 0 para todos los valores negativos de su argumento, y de 1 para

todos los valores positivos de su argumento.

17

Función Rampa. Es una señal que cambia constantemente con el tiempo.

Función Sinc. Tiene una singularidad evitable en cero, que generalmente se redefine

específicamente como igual a 1.

Función Seno. Es aquella que asocia a cada ángulo el valor del seno correspondiente.

00

02

1

01

)(

t

t

t

tu

)()(00

0)( ttudu

t

tttramp

t

tsentc

)()(sin

Figura 3.1. Función Escalón

unitario.

Figura 3.2 Función Rampa.

Figura 3.3. Función Sinc.

18

y(t)=Asin(t)

Función Coseno. Aquella que asocia a cada ángulo el valor del coseno

correspondiente.

y(t)=cos(t)

Función Triangular. Presenta unas velocidades de subida y bajada (Slow Rate)

constantes.

y(t)=

Función Diente de Sierra.

Figura 3.4. Función Seno.

Figura 3.5. Función Coseno.

Figura 3.6. Función Triangular.

Figura 3.7. Función Diente de sierra

19

Función Cuadrática.

3.2 Serie de Fourier

La Serie de Fourier sirve para representar señales continuas periódicas por medio de

una serie de componentes senoidales. Constituyen la herramienta matemática básica

del análisis de Fourier empleado para analizar funciones periódicas a través de la

descomposición de dicha función en una suma infinitesimal de funciones senoidales

mucho más simples (como combinación de senos y cosenos con frecuencias enteras)

[5].

El espectro de frecuencia de esta serie muestra las componentes sinusoidales que

forman una señal de tiempo continuo dada. En general, el espectro de frecuencia es

una función compleja de la variable de frecuencia y es usualmente especificada en

términos de un espectro de amplitud y uno de fase. En el caso de señales periódicas, el

espectro de frecuencia de la señal se puede generar mediante la representación de la

señal como una suma de sinusoides, que se conoce como una Serie de Fourier. Esta

denominación se conoce así en honor del físico francés Jean Baptiste Fourier (1768 –

1830). Cabe señalar que también se puede generar una representación del dominio de

la frecuencia de una señal no periódica. Esta representación se define en términos de la

Transformada de Fourier. En contraste con una señal periódica, los espectros de una

señal no periódica consisten en una continuación de frecuencias.

Se busca poner cualquier función x(t) como un sumatoria de senos y cosenos, esto es,

como un sumatoria de puesto que cualquier función senoidal se puede poner

Figura 3.8. Función Cuadrática.

20

en forma de exponencial compleja. Para una señal periódica definimos el desarrollo en

serie de Fourier como:

A la vista de la exponencial compleja podemos observar que al variar los valores de k

tenemos una función periódica con periodo:

Los coeficientes del desarrollo en serie de Fourier son:

Por lo tanto, la Serie de Fourier se define:

3.3 Transformada de Fourier

Una característica clave de la teoría de las Series de Fourier de las señales periódicas

es la definición de los espectros de amplitud y de fase de señales periódicas. Se sabe

que el espectro de amplitud de salida es igual al producto del espectro de amplitud de

la señal periódica de entrada por la función magnitud | H( ) | del sistema, donde

y el espectro de la fase de la salida es igual a la suma del espectro de la fase

de la señal periódica de entrada más la función de la fase L H( ) del sistema.

La Transformada de Fourier se usa para representar una señal no periódica en tiempo

21

continuo como una superposición de señales senoidales complejas [6].

La Transformada de Fourier muestra una secuencia en la que se aumenta el periodo de

una señal periódica.

La Transformada rápida de Fourier es simplemente un algoritmo rápido para la

evaluación numérica de integrales de Fourier y su importancia radica en la rapidez de

cálculo conseguida, importante en otro tipo de aplicaciones: ecualización y filtrado en

equipos de audio/vídeo en tiempo real, comunicaciones, etc.

La diferencia de velocidad de cálculo entre la tradicional Transformada discreta y la

FFT aumenta según aumenta el número de muestras a analizar.

Sea x(t) una función continua por partes en el intervalo [-T,T] para todo T > 0 y tal que

exista, la Transformada de Fourier se define como:

La Transformada F ( ) describe la señal x(t) como una función de la frecuencia

senoidal y se llama la representación de x(t), en el dominio de la frecuencia. Esta

ecuación convierte la señal en el dominio del tiempo, en su representación en el

dominio de la frecuencia.

Figura 3.9. Transformada de Fourier

Amplitud

(Potencia)

Medición en el

dominio del tiempo Medición en el

dominio de la frecuencia

22

Propiedades de la Transformada de Fourier

Tabla 1. Propiedades de la Transformada de Fourier.

Linealidad a(x) + b(y) aX(jω) + bY(jω)

Translación en el tiempo x(t-t0) jXe

tj 0

Translación en la frecuencia txe tj

x(j(ω-ω0))

Conjugación x*(t) X*(-j ω)

Inversión en el tiempo x(-t) X(-j ω)

Cambio de escala en tiempo y

frecuencia x(at)

a

jX

a

1

Convolución x(t)*y(t) X(j ω)Y(j ω)

3.4 Correlación

Una herramienta útil en análisis de señales y sistemas es la Correlación. La

Correlación obtiene la información sobre las señales en base a promedios temporales y

su transformada de Fourier permite obtener funciones de densidad espectral de energía

o potencia, dependiendo de las características de las señales y sistemas bajo estudio.

Las herramientas basadas en Correlación de señales y su Transformada de Fourier, son

usadas en el análisis de procesos.

La Correlación nos da una medida de la similitud entre dos señales. Es comparar las

características de una señal conocida con las de una señal desconocida.

23

Autocorrelación. Es la correlación de una señal consigo misma. Representa la

similitud entre una señal y ella misma desplazada. El máximo de una autocorrelación

se obtiene cuando no hay desplazamiento (t = 0).

La Autocorrelación se usa considerablemente en el análisis de señales. Es

especialmente útil en la detección o reconocimiento de señales enmascaradas por ruido

agregado. La Autocorrelación suele emplearse para encontrar periodos. La fórmula

para realizar la autocorrelación de una señal x(t) es:

La Correlación cruzada implica el cambiar de puesto de una señal y multiplicarse por

otra señal. La Correlación cruzada expresa que tanta similitud tienen dos señales de

tiempo diferentes a(t) y b(t) para diferentes desplazamientos de tiempo.

3.5 Convolución

La Convolución nos ayuda a determinar la respuesta que un sistema ejerce en una

señal de entrada. Cualquier señal puede expresarse como una superposición de

impulsos unitarios de diferentes amplitudes.

Un sistema invariante en el tiempo no cambia su comportamiento con el tiempo,

entonces la respuesta al impulso h(t) a una serie de impulsos desplazados d (t - t) se

puede expresar como h(t - t). Cuando esos impulsos desplazados los afectamos por la

amplitud de una señal f (t) podemos expresar una salida en términos de este impulso

desplazado y la respuesta al impulso del sistema f1(t) [h(t) d (t- t )]= f1(t)h(t- t) =y1(t).

Luego, podemos expresar la salida y (t) en términos de su respuesta al impuso y de su

entrada si integramos todos los puntos de la función, así quedaría definida la “Integral

de la Convolución para sistemas invariantes en el tiempo”.

24

Interpretación gráfica de la convolución.

La interpretación gráfica de la convolución permite visualizar los resultados de las más

abstractas operaciones matemáticas. Supóngase que se quiere hallar la convolución de

dos funciones dadas f 1(t) y f2 (t). Las operaciones que se efectúan se basan en la

integral de la convolución:

Primero se enumeran, paso a paso, las operaciones necesarias:

1. Reemplazar t por en f1 (t), quedando f ( ).

2. Reemplazar t por (- ) en f2 (t). Esto hace girar a la función f2 ( ) alrededor del eje

vertical pasando por el origen del eje.

3. Trasladar todo el sistema de referencia de f (- ) en una cantidad t. Entonces, la

traslación t es la diferencia entre el sistema de referencia móvil y el fijo. El or igen del

sistema móvil esta en = t; el origen fijo, en = 0. La función en el sistema móvil

representa f2 ( t - ); la función en el sistema fijo, f1 ( ).

4. En cualquier desplazamiento relativo entre los ejes de referencia, por ejemplo, t0,

debe hallarse el área bajo el producto de las dos funciones.

5. Este procedimiento debe repetirse para diferentes valores t = t0 desplazando

progresivamente el sistema móvil y hallando los valores de la integral de convolución

en esos valores de t. Para funciones continuas esto puede hacerse por integración

directa. Para funciones continuas por tanto, el producto será continuo por tramos y

deberá integrarse sobre cada sección continua.

6. Si el desplazamiento del sistema móvil es a lo largo del eje negativo (a la

izquierda), t es negativo. Si es sobre el eje positivo (a la derecha), t es positivo.

3.6 Modulación y Demodulación

Modulación es el proceso de preparar la señal para envió por un medio de transmisión,

25

este proceso se puede llevar a cabo en banda base, es decir la banda de frecuencias

original de la señal o por medio de una translación de frecuencia se puede hacer en lo

que se llama modulación pasa banda, en este caso existe una translación de frecuencia

de una banda de frecuencias baja a una banda de frecuencias alta. La figura 3.10

muestra la operación de modulación y su contraparte, la de-modulación en la figura

3.11. En la modulación se pasa la señal de una banda base (baja frecuencia) a una pasa

banda (alta frecuencia). En la demodulación se pasa la señal de una pasa banda (alta

frecuencia) a una banda base (baja frecuencia). Típicamente la modulación se lleva a

cabo modificando alguna de las características de las señales; amplitud, frecuencia o

fase.

Debido a este proceso, la señal de alta frecuencia denominada portadora, sufrirá la

modificación de alguno de sus parámetros, siendo dicha modificación proporcional a

la amplitud de la señal de baja frecuencia denominada moduladora.

A la señal resultante de este proceso se la denomina señal modulada y la misma es la

señal que se transmite.

Figura 3.10. Modulación de una señal

La demodulación es el proceso inverso a la modulación.

Figura 3.11. Demodulación de una señal

26

3.6.1 Modulación en amplitud

Modulación en amplitud es el proceso de cambiar la amplitud de una portadora de

frecuencia relativamente alta de acuerdo a la amplitud de la señal modulante

(información).

Con la modulación en amplitud la información se imprime sobre la portadora en forma

de cambios de amplitud.

La onda modulante modula a la onda portadora tanto en sus partes positivas como

negativas, es decir, produce una señal con dos bandas laterales.

La señal modulada tendrá una amplitud que será igual al valor pico de la señal

portadora más el valor instantáneo de la señal modulada.

La señal modulada en amplitud es:

Tipos de modulación AM.

Al modular en amplitud, el ancho de banda resultante es el doble del ancho de banda

de la información original, debido a la generación de dos bandas laterales que

desafortunadamente contienen la misma información cada una de ellas. Por lo tanto, se

han desarrollado técnicas para reducir el ancho de banda necesario y de ahí han

resultado varios tipos de modulación en amplitud, los cuales son los siguientes:

Modulación en amplitud con doble banda lateral. (AM-DSB)

Este es el tipo de modulación en la cual al hacer la multiplicación de las dos señales se

generan las dos bandas laterales de igual tamaño.

Modulación en amplitud con banda lateral suprimida. (AM-SSB)

27

Para evitar que se tenga que usar el doble de ancho de banda requerido se usa la

modulación AM-SSB, en este tipo de modulación, por medio de un filtro se elimina

una de las bandas laterales, después de la modulación y se usa una sola banda lateral,

reduciendo por lo tanto el ancho de banda requerido.

Modulación con banda lateral residual. (AM-VSSB)

En este tipo de modulación se elimina solo parte de una de las bandas laterales, y se

usa esa parte para modular información adicional.

3.6.2 Modulación en frecuencia

La modulación en frecuencia se obtiene variando la frecuencia instantánea de la

portadora en función de la información. En este caso la señal modulada mantendrá fija

su amplitud y el parámetro de la señal portadora que variará es la frecuencia, y lo

hace de acuerdo a cómo varíe la amplitud de la señal moduladora.

La expresión matemática de la señal modulada es:

Vp(t) = Vp sen[2π (fp + Δf sen(2 π fm t) ) t]

Δf se denomina desviación de frecuencia y es el máximo cambio de frecuencia que

puede experimentar la frecuencia de la señal portadora. A la variación total de

frecuencia desde la más baja hasta la más alta, se le conoce como oscilación de

portadora.

3.6.3 Modulación en fase

En este tipo de modulación la amplitud de la portadora es constante y la característica

que contiene la información es el ángulo de la fase instantánea de la señal portadora.

La señal modulada es:

V (t) = Vp cos[ 2π fp t + Β sen(2π fm t) ]

28

La diferencia que hay con la señal modulada en frecuencia es que en la modulación

en fase, Β es independiente de la frecuencia.

3.7 Decibeles

Es la décima parte del Bel, que es utilizado en sistemas de comunicación para medir

la relación de dos magnitudes (eléctricas y acústicas). Es una unidad de medida

adimensional y logarítmica.

En sistemas de comunicación muy a menudo es necesario confrontar las relaciones

entre las mediciones de varios niveles de señal y medir niveles exactos de señal a

través de todo el sistema. Es deseable que los cálculos para determinar esas relaciones

o cálculos exactos sean lo más simple posible para evitar la posibilidad de error. Para

llevar a cabo esto se ha seleccionado un sistema de cálculo basado en el decibel (dB).

El decibel es una cantidad que indica una relación en lugar de una cantidad en sí, por

ejemplo, nos indica que una cantidad es 5 veces mayor que otra o que una cantidad es

10 veces mayor que otra. El dB es una relación entre dos cantidades que se miden con

un mismo parámetro. Ej. Potencia o Voltaje.

Cuando se consideran las condiciones normales en un sistema, se encuentra que una

cantidad q1 es mayor que una cantidad q2 nos referimos a una ganancia de señal y

cuando una cantidad q1 es menor a una cantidad q2 nos referimos a una pérdida de

señal y como usamos valores logarítmicos (dB), un signo positivo indicará una

ganancia y un signo negativo indicará una pérdida.

El dB es usado en un sistema para representar solamente pérdida o ganancia.

Dado que los niveles de señal en los sistemas de comunicación son muy pequeños y

están representados por relaciones en lugar de cantidades fijas, se hace necesario

encontrar una forma de representar estos valores. La representación en Decibeles es

una manera sencilla y que abarca una amplia gama de valores en una cierta escala.

Debido a esto se usan los valores en una escala logarítmica. Aunque esto parezca

29

complicado, es una manera sencilla de representar valores muy dispares y con una

exactitud aceptable. Así un valor en Decibeles es una representación logarítmica de

una relación de dos valores. Para expresar ganancia de potencia directamente se usa

esta ecuación:

Ganancia de potencia en dB =10 log10

En donde P1 es la potencia de la señal en la entrada del sistema, y P2 la potencia a la

salida del mismo.

Para expresar ganancia de potencia en términos de voltaje y corriente se usan estas

ecuaciones:

Ganancia de voltaje en dB =20 log10

Ganancia de corriente en dB =20 log10

En donde V1 es el voltaje de la señal en la entrada del sistema, V2 el voltaje a la salida

del mismo, I1 es la corriente de la señal en la entrada del sistema, y I2 la corriente a la

salida del mismo.

Otro estándar que se usa muy comúnmente es el de dBm. Esta señal de referencia para

mediciones de señal representa una relación de una señal de un valor fijo de 1 miliWatt

o 1 x 10-3 Watts y otra señal desconocida.

dB =10 log10

30

CAPÍTULO 4. Modulación Digital

La Modulación es la alteración sistemática de una onda portadora de acuerdo con el

mensaje (señal modulada). En donde la señal de entrada es una señal digital binaria.

4.1 Muestreo

Es el proceso de extraer una señal discreta de una señal en tiempo continuo. Sea x(t)

una señal continua en el tiempo y sea el periodo de muestreo Ts > 0 un número fijo. A

partir de x(t), la señal discreta:

x(n)=x(nTs)

Sí la señal es muestreada a una velocidad Fs (muestras/s) se obtiene que:

Teoría de muestreo.

Si m(t) es una señal que tiene una banda de frecuencias limitada, tal que la frecuencia

máxima de esta señal es fM. Si hacemos que los valores de m (t) sean validos solo a

intervalos regulares separados por los tiempos Ts ≤ 1/2 fM, es decir, la señal es

periódicamente muestreada cada Ts segundos. Entonces, las muestras m (nTs), donde

n es un entero, determinan completamente la señal y la señal puede ser reconstruida

con esas muestras sin ninguna distorsión.

El tiempo Ts es llamado el tiempo de muestreo. El teorema muestreo indica que la

velocidad de muestreo debe ser lo suficientemente rápida, de manera que al menos

dos muestras sean tomadas en el periodo correspondiente al componente espectral de

máxima frecuencia encontrada en la señal (velocidad Nyquist).

4.2 Modulación por amplitud de pulsos (PAM)

31

Describe la conversión de señales analógicas en señales de pulsos donde la amplitud

del impulso indica la información analógica. Esta señal PAM (pulse-amplitude

modulation) se puede convertir en una señal digital PCM (Pulse-code modulation) de

banda base, la que a su vez se modula sobre una portadora de sistemas de

comunicación digital pasa banda. Por consiguiente, el proceso de conversión

analógica a PAM es el primer paso en la conversión de una forma de onda analógica

en una señal PCM digital.

El teorema de muestreo, permite reproducir una forma de onda analógica con valores

de muestreo de dicha forma de onda y funciones ortogonales (senx/x). El objetivo de

la señalización PAM es proporcionar otra forma de onda con apariencia de pulsos, y

que aun así contenga la información que estaba presente en la forma de onda

analógica.

Figura 3.12. Señal PAM

Como se usan pulsos, se puede esperar que el ancho de banda de la forma de onda

PAM sea más ancha que el de la forma de onda analógica. No obstante, los pulsos

son más prácticos de utilizar en sistemas digitales. La velocidad de los pulsos fs, en el

caso de PAM es la misma que la requerida por el teorema de muestreo, es decir, fs>

2B, donde B es la frecuencia más alta en la forma de onda analógica y 2B se llama

tasa (relación) de Nyquist.

Existen dos clases de señales PAM: PAM que utiliza muestreo natural (compuerta) y

la PAM que utiliza muestreo instantáneo para producir un pulso de cresta plana. Las

de cresta plana son más útiles para la conversión en PCM; sin embargo, las de

muestreo son más fáciles de generar y usar en otras aplicaciones.

32

En la modulación de amplitud de pulsos, la amplitud de un tren de pulsos de ancho

constante varía en proporción a los valores muestreados de la señal moduladora.

Usualmente, los pulsos se toman a intervalos de tiempo equidistantes.

4.3 Tipos de Modulación Digital

Modulación por amplitud (Amplitude Shift Keying ASK). Tipo de modulación en la

cual una señal digital binaria, es representada con variaciones de amplitud, es decir un

nivel v1(t) si la señal es cero y una señal v2(t) si la señal es uno.

Modulación por frecuencia (Frequency Shift Keying FSK). Tipo de modulación en la

cual una señal digital binaria, es representada con variaciones de frecuencia, es decir

una frecuencia f1 si la señal es cero y una frecuencia f2 si la señal es uno.

Modulación por fase (Phase Shift Keying PSK). Tipo de modulación en la cual una

señal digital binaria, es representada con variaciones de fase, es decir una fase θ1 si la

señal es cero y una fase θ2 si la señal es uno.

Modulación de amplitud en cuadratura (Quadrature Amplitude Modulation QAM). Se

trata de un caso especial de PAM (Pulse Amplitude Modulation), es la superposición

de dos portadoras en cuadratura moduladas en amplitud con la misma frecuencia pero

desfasadas 900.

ASK

FSK

PSK

QAM

Figura 4.1. Tipos de Modulación Digital.

33

Diagrama de constelación

Es un método de representar los estados de símbolo en un modem de paso de banda

modulado de portadora en términos de su amplitud y fase. Típicamente, el eje

horizontal se toma como referencia para los símbolos que están en fase con la

portadora cos ct ), y el eje vertical representa la componente de frecuencia en

cuadratura, sen ct). Se utiliza para representar diferentes tipos de señales digitales.

La fase de la señal es representada por el ángulo alrededor del círculo y la amplitud

por la distancia del origen al centro del círculo.

4.1 Modulación PSK

PSK con múltiples valores (M-ary PSK)

En BPSK se transmite cada bit individualmente, en QPSK se transmite un símbolo

que representa 2 bits. Si continuamos con esta tendencia, se puede ampliar la cantidad

de bits representados por un símbolo, es decir representar N bits con un símbolo,

extendidos sobre el tiempo NTb y con 2N =M símbolos. Representando los símbolos

con formas de onda de duración NTb = Ts y con diferencia de fase igual a 2π/M.

PSK binaria (BPSK). En este tipo de modulación, la señal transmitida es una onda

senoidal de amplitud fija A. Tiene una fase fija cuando la señal es un 1 y una fase

180° diferente cuando la señal es 0.

PSK en cuadratura (QPSK). Esta forma de modulación genera una secuencia de

símbolos, en lugar de una secuencia de bits, es decir, además de la fase se usan las

señales de cuadratura sen(t) y cos(t), para la modulación. El cambio de fase y las

señales de cuadratura nos dan la posibilidad de tener cuatro combinaciones de salida:

la salida sen(t) con cambios de fase de ±180° y la salida cos(t) con cambios de fase de

±180°.

Así como BPSK cambia la fase en 180°, QPSK lo hace en 90°. El desplazamiento de

fase en cuadratura (QPSK) es una extensión del método de PSK simple. En QPSK la

34

señal puede tomar uno de los cuatro ángulos de fase posibles, mutuamente en

cuadratura, cada uno corresponde a una condición de entrada de datos particular.

Con el formato de datos NRZ (No Return to Zero), en el cual cada palabra es dividida

en pares de bits en lugar de bits individuales, hay cuatro modos posibles de paridad

binaria 1 y 0. Estos son: 00, 01, 10, 11. Cualquier palabra de información con un

número par de bits puede ser representado por una combinación de estos pares de

bits. Uno de los cuatro ángulos de fase es asignado a cada uno de estos pares de bits.

La modulación QPSK utiliza cuatro señales senoidales, para codificar dígitos

binarios. En el transmisor los dígitos binarios son tomados de a dos a la vez,

instruyendo al modulador, cuál de las cuatro señales enviar (dependiendo de la forma

de la constelación elegida).

QPSK comparado con el BPSK ofrece el doble de bits de información por portadora

de cambio de fase, encuentra amplia aplicación en sistemas de transmisión de datos

de portadora-modulada de alta-velocidad.

8-PSK. Es casi idéntico a QPSK con la excepción que la fase de la forma de onda de

la salida varía entre ocho posiciones.

16-PSK. Es una técnica de codificación M-ario, en donde M = 16; hay 16 diferentes

fases de salida posibles. Un modulador de 16-PSK actúa en los datos que están

entrando en grupos de 4 bits (24= 16), llamados quadbits (bits en cuadratura). La fase

de salida no cambia, hasta que 4 bits han sido introducidos al modulador.

Figura 4.2. Diagramas de constelación de PSK. a) BPSK. b) QPSK

b) a)

35

4.2 Modulación QAM

En QAM, los tonos son representados como la sumatoria de dos señales que están en

fase o fuera de fase con respecto a un reloj. Estas señales son llamadas I (en fase) y Q

(por cuadratura).

4-QAM. La modulación 4-QAM contiene 4 valores binarios: 00, 01, 10, 11. Los

cuales corresponden a una determinada fase, el cambio de fase entre uno y otro es de

90°.

8-QAM. Los datos se dividen en grupos de 3 bits: 000 hasta 111. Los flujos de bits I,

Q y C cada uno con una tasa de bits igual a un tercio de la tasa de datos que están

entrando. Los bits I y Q determinan la polaridad de la señal PAM y el canal C

determina la magnitud.

Así como con el 8-PSK, los datos que están entrando se dividen en grupos de tres bits

(tribits): los flujos de bits I, Q y C, cada uno con una tasa de bits igual a un tercio de

la tasa de datos que están entrando.

16-QAM. Así como el 16-PSK, el 16-QAM es un sistema M-ario, en donde M= 16.

Actúa sobre los datos de entrada en grupos de cuatro (24 = 16).

a) b)

36

Figura 4.3. Diagramas de constelación de QAM. a) 4-

QAM. b) 8-QAM. c) 16-QAM. d) 32-QAM.

c) d)

37

CAPÍTULO 5. Codificación para control de errores.

5.1 Fundamentos y definiciones

La codificación de canal o codificación para control de errores: consiste en 'mapear'

(añadir redundancia) a la secuencia de datos entrante en una secuencia de entrada al

canal y realizar el 'mapeo' inverso a la salida del canal en una secuencia de datos tal

que los efectos del ruido estén minimizados. La introducción de redundancia en la

codificación del canal tiene como finalidad mejorar la fiabilidad de la transmisión.

Proporción de error en bits (BER): se define como la relación entre el número de bits

erróneos recibidos respecto al número total de bits transmitidos.

Proporción residual de error: se define como la relación entre el número de bits

erróneos no detectados sobre el total de bits emitidos. Mide la capacidad de detectar

errores.

Peso de Hamming: está representado por W(c) donde c es una palabra de código, y se

define como el número de bits de esa palabra diferentes de cero.

Distancia de Hamming: es la distancia entre dos palabras de código de igual longitud y

se define como el número de bits (posición a posición) en los que se diferencian las

dos palabras.

Tipos de códigos:

Códigos sistemáticos: aquellos códigos en los que la palabra de información aparece

de forma explícita en la palabra codificada.

Códigos no sistemáticos: aquellos códigos en los que la palabra de información no

aparece de forma explícita en la palabra codificada.

Códigos de bloque: (tienen el mismo significado que en el caso de la codificación de

la fuente) aquellos códigos en los que todas las palabras tienen la misma longitud y la

38

codificación se hace de forma estática.

Códigos lineales: aquellos en los que cualquier combinación lineal de palabras de

código válida (por ejemplo la suma módulo 2) produce otra palabra válida.

Códigos cíclicos: aquellos en los que cualquier desplazamiento cíclico de una palabra

de código da lugar a otra palabra de código.

Códigos de paridad: su funcionamiento se basa en añadir un bit a la secuencia a enviar

de forma que el número de "1's" sea par o impar, dependiendo del tipo de paridad:

- si la paridad es par, el número final de "1's" debe ser par.

- si la paridad es impar, el número final de "1's" debe ser impar.

Códigos: Denominemos S={S , S , S ... S } al conjunto de símbolos de un alfabeto

dado. Se define un código como la correspondencia de todas las secuencias posibles

de símbolos de S a secuencias de símbolos de algún otro alfabeto X={x , x , x ,...x }. S

recibe el nombre de alfabeto fuente y X el de alfabeto código. Como esto es demasiado

general para resultar de utilidad, será necesario acotar más esta definición. Y la

primera propiedad de un código es que sea un código de bloque.

Un código bloque es aquel que asigna cada uno de los símbolos del alfabeto fuente S a

una secuencia fija de símbolos del alfabeto código X. Esas secuencias fijas reciben el

nombre de palabras código. Un código bloque se denomina no singular si todas sus

palabras son distintas.

Códigos unívocamente decodificables: la extensión de orden n de un código bloque es

la que hace corresponder los símbolos S con las palabras de código X, es el código

bloque que hace corresponder las secuencias de símbolos de la fuente (S ,S ....S ) con

las secuencias de las palabras de código ( X , X ...X ). Es decir, la extensión de orden n

de un código bloque es también un código bloque. Además, un código bloque es

unívocamente decodificable si, y solamente sí, su extensión de orden n es no singular

39

para cualquier n finito.

Con un código unívocamente decodificable nos aseguramos que dos secuencias

cualesquiera de símbolos de la fuente de igual longitud dan lugar a secuencias de

símbolos código distintas. Un código unívocamente decodificable se denomina

instantáneo cuando es posible decodificar las palabras de una secuencia sin precisar el

conocimiento de los símbolos siguientes.

Distancia mínima de un código: se establece como la distancia de Hamming más

pequeña entre dos combinaciones cualesquiera del código.

Códigos detectores de error: Los códigos detectores están basados en no aprovechar

todas las combinaciones posibles de ceros y unos para formar palabras pertenecientes

al código. Así, si se produce algún error en la transmisión, la palabra resultante podría

no pertenecer al código y de esta forma sabríamos que se ha producido un error.

Para detectar el error en un dígito binario es condición necesaria que el código posea

una distancia mínima estrictamente mayor que uno. Y la condición necesaria y

suficiente para detectar un error en k dígitos binarios, es que la distancia mínima sea

de k+1.

Estos códigos se forman a partir de uno de distancia mínima uno o superior, al cual se

le añade el denominado dígito de paridad (normalmente como dígito binario más

significativo). Este dígito deberá tomar el valor apropiado (0 o 1) para que el número

de unos de la combinación resultante sea par o impar dependiendo de si queremos

construir un código de paridad par o un código de paridad impar.

Códigos correctores de error: La condición necesaria y suficiente para que un código

sea corrector de error en k dígitos binarios, es que su distancia mínima sea de 2k+1.

5.2 Códigos de bloque

5.2.1 Códigos de bloque lineales sistemáticos

40

Un código de bloque lineal sistemático será capaz de detectar X-1 bits erróneos, donde

X viene dado por la distancia de Hamming mínima entre 2 palabras cualesquiera del

código, y será capaz de corregir ( X-1)/2 bits erróneos.

Estos códigos cumplen la siguiente propiedad:

La suma módulo-2 de dos palabras del código da lugar a otra palabra de código.

En la especificación de estos códigos se utiliza la siguiente notación ( n,k ):

n es el tamaño de la palabra codificada

k es el tamaño del mensaje original. Estos k bits se envían sin alteración.

Los n-k bits restantes son los bits de paridad. Es la redundancia mediante la cual se

detectan y corrigen los errores.

La forma de una palabra de código de un código de bloque lineal sistemático es la

siguiente:

m0 m1 . . . mk-1 b0 b1 b2 . . . bn-k-1

Donde m0 .......................mk-1 son los bits del mensaje original y b0 .......................bn-

k-1 son los bits de paridad que se añaden como redundancia.

De esta forma, podemos expresar una palabra de código como:

c0 c1 . . . cnk-1 cn-k . . . cn-1

El cálculo de los bits de paridad se realiza de la siguiente forma:

bi = P0i m0 + P1i m1 + . . . + Pk-1i mk-1

Donde los Pij deben ser tales que la matriz generadora del código tenga filas

independientes y las ecuaciones de paridad sean iguales.

41

Para realizar la codificación se utiliza una notación matricial. Consideraremos la

palabra original, la palabra formada por los bits de paridad y la palabra de código

como vectores:

m = (m0 m1 . . . mk-1 )

b = (b0 b1 . . . bn-k-1 )

c = (c0c1 . . . cn-1 )

También se utiliza la matriz de coeficientes:

P=

Para realizar la codificación se utiliza la matriz generadora:

G = [ Ik,k | P ]

Siendo Ik,k la matriz identidad de tamaño k * k.

De esta forma podemos obtener cada palabra de código a partir de cada palabra de

mensaje original realizando la siguiente multiplicación:

c = m · G

Para realizar la decodificación, en destino se recibe un vector (c) de tamaño n y lo que

se puede hacer es repetir la operación realizada en la codificación: se toman los

primeros k bits y se calcula la redundancia usando la matriz generadora y se

comprueba si la redundancia obtenida es igual a la redundancia recibida.

Otra opción más eficiente es la basada en el concepto de síndrome. En este proceso se

utiliza la matriz de chequeo de paridad, que se define de la siguiente forma:

H = [Pt | I]

42

H tiene la propiedad de que sólo las palabras de código verifican que al multiplicarlas

por Ht el resultado es el vector nulo. Esta propiedad será utilizada para la detección y

corrección de errores.

A cada palabra que el receptor recibe a través del canal la denominaremos palabra

recibida r. Una palabra recibida la podemos expresar como:

r = c + e

Donde c es la palabra de código enviada por el emisor y e es una palabra de error.

Cada componente ei de la palabra de error vale 1 si hay un error en esa posición y 0 si

no lo hay.

El receptor para realizar la codificación utiliza la matriz H para calcular el vector de

síndrome de error a partir de la palabra recibida. El vector de síndrome de error se

obtiene de la siguiente forma:

s = r · Ht

El vector de síndrome tiene tantos elementos como bits de paridad se estén usando, y

sólo depende de la secuencia de error y no de la palabra de código transmitida. Si en la

transmisión no se ha producido un error, el síndrome es el vector nulo:

s = r · Ht = 0

Si se ha producido un error la multiplicación de la palabra recibida por Ht nos da un

vector que es igual a una de las filas de Ht. La posición que ocupa esa fila es la

posición donde hay un error. Todas estas operaciones se hacen en módulo-2 (sin

acarreo).

5.2.2 Código Hamming

Un código de Hamming es un código de bloque lineal. Al igual que en los códigos de

43

bloque lineales sistemáticos, podemos denotar un código de Hamming mediante un

par (n ,k). Sin embargo los valores de n y k deberán verificar una serie de condiciones:

- n es la longitud de la palabra de código.

- k es el número de bits de datos de la palabra original sin codificar.

- el número de bits de paridad será m = n - k, pero deberá cumplirse la siguiente

relación entre la longitud de la palabra de código y el número de bits de paridad:

n = 2m - 1 con m >= 3

Según esto también se cumplirá la siguiente relación entre el número de bits de datos y

el número de bits de paridad:

k = 2m - m - 1

Por lo tanto, a cada palabra original se le añadirán unos bits de paridad para obtener la

palabra de código, de forma que estos bits de paridad sirvan posteriormente para

encontrar y corregir errores que se produzcan en la transmisión.

Cada uno de los bits de paridad que añadimos a una palabra original va a afectar a

unas determinadas posiciones de la nueva palabra de código, de forma que tomarán un

valor adecuado para que se cumpla el criterio de paridad (par o impar) preestablecido

en las sub-combinaciones afectadas por cada uno de estos bits de paridad.

El siguiente paso consistirá en determinar a qué posiciones de los bits de las palabras

de código afecta cada bit de paridad. Para ello, se construyen todas las combinaciones

posibles con m bits de paridad y se interpreta cada una en binario natural.

Cada bit de paridad va a afectar a aquellas posiciones en las que ese bit vale 1.

Bit de paridad Posiciones

b1 ................. 1,3,5,7,..........

44

b2 ................. 2,3,6,7,..........

...

bm ................. 2m, 2m+1,2m+2....

Por último se determina qué posiciones de cada palabra de código ocupará cada bit de

paridad. Los bits de paridad se colocan en aquellas posiciones en las que no se vean

afectados por otros bits de paridad. Estas posiciones serán:

Bit de paridad Posición

b1 ................... 20

b2 ................... 21

b3 ................... 22

.....

De esta forma queda completado el proceso de construcción de un código de

Hamming.

En el proceso de decodificación, el receptor recibe una palabra de un código de

Hamming, y deberá comprobar si es correcta o no, y en el caso de que no fuera

correcta deberá comprobar en que bit se produjo el error y corregir ese error.

Para comprobar si la palabra recibida es correcta, e l receptor debe utilizar los bits de

paridad de la palabra y hacer con ellos un control de paridad. Para realizar el control

de paridad, se crea una palabra que tendrá un bit por cada uno de los bits de paridad

utilizados. Cada uno de los bits de esta palabra toma el valor 0 o 1 dependiendo de si

el número de unos de las posiciones de la palabra de código afectadas por su

correspondiente bit de paridad cumplen o no el criterio de paridad establecido.

Interpretando la combinación resultante en binario natural se tendrán dos

45

posibilidades:

- que sea un 0, lo cual quiere decir que no se han producido errores en la transmisión.

- que se corresponda a un número distinto de 0, lo cual quiere decir que durante la

transmisión ha variado el bit situado en la posición indicada por ese número.

Una vez obtenida la palabra de código correcta, basta con quitar los bits de paridad

para obtener la palabra original enviada por el emisor.

5.3 Códigos Cíclicos

Los códigos cíclicos son una subclase de los códigos de bloque lineales. Son fáciles de

codificar y cumplen la propiedad de linealidad y la de propiedad de que cualquier

desplazamiento cíclico de una palabra del código también pertenece al código.

Al igual que en los códigos de bloque lineales sistemáticos y en los códigos de

Hamming, se denota un código cíclico mediante un par (n,k), donde n es la longitud de

las palabras de código y k es la longitud de una palabra original.

Para el manejo de estos códigos se utiliza una notación polinomial, de forma que una

palabra de código C = (c0......,cn-1 ) se interpreta como un polinomio, y cada uno de los

bits de la palabra de código será uno de los coeficientes de este polinomio:

C(x) = c0 + c1x + . . . + cn-1xn-1

A su vez, una palabra original m = (m0,......, mk-1) se interpreta como el polinomio:

m(x) = m0 + m1x + . . . + mk-1xk-1

Para generar C(x) a partir de m(x) se usa el polinomio generador g(x) que es un factor

de ( x + 1)n . Su grado es n-k. La obtención de la palabra codificada se hace de la

siguiente forma:

C(x) = m(x) · g(x)

46

Así se tiene que un código cíclico queda perfectamente determinado por su polinomio

generador.

Para realizar el control de errores se utiliza el polinomio de chequeo de paridad, que es

un polinomio de grado k tal que:

g(x) · H(x) = (x + 1)n

Los pasos para hacer una codificación CRC son:

1) Expresar el mensaje en forma de cadena binaria

2) Escoger un polinomio divisor (polinomio generador)

3) Agregar al mensaje tantos ceros, como bits tenga el polinomio generador

4) Efectuar la división del mensaje entre el polinomio generador

5) Agregar el residuo de la división (checksum), al mensaje original

6) Tras la recepción, se divide la cadena recibida entre el polinomio generador, si la

transmisión fue correcta el residuo de la división deberá ser cero. De no ser nulo el

residuo, significa que hubo errores durante la transmisión.

5.4 Códigos convolucionales

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). Estos códigos son lineales, donde la suma de dos palabras

de código cualesquiera también es una palabra de código. Y al contrario que con los

códigos lineales, se prefieren los códigos no sistemáticos.

47

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.

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.

48

CAPÍTULO 6. Resultados

6.1 Serie de Fourier

Es un programa que grafica una señal elegida por el usuario y la Serie de Fourier de

una dicha señal con n armónicas, que son también introducidas por el usuario.

Figura 6.1a. Inicialización (Serie de Fourier).

Este programa se implementó con una serie de comandos básicos de Matlab y

operaciones para realizar la suma (de acuerdo a la fórmula) dentro de un ciclo for.

El programa se implementa con un ciclo if para elegir la señal a calcular:

si señal == 1

graficar parábola si señal == 2

graficar recta si señal == 3 graficar cuadrada

si señal == 4 graficar triangular

si señal == 5 graficar diente de sierra fin

De acuerdo a la señal que se eligió, se hace el cá lculo de la suma de n armónicas

mediante un ciclo for:

49

= valor calculado desde m=1 hasta n

= valor calculado = valor calculado

suma = suma+( (m)*cos(m*t))+( (m)*sen(m*t))

fin

El valor de suma será el valor de la serie de Fourier. Este valor se grafica con respecto

al tiempo.

6.1.1 Elementos del programa

1. n: armónicas de la Serie de Fourier.

2. Señal: es la señal a la cual se le grafica la Serie de Fourier. Las señales a elegir

son: parábola, recta, cuadrada, triangular y diente de sierra.

3. Coeficientes de la Serie de Fourier: es donde se muestran los coeficientes de

la Serie de Fourier calculados de acuerdo a la señal elegida.

4. Grafica de la Serie de Fourier: es donde se grafica la señal que representa la

Serie de Fourier de acuerdo a n y la señal elegida.

6.1.2 Ejemplo

Con la función y=t2, los valores de los coeficientes de Fourier son:

Figura 6.1b. Elementos del programa (Serie de Fourier).

50

=

= π2/3

=

=

(-1)n

bn=

= 0

Figura 6.1c. Ejemplo (Serie de Fourier).

6.2 Transformada de Fourier

Es un programa que grafica una señal elegida por el usuario y su Transformada de

Fourier.

Figura 6.2a. Inicialización (Transformada de Fourier).

El programa se implementa con ciclos if para elegir la señal a calcular: si señal == 1

graficar coseno si señal == 2

51

graficar diente de sierra si señal == 3 graficar sinc

si señal == 4 graficar cuadrada

si señal == 5 graficar exponencial si señal == 6

graficar impulso si señal == 7

graficar seno fin

Después de elegir la señal a graficar, se calcula la Transformada de Fourier con la

función fft:

Transformada de Fourier= abs (fft (señal, puntos a graficar))

6.2.1 Función fft (x, N)

Es una función de Matlab que regresa la Transformada Discreta de Fourier (DFT) del

vector x, realizada con el algoritmo de la transformada rápida de Fourier (FFT). “x”

es un vector de números complejos ordenados desde k=0...N-1. La longitud del vector

x debe ser una potencia de 2. “N” es el número de puntos con el que se hace la FFT.


Figura 6.2b. Elementos del programa (Transformada de Fourier).

52

1. Señal. Es donde se elige la señal a graficar.

2. Grafica de señal. Es donde se grafica la señal elegida.

3. Transformada de Fourier. Es donde se grafica la Transformada de Fourier de

la señal elegida.

6.2.3 Ejemplo

Figura 6.2c. Ejemplo del programa (Transformada de Fourier).

6.3 Convolución y Correlación de señales

Es un programa que grafica dos señales y la Convolución o Correlación de éstas.

Figura 6.3a. Inicialización (Convolución y Correlación).

53

En el programa se desarrollaron varias opciones para elegir el tipo, la operación y las

señales a las que se grafica la Convolución o Correlación.

Con ciclos if se selecciona el tipo de señal a elegir y la operación a realizar:

si señal == señal CT

mostrar en menú desplegable señales continuas en el tiempo si no

mostrar en menú desplegable señales discretas en el tiempo fin

si operación == Convolución gráfica == conv (x(t), h(t))

si no gráfica == xcorr (x(t), h(t)) fin

Las opciones de señales que muestran los menús desplegables son:

x(t) para señales continuas: x=t 0 < t < 3

x=1 0 < t < 3 x=sen(t) -3 < t < 3 x=1 -1 < t < 1

h(t) para señales continuas:

h=1 -1 < t < 1 h=1 0 < t < 3

h=-t 0 < t < 3 h=sen(t) -3 < t < 3

x(t) para señales continuas:

1.

2.

3.

4.

54

5.

h(t) para señales discretas:

1.

2.

3.

4.

5.

6.3.1 Función conv (x,h)

Hace la convolución de los vectores x y h. El vector resultante tiene un tamaño igual

a la longitud de x + la longitud de h-1.

6.3.2 Función xcorr (x,h)

Hace la correlación de los vectores de M elementos x y h. Devuelve un vector de 2M-

1 elementos.


Figura 6.3b. Elementos del programa (Convolución y Correlación).

55

1. Tipo de señal. Es donde se elige el tipo de señal. Señal CT: señal continúa en

el tiempo. Señal DT: señal discreta en el tiempo.

2. Operación. Es donde se elige el tipo de operación: Convolución o

Correlación.

3. Señal x(t) o x(n). Es donde se elige la señal x(t) si la señal es continua, o x(n)

si la señal es discreta.

4. Señal h(t) o h(n). Es donde se elige la señal h(t) si la señal es continua, o h(n)

si la señal es discreta.

5. Graficar Convolución o Correlación. Es el botón que grafica la Convolución o

Correlación según los parámetros especificados.

6. Gráfica de señal x. Es donde se grafica la señal x(t) o x(n).

7. Gráfica de señal h. Es donde se grafica la señal h(t) o h(n).

8. Gráfica de señal y(t). Es donde se grafica la señal resultante.

6.3.4 Ejemplo

Figura 6.3c. Ejemplo (Convolución y Correlación).

56

6.4 Modulación AM, FM y PM

Es un programa que grafica una señal análoga moduladora a elegir y su respectiva

señal modulada en Amplitud (AM), en Frecuencia (FM) o en Fase (PM).

Figura 6.4a. Inicialización (Modulación AM, FM y PM).

El programa esta implementado con ciclos if para elegir la operación a realizar:

si Modulación == AM modulada= amod(moduladora, frecuencia de la portadora,1000, 'am') si Modulación == FM

modulada= amod(moduladora, frecuencia de la portadora,1000, 'fm') si Modulación == PM

modulada= amod(moduladora, frecuencia de la portadora,1000, 'pm') 6.4.1 Función amod(x,fc,fs, 'method')

Usa la señal x para modular una señal portadora con frecuencia Fc (Hz) usando la

modulación especificada en “method”: am para modulación en amplitud, fm para

modulación en frecuencia y pm para modulación en fase. La señal portadora y x

tienen una frecuencia de muestreo Fs (Hz).


57

Figura 6.4b. Elementos del programa (Modulación AM, FM y PM).

1. Am. Amplitud de la señal moduladora.

2. fc. Frecuencia de la señal portadora.

3. fm. Frecuencia de la señal moduladora.

4. Modulación. Tipo de modulación a graficar: AM, FM o PM.

5. Moduladora. Tipo de señal a modular: Diente de sierra, Cuadrada, Seno o

Coseno.

6. Gráfica de señal moduladora. Es donde se grafica la señal moduladora.

7. Gráfica de señal modulada. Es donde se grafica la señal modulada.

6.4.3 Ejemplo de modulación AM

58

Figura 6.4c. Ejemplo (Modulación AM).

6.4.4 Ejemplo de modulación FM

Figura 6.4d. Ejemplo (Modulación FM).

6.4.5 Ejemplo de modulación PM

Figura 6.4e. Ejemplo (Modulación PM).

59

6.5 Conversión dB a Watts y Watts a dB

Es un programa que realiza la conversión de dB a Watts, de Watts a dB, de dBm a

Watts y de Watts a dBm.

Figura 6.5a. Inicialización (Decibeles y Watts).

El código consiste en ciclos if que se emplean para elegir la operación a realizar:

si Convertir == dB a Watts

Watts= 10 ^ (dB/10) si Convertir == Watts a dB dB= 10log10 (potencia de salida / potencia de entrada)

si Convertir == dBm a Watts Watts=10 ^ (dB/10)

si Convertir == Watts a dBm dB=10*log10 (potencia de salida / .001) fin


Figura 6.5b. Elementos del programa (Decibeles y Watts).

60

1. Menú de conversiones. Es donde se elige la operación a realizar.

2. Convertir. Es el botón que, al ser presionado, hace la conversión elegida.

3. Decibeles. Es donde se introducen los decibeles para hacer las conversiones:

dB a Watts o dBm a Watts.

4. Potencia de entrada. Es donde se introducen los Watts de la potencia de

entrada para la conversión de Watts a dB

5. Potencia de salida. Es donde se introducen los Watts de la potencia de salida

para las conversiones: Watts a dB o Watts a dBm.

6.5.2 Ejemplo

dB= 10log10(potencia de salida / potencia de entrada) dB=10log10(5/3)

dB=2.218

Figura 6.5c. Ejemplo (Decibeles y Watts).

6.6 Muestreo de señales

Es un programa que grafica una señal muestreada con frecuencia, muestras y

frecuencia de muestreo como parámetros de entrada.

61

Figura 6.6a. Inicialización (Muestreo de señales).

El código del programa consiste en ciclos if para cambiar de señal, de 5 a elegir en un

menú:

Si señal == seno señal =seno(2*pi*Frecuencia de la señal*(muestras / Frecuencia de muestreo))

Si señal == coseno señal =coseno(2*pi*Frecuencia de la señal*(muestras / Frecuencia de muestreo))

Si señal == cuadrada señal =cuadrada(2*pi*Frecuencia de la señal*(muestras / Frecuencia de muestreo)) Si señal == diente de sierra

señal =diente de sierra(2*pi*Frecuencia de la señal*(muestras / Frecuencia de muestreo))

Si señal == rectangular señal =rectangular(2*pi*Frecuencia de la señal*(muestras / Frecuencia de muestreo))


Figura 6.6b. Elementos del programa (Muestreo de señales).

62

1. n. Es el número de muestras que se van a graficar.

2. Frecuencia. Es la Frecuencia a la que se quiere graficar la señal.

3. Menú de señales. Es donde se elige la señal a muestrear.

4. Frecuencia de Muestreo. Es donde se varía la Frecuencia de muestreo.

6.6.2 Ejemplo

Figura 6.6c. Ejemplo (Muestreo de señales).

6.7 Muestreo de señal PAM

Es un programa que grafica una señal PAM muestreada con una frecuencia de

muestreo introducida por el usuario.

Figura 6.7a. Inicialización (Muestreo señal PAM).

63

El código de este programa consiste en ciclos if para elegir la señal a muestrear:

si señal == seno

seno(2*pi*10t) si señal== coseno coso(2*pi*10t)

si señal == diente de sierra diente de sierra(2*pi*10t)

si señal == triangular triangular(2*pi*10t) si señal == sinc

sinc(2*pi*10t) si señal == exponencial

exponencial(2*pi*10t) fin

Para graficar la señal muestreada se implemento un ciclo for:

desde i =1 hasta t

si (mod(i, frecuencia de muestreo) ==1) z =x (i) fin

n(i)=z fin señal muestreada = t , n


Figura 6.7b. Elementos del programa (Muestreo de señal PAM).

64

1. Frecuencia de muestreo. Es donde se introduce la Frecuencia de muestreo de

la señal.

2. Menú de señales. Es donde se elige la señal a muestrear.

3. Gráfica de la señal muestreada. Es donde se grafica la señal original y la señal

muestreada.

6.7.2 Ejemplo

Figura 6.7c. Ejemplo (Muestreo de señal PAM).

6.8 Modulación PSK y QAM

Es un programa que grafica una señal binaria aleatoria y su modulación PSK o QAM.

Figura 6.8a. Inicialización (Modulación digital).

65

Este programa consiste en generar una señal binaria aleatoriamente. Para esto, y con

el propósito de separar la señal con símbolos (M), se generó una señal decimal.

Luego se usó un ciclo for para convertir la señal decimal a binaria:

n= cantidad de símbolos a enviar

k=log2(M); señal = round(rand(1,n)*(M-1))

señal binaria=[] desde r=1 hasta length(señal) conversión=fliplr(dec2binvec(señal(r),k))

señal binaria=[señal binaria conversion] fin

Luego se utilizó un ciclo if para hacer la modulación:

Si tipo de modulación == psk

[y,t]=dmod(senial,1,1,100,'psk',M) Si no

[y,t]=dmod(senial,1,1,100,'qask',M) fin

6.8.1 Función dmod(x, Fc, Fd, Fs, 'method')

Modula la señal x con Frecuencia de la señal portadora Fc (Hz) y Frecuencia de

símbolos de la fuente Fd (Hz). La Frecuencia de muestreo es Fs (Hz), donde Fs > Fc

y Fs/Fd es un número positivo entero. La modulación es según se especifique en

“method”: ask para modulación en amplitud, psk para modulación en pase, fsk para

modulación en frecuencia, qask para modulación en amplitud y fase.


66

Figura 6.8b. Elementos del programa (Modulación digital).

1. Tipo de modulación. Es donde se elige el tipo de modulación: psk o qam.

2. M. Es donde se elige los símbolos a modular: 2, 4, 8, 16, 32, 64.

3. No. de símbolos a enviar. Es donde se especifica el número de símbolos a

enviar.

4. Señal. Es donde se muestra la señal que se va a modular.

5. Generar señal. Es el botón que al ser presionado genera y grafica una señal

digital para ser modulada, esta señal se genera aleatoriamente cada vez que se

presione este botón.

6. Modular. Es el botón que grafica la señal modulada.

7. Gráfica de señal digital. Es donde se grafica la señal digital generada.

8. Gráfica de señal modulada. Es donde se grafica la señal modulada.

6.8.3 Ejemplo de modulación PSK

Figura 6.8c. Ejemplo (Modulación PSK).

67

6.8.4 Ejemplo de modulación QAM

Figura 6.8d. Elementos del programa (Modulación QAM).

6.9 Codificación de Bloque Lineal

Es un programa que realiza la Codificación de Bloque Lineal de una palabra

introducida por el usuario. Además simula la detección de un error en la palabra

fuente y muestra la posición de este error mediante la matriz H y el síndrome.

Figura 6.9a. Inicialización (Codificación de bloque lineal).

La primer parte del código de este programa consiste en ciclos if para definir los

valores de los parámetros n, k y la matriz paridad P según la opción elegida en el

menú (n, k):

si menú == 1 n=4, k=2, P= [1 1; 1 0]

si menú == 2

68

n=5, k=2, P= [0 1 1; 1 0 1] si menú == 3 n=6, k=3, P= [1 1 1; 0 1 1; 1 1 0]

si menú == 4 n=7, k=4, P= [1 1 0; 0 1 1; 1 0 1; 1 1 1]

si menú == 5 n=7, k=5, P= [1 0; 0 1; 1 1; 1 0; 1 1] si menú == 6

n=9, k=6, P= [0 1 0; 1 0 0; 0 1 1; 1 1 0; 0 0 1; 1 0 1] si menú == 7

n=11, k=7, P= [0 1 0 1; 1 1 0 1; 1 0 1 0; 1 0 1 1; 1 1 1 0; 0 1 1 1; 0 0 0 1] si menú == 8 n=11, k=8, P= [0 1 0; 1 1 0; 1 0 1; 1 0 0; 1 1 1; 0 1 0; 0 1 1; 1 0 0]

Luego de establecer los parámetros, se define la matriz generadora y se codifica el

mensaje:

G = [eye (k) P]

Palabra código = encode (m,n,k,'linear',G) Al final se usa un ciclo if para revisar si se quiere simular un error, el cual se crea

aleatoriamente: H = [P' eye (n-k)]

si error == 1 vector error = [randerr (1,k) zeros (1,n-k)]

palabra recibida = bitxor (palabra código, vector error) sindrome = rem (r*H', 2) H transpuesta = H'

Dentro del ciclo if se crea un ciclo for para encontrar la posición del error:

desde j=1 hasta n fila = H transpuesta (j,:) si fila == síndrome

contador = contador + 1 si contador == 1

posición de error=j; fin fin

fin

69

6.9.1 Función encode (msg, n, k, 'method', genmat)

Es una función de Matlab que codifica el mensaje “msg” usando el método de

codificación especificado en “method”: linear, cyclic y hamming. La longitud de la

palabra código es n y la longitud del mensaje es k.


Figura 6.9b. Elementos del programa (Codificación de bloque lineal).

1. Palabra. Es donde se introduce la palabra a codificar.

2. Agregar un error. Es donde se elige si se quiere agregar un error

aleatoriamente.

3. Codificar. Es el botón que al ser presionado codifica la palabra.

4. n, k. Es donde se eligen los valores de n y k de 8 opciones: 4,2; 5,2; 6,3; 7,4;

7,5; 9,6; 11,7; y 11,8.

5. Palabra código. Es donde se muestra la palabra codificada.

6. Síndrome, H’ y posición de error. Es donde se muestra el síndrome, la matriz

transpuesta H y la posición de error si se seleccionó “Agregar un error”.

6.9.3 Ejemplo

70

Figura 6.9c. Ejemplo (Codificación de bloque lineal).

6.10 Codificación Hamming

Es un programa que realiza la Codificación Hamming de una palabra introducida por

el usuario. Este programa simula la detección de un error mediante los controles de

paridad.

Figura 6.10a. Inicialización (Codificación Hamming).

El código de la primer parte consiste en sumar la cantidad de unos que tiene la

palabra:

suma de b8 = sum(b8) suma de b4 = sum(b4)

suma de b2 = sum(b2)

71

suma de b4 = sum(b1)

Luego se establecen los valores de los controles de paridad mediante un ciclo if y la

función mod:

si mod (suma de bx, 2) == 0

cx = 0 si no

cx = 1 fin c=[b15 b14 b13 b12 b11 b10 b9 c4 b7 b6 b5 c3 b3 c2 c1]

Para agregar un error al codificar se implemento un ciclo if de la siguiente manera:

Si error == 1 vector de error = randerr (1, n)

palabra recibida = bitxor (c, vector de error)

A esta palabra recibida se le suman la cantidad de unos que tiene y se establecen los

nuevos controles de paridad. Luego para saber la posición del error se convierten

estos controles de paridad a decimales:

controles de paridad = [ce4 ce3 ce2 ce1] posición de error = binvec2dec (fliplr (controles de paridad))


Figura 6.10b. Elementos del programa (Codificación Hamming).

72



aleatoriamente.

3. Codificar. Es el botón que al ser presionado codifica la palabra.

4. m. Es donde se elige el valor de m: 3 o 4.

5. Dígitos binarios de control. Es donde se muestran los dígitos de control, según

se haya elegido en el menú m.


7. Posición de error y Controles de paridad. Es donde se muestra la posición de

error y los controles de paridad si se seleccionó “Agregar un error”.

6.10.2 Ejemplo

Figura 6.10c. Ejemplo (Codificación Hamming).

6.11 Codificación Cíclica

Es un programa que realiza la Codificación Cíclica de una palabra introducida por el

usuario. También simula la detección de un error mediante el síndrome.

73

Figura 6.11a. Inicialización (Codificación Cíclica).

Primero se usó un ciclo if para definir los valores de los parámetros n y k según la

opción elegida en el menú (n, k):

si menú == 1 n= 4, k=3

si menú == 2 n= 7, k=4 si menú == 3

n= 18, k=6 si menú == 4

n= 24, k=8

Para crear el polinomio generador se utilizó la función cyclpoly y la codificación se

hizo multiplicando este polinomio con el mensaje:

Polinomio generador = cyclpoly (n, k, 'min')

c = mod (conv (polinomio generador, mensaje), 2)

Para generar un error aleatoriamente en la palabra recibida se implementó de la

misma manera que en las anteriores codificaciones:

si error == 1 vector de error = [randerr (1,k) zeros (1,n-k)] palabra recibida = bitxor (c, vector de error)

posición de error = find (e) fin

6.11.1 Función cyclpoly (n, k, 'opt')

74

Es una función que regresa el vector fila que representa el polinomio generador de un

código cíclico teniendo una palabra fuente de longitud k y para una palabra código de

longitud n. La salida de esta función depende del argumento “opt”: min (polinomio

generador con menor peso), max (polinomio generador con mayor peso) y all (todos

los polinomios generadores).


Figura 6.11b. Elementos del programa (Codificación Cíclica).

1. Menú n, k. Es donde se eligen los valores de n y k: 4, 3; 7, 4; 18, 6 y 24, 8.



aleatoriamente.

4. Codificar. Es el botón que al ser presionado hace la codificación de la palabra.

5. Polinomio código. Es donde se muestra el polinomio código.

6. Polinomio generador. Es donde se muestra el polinomio generador de la

palabra.

7. Síndrome. Es donde se muestra el síndrome.

6.11.3 Ejemplo

75

Figura 6.11c. Ejemplo (Codificación Cíclica).

6.12 Codificación Convolucional

Es un programa que realiza la Codificación Convolucional de una palabra introducida

por el usuario.

Figura 6.12a. Inicialización (Codificación Convolucional).

Este programa esta implementado con un ciclo for para ir recorriendo la posición en la

palabra, y dentro de este ciclo se usó un ciclo if para hacer las operaciones según la

memoria elegida m:

desde i= longitud del mensaje hasta 1

s = [mensaje(i), y] y = s (1: m-1)

si m == 2 o1=s(1)

76

o2=bitxor (s(1), s(2)) o3=[] si m==3

o1=bitxor (s(1), s(3)) o2=bitxor (s(1), s(2))

o3=[] si m==4 o1=bitxor (s(1), s(2))

o2=s (4) o3=bitxor (s(1), s(3))

fin c=[o1 o2 o3 c] fin


Figura 6.12b. Elementos del programa (Codificación Convolucional).

1. m. Es donde se elige la memoria que va a tener la codificación: 2, 3 o 4.


3. Codificar. Es el botón que ejecuta la codificación.

4. Dibujo del codificador. Es donde se muestra el dibujo del codificador.


6.12.2 Ejemplo

77

Figura 6.12c. Ejemplo (Codificación Convolucional).

78

CAPÍTULO 7. Conclusiones

Matlab es un programa muy poderoso, por lo cual en este proyecto se quiso

aprovechar al máximo esta herramienta de programación para aplicaciones en los

conceptos de las clases de comunicaciones.

Realizar ejemplos de muchos de los temas de comunicaciones a veces se vuelve un

proceso complejo y tedioso, además de que hay riesgo de que se cometan errores en

los procedimientos o en las respuestas. Si se desarrollan estos ejemplos en Matlab, se

puede estar seguro que la respuesta es correcta. Matlab que ayuda a desarrollar

muchos problemas complejos de comunicaciones y ofrece una forma sencilla de

visualizar conceptos que de otra forma sería muy difícil observar en la realidad. Otra

de las ventajas que ofrece Matlab es el ahorro de tiempo y esfuerzo considerable.

El propósito de crear los programas en una GUI fue el facilitar el proceso práctico de

utilización, ya que a través de ésta, el usuario puede llevar a cabo dist intas funciones

sin necesidad de trabajar dentro de Matlab. Los programas están diseñados con el

propósito de facilitar el análisis y entendimiento de muchos de los temas de

comunicaciones. Los programas presentados además de demostrar una gran rapidez,

resultan simples en su comprensión. La importancia de este proyecto se basa en

facilitar los procesos para resolución de problemas de comunicaciones que requieren

que se resuelvan a papel y lápiz, pero con solo entender lo que se necesita realizar,

podemos lograr estos cálculos utilizando de manera esencial la herramienta Matlab.

Matlab es una excelente opción para el análisis y simulación de sistemas de

comunicaciones por la facilidad con la que se pueden visualizar los resultados, por la

sencillez de las instrucciones y por su variedad en las aplicaciones.

79

Referencias

[1] Amos Gilat. Matlab una introducción con ejemplos prácticos. Reverté. Barcelona. 2005.

[2] Haykin, Simon. Señales y Sistemas. Limusa Wiley. México, D.F. 2004. Pag. 21.

[3]

http://carreras.frba.utn.edu.ar/matematica/matapp/cursos/Primer_Curso_Final_2004.pdf, 26 de Septiembre.

[4] http://amasd.upb.edu.co/es/pregrado/programacion/Matlab6_GUI.pdf, 27 de Septiembre.

[6] www.astormastering.com.ar/Clase_1_Introducción_al_analisis_espectral.pdf, 3 de Octubre.

[7] Lathi B. P. Sistemas de Comunicación. McGrawHill. Edo de México. 1986.

Haykin Simon. Communication systems. Limusa Wiley. México, D.F. 2001.

Wayne Tomasi. Sistemas de Comunicaciones Electrónicas. Prentice-Hall. México.

2003.

Proakis J. K. Digital communications. Mcgraw-Hill. New York. 2001.

http://www.mathworks.com, 10 de Agosto.

80

APÉNDICE A. Archivo .m: Serie de Fourier

function varargout = Serie_Fourier(varargin) % SERIE_FOURIER Grafica la serie de fourier de distintas señales con

% distinto número de armónicas. % x = señal % t = tiempo % n = número de armónicas % a, b, serie = coeficientes de la Serie de Fourier % %

% Código de inicialización gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @Serie_Fourier_OpeningFcn, ... 'gui_OutputFcn', @Serie_Fourier_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(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

function Serie_Fourier_OpeningFcn(hObject, eventdata, handles,

varargin) handles.output = hObject; [x,map]=imread('none.jpg','jpg'); axes(handles.axes2) image(x),colormap(map),axis off guidata(hObject, handles);

function varargout = Serie_Fourier_OutputFcn(hObject, eventdata,

handles) varargout{1} = handles.output;

% --- Cálculo y graficación de la Serie de Fourier function popupmenu1_Callback(hObject, eventdata, handles) grafica=get(hObject,'Value'); t=-pi:pi/1000:pi; n=str2num(get(handles.n,'String')); a=zeros(1,n); b=zeros(1,n); if grafica==1 [x,map]=imread('none.jpg','jpg'); axes(handles.axes2) image(x),colormap(map),axis off

81

t=0; x=0; serie=0; elseif grafica==2 serie=(pi^2)/3; for m=1:n a(m)=(4/(m^2))*((-1)^m); b(m)=0; serie=serie+(a(m)*cos(m*t))+(b(m)*sin(m*t)); end [x,map]=imread('parabola.jpg','jpg'); axes(handles.axes2) image(x),colormap(map),axis off x=t.^2; elseif grafica==3 serie=0; for m=1:n a(m)=0; b(m)=(2/m)*(-1)^(m+1); serie=serie+(a(m)*cos(m*t))+(b(m)*sin(m*t)); end [x,map]=imread('recta.jpg','jpg'); axes(handles.axes2) image(x),colormap(map),axis off x=t; elseif grafica==4 serie=0; for m=1:n a(m)=0; b(m)=-2/(m*pi); serie=serie+(a(m)*cos(m*t))+(b(m)*sin(m*t)); end [x,map]=imread('diente.jpg','jpg'); axes(handles.axes2) image(x),colormap(map),axis off x=sawtooth(t); elseif grafica==5 serie=0; for m=1:n

a(m)=0; b(m)=(2/(m*pi))*(1-(-1)^m); serie=serie+(a(m)*cos(m*t))+(b(m)*sin(m*t)); end [x,map]=imread('cuadrada.jpg','jpg'); axes(handles.axes2) image(x),colormap(map),axis off x=square(t); elseif grafica==6 serie=0; for m=1:n a(m)=(4/((m^2)*(pi^2)))*((-1)^m-1); b(m)=0; serie=serie+(a(m)*cos(m*t))+(b(m)*sin(m*t)); end

82

[x,map]=imread('triangular.jpg','jpg'); axes(handles.axes2) image(x),colormap(map),axis off x=sawtooth(t,.5); end axes(handles.axes1) plot(t,x,'b','LineWidth',2); hold on plot(t,serie,'r','LineWidth',2); xlabel('t', 'Fontsize', 12) ylabel('f(t)', 'Fontsize', 12) title('Serie de Fourier con n armonicas','Fontsize', 12) grid on hold off guidata(hObject,handles)

% ------------------------------------------------------------------

-- function popupmenu1_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'),

get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end %-------------------------------------------------------------------

-- function n_Callback(hObject, eventdata, handles) %-------------------------------------------------------------------

-- function n_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'),

get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end %-------------------------------------------------------------------

-- function n_KeyPressFcn(hObject, eventdata, handles) set(handles.popupmenu1,'Value',1);

NOTA: Todos los archivos .m de los programas que se realizaron cuentan con el mismo código de inicialización y funciones CreateFcn que el mostrado en el

programa Serie de Fourier; por lo tanto, en los casos donde no se muestren estas funciones será debido a que son similares a este programa y sólo se mostrará la parte más importante del código de cada uno de los programas.

83

APÉNDICE B. Archivo .m: Transformada de Fourier

function popupmenu1_Callback(hObject, eventdata, handles) grafica=get(hObject,'Value');

p=256; t=0:59; f=(0:p-1)/p; if grafica==1 x=0; elseif grafica==2 x=cos(2*pi*t/10); elseif grafica==3 x=sawtooth(2*pi*t/10); elseif grafica==4 x=sinc(2*pi*t/10); elseif grafica==5 x=square(2*pi*t/10); elseif grafica==6 x=(t<0).*0+(t>=0).*exp(2*pi*t/10); elseif grafica==7 x=(t<-1).*0+(t>1).*0+(t>=-1).*1+(t<=1).*1; elseif grafica==8 x=sin(2*pi*t/10); end tf=abs(fft(x,p)); axes(handles.axes1) plot(t,x) title('Señal original') xlabel('t') ylabel('x(t)') grid on axes(handles.axes2) plot(f,tf) title('Transformada de Fourier') xlabel('w'); ylabel('|F(w)|') grid on guidata(hObject, handles);

84

APÉNDICE C. Archivo .m: Convolución y Correlación de señales

function popupmenu1_Callback(hObject, eventdata, handles) grafica=get(hObject,'Value');

t=handles.t; % graficas if grafica==1

handles.x=(t<0&t>3).*0+(t>=0&t<=3).*t; elseif grafica==2 handles.x=ustep(t); elseif grafica==3

handles.x=(t<-1&t>1).*0+(t>=-1&t<=1).*1; elseif grafica==4

handles.x=sin(t); end % graficar x(t) axes(handles.axes1) plot(t,handles.x,'LineWidth',2) xlabel('t') ylabel('x(t)') grid on guidata(hObject,handles)

function popupmenu2_Callback(hObject, eventdata, handles) grafica2=get(hObject,'Value'); t=handles.t; % graficas if grafica2==1

handles.h=(t<-1&t>1).*0+(t>=-1&t<=1).*1; elseif grafica2==2

handles.h=ustep(t); elseif grafica2==3

handles.h=(t<0&t>3).*0+(t>=0&t<=3).*-t; elseif grafica2==4

handles.h=sin(t); end % graficar h(t) axes(handles.axes2) plot(t,handles.h,'LineWidth',2) xlabel('t') ylabel('h(t)') grid on guidata(hObject,handles)

function popupmenu3_Callback(hObject, eventdata, handles) grafica3=get(hObject,'Value'); %graficas if grafica3==1

handles.x=[1 1 1 1 1]; handles.tiempox=0:1:4;

elseif grafica3==2 handles.x=[2 1 1 1]; handles.tiempox=0:1:3;

elseif grafica3==3

85

handles.x=[1 2]; handles.tiempox=0:1:1; elseif grafica3==4 handles.x=[1 1 1]; handles.tiempox=-1:1:1; elseif grafica3==5 handles.x=2; handles.tiempox=0; end % graficar x(t) axes(handles.axes1) stem(handles.tiempox,handles.x,'LineWidth',2) xlabel('n') ylabel('x(n)') grid on guidata(hObject,handles)

function popupmenu4_Callback(hObject, eventdata, handles) grafica4=get(hObject,'Value'); % graficas if grafica4==1 handles.h=[2 1 1 1]; handles.tiempoh=0:1:3; elseif grafica4==2 handles.h=[1 1 1 1 1]; handles.tiempoh=0:1:4; elseif grafica4==3 handles.h=[1 2 3]; handles.tiempoh=1:1:3; elseif grafica4==4 handles.h=[1 1 1]; handles.tiempoh=-1:1:1; elseif grafica4==5 handles.h=2; handles.tiempoh=0; end % graficar h(t) axes(handles.axes2) stem(handles.tiempoh,handles.h,'LineWidth',2) xlabel('n') ylabel('h(n)') grid on guidata(hObject,handles)

function graficar_Callback(hObject, eventdata, handles) x=handles.x; h=handles.h; op=get(handles.convolucion,'Value'); tipo_s=get(handles.ct,'Value'); if op==1

y = conv(x,h); else

y = xcorr(x,h); end

86

if tipo_s==1

lx=length(x)-1; lh=length(h)-1; n=-lh:lx; axes(handles.axes3) plot(n./1000,y./1000,'LineWidth',2) % graficar señal CT xlabel('t') ylabel('y(t)') else axes(handles.axes3) stem(y,'LineWidth',2) % graficar señal DT xlabel('n') ylabel('y(n)') end grid on guidata(hObject,handles)

87

APÉNDICE D. Archivo .m: Modulación AM, FM y PM function popupmenu1_Callback(hObject, eventdata, handles) grafica1=get(hObject,'Value');

t=handles.t; Am=str2double(get(handles.edit_Am,'String')); fm=str2double(get(handles.edit_fm,'String')); fc=str2double(get(handles.edit_fc,'String')); if grafica1==2 moduladora=Am*sawtooth(2*pi*fm*t); elseif grafica1==3 moduladora=Am*square(2*pi*fm*t); elseif grafica1==4 moduladora=Am*sin(2*pi*fm*t); elseif grafica1==5 moduladora=Am*cos(2*pi*fm*t); else moduladora=0; end tipo_mod=get(handles.popupmenu3,'Value'); if tipo_mod==1 axes(handles.axes1) plot(t,moduladora,'Color','r','LineWidth',2) title('Señal moduladora'); ylabel('A'); xlabel('Tiempo'); grid on; axes(handles.axes2) senial = amod(moduladora,fc,1000,'am'); plot(t,senial) hold on; plot(t,(moduladora)+Am,'--','Color','r'); hold off; title('Señal AM '); ylabel('Amplitud'); xlabel('Tiempo'); grid on elseif tipo_mod==2 axes(handles.axes1) plot(t,moduladora,'Color','r','LineWidth',2) title('Señal moduladora'); ylabel('A'); xlabel('Tiempo');

grid on; axes(handles.axes2) senial = amod(moduladora,fc,1000,'fm'); plot(t,senial) hold on; plot(t,moduladora,'--','Color','r'); hold off; title('Señal FM '); ylabel('Frecuencia'); xlabel('Tiempo'); grid on

88

elseif tipo_mod==3 axes(handles.axes1) plot(t,moduladora,'Color','r','LineWidth',2) title('Señal moduladora'); ylabel('A'); xlabel('Tiempo'); grid on; axes(handles.axes2) senial = amod(moduladora,fc,1000,'pm'); plot(t,senial) hold on; plot(t,moduladora,'--','Color','r'); hold off; title('Señal PM '); ylabel('Fase'); xlabel('Tiempo'); grid on end guidata(hObject, handles);

89

APÉNDICE E. Archivo .m: Conversión dB a Watts y Watts a dB

function convertir_Callback(hObject, eventdata, handles) w_db=get(handles.w_db,'Value');

db_w=get(handles.db_w,'Value'); w_dbm=get(handles.w_dbm,'Value'); dbm_w=get(handles.dbm_w,'Value'); if db_w==1 db=str2double(get(handles.db,'String')); ans_w=10^(db/10); set(handles.resultado2,'String',ans_w); elseif w_db==1 p1=str2double(get(handles.p1,'String')); p2=str2double(get(handles.p2,'String')); ans_db=10*log10(p2/p1); set(handles.resultado1,'String',ans_db); elseif dbm_w==1 db=str2double(get(handles.db,'String')); ans_w=10^(db/10); set(handles.resultado2,'String',ans_w); elseif w_dbm==1 p1=.001; p2=str2double(get(handles.p2,'String')); ans_db=10*log10(p2/p1); set(handles.resultado1,'String',ans_db); end guidata(hObject, handles);

90

APÉNDICE F. Archivo .m: Muestreo de señal

function slider1_Callback(hObject, eventdata, handles) F_muestreo=round(100*get(hObject,'Value'));

set(handles.text_fm,'string',num2str(F_muestreo)); muestras=str2double(get(handles.edit_n,'string')); F=str2double(get(handles.edit_f,'string')); n=0:muestras-1; if (get(handles.radiobutton1,'Value')==1) x=sin(2*pi*F*(n./F_muestreo)); elseif(get(handles.radiobutton2,'Value')==1) x=cos(2*pi*F*(n./F_muestreo)); elseif(get(handles.radiobutton3,'Value')==1) x=square(2*pi*F*(n./F_muestreo)); elseif(get(handles.radiobutton4,'Value')==1) x=sawtooth(2*pi*F*(n./F_muestreo)); elseif(get(handles.radiobutton5,'Value')==1) x=sawtooth((2*pi*F*(n./F_muestreo)),.5); end axes(handles.axes1) stem(n,x,'Linewidth',1.5) title('Señal muestreada ') xlabel('n') ylabel('x(n)') grid on guidata(hObject, handles);

91

APÉNDICE G. Archivo .m: Muestreo de señal PAM

function uipanel1_SelectionChangeFcn(hObject, eventdata, handles) Ts = 1/10000;

t=0:Ts:.2; if hObject==handles.b1 x= sin(2*pi*10*t); elseif hObject==handles.b2 x= cos(2*pi*10*t); elseif hObject==handles.b3 x= sawtooth(2*pi*10*t); elseif hObject==handles.b4 x= sawtooth(2*pi*10*t,.5); elseif hObject==handles.b5 x= sinc(2*pi*10*t); elseif hObject==handles.b6 x= exp(2*pi*10*t); end f=str2double(get(handles.frec,'String')); n = zeros(1,length(t)); for i =1:length(t) if(mod(i,f)==1) % ciclo para que x cambie cada f veces z =x(i); end n(i)=z; end plot(t,x,'--') hold on plot(t,n,'black','Linewidth',1.5); xlabel('t'); ylabel('y(n)'); hold off guidata(hObject, handles);

92

APÉNDICE H. Archivo .m: Modulación PSK y QAM

function Mn_Callback(hObject, eventdata, handles) axes(handles.axes2)

cla reset set(handles.text_senial,'String',''); set(handles.modular,'Enable','off'); m1=get(hObject,'Value'); if m1==2 handles.M=2; elseif m1==3 handles.M=4; elseif m1==4 handles.M=8; elseif m1==5 handles.M=16; elseif m1==6 handles.M=32; elseif m1==7 handles.M=64; end guidata(hObject, handles);

function generar_Callback(hObject, eventdata, handles) set(handles.modular,'Enable','on'); n=str2double(get(handles.n,'String')); u=[]; M=handles.M; k=log2(M); handles.senial = round(rand(1,n)*(M-1)); binaria=[]; for r=1:length(handles.senial) conver=fliplr(dec2binvec(handles.senial(r),k)); binaria=[binaria conver]; end binaria2=reshape(dec2bin(handles.senial,k).',1,k*n); set(handles.text_senial,'String',binaria2); for i=1:(k*n) if binaria(i)==1 u=[u ones(1,100)]; elseif binaria(i)==0 u=[u zeros(1,100)]; end end axes(handles.axes2) cla reset axes(handles.axes1) plot(u,'Linewidth',1.5) guidata(hObject, handles);

function modular_Callback(hObject, eventdata, handles) tipo=get(handles.tipo_mod,'Value'); senial=handles.senial; M=handles.M;

93

if tipo==1 [y,t]=dmod(senial,1,1,100,'psk',M); else [y,t]=dmod(senial,1,1,100,'qask',M); end axes(handles.axes2) plot(t,y,'Linewidth',1.5); guidata(hObject, handles);

94

APÉNDICE I. Archivo .m: Codificación de Bloque Lineal

function codificar_Callback(hObject, eventdata, handles) error=get(handles.check_error,'Value'); ka=get(handles.popupmenu_k,'Value'); count=0; if ka==1 k=2; n=4; P=[1 1; 1 0]; m_0= str2double(get(handles.edit1,'String')); m_1= str2double(get(handles.edit2,'String')); m=[m_0 m_1]; if ((m_0~=0) && (m_0~=1)) || ((m_1~=0) && (m_1~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end elseif ka==2 k=2; n=5; P=[0 1 1; 1 0 1]; m_0= str2double(get(handles.edit1,'String')); m_1= str2double(get(handles.edit2,'String')); m=[m_0 m_1]; if ((m_0~=0) && (m_0~=1)) || ((m_1~=0) && (m_1~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end elseif ka==3 k=3; n=6; P=[1 1 1; 0 1 1; 1 1 0]; m_0= str2double(get(handles.edit1,'String')); m_1= str2double(get(handles.edit2,'String')); m_2= str2double(get(handles.edit3,'String')); m=[m_0 m_1 m_2]; if ((m_0~=0) && (m_0~=1)) || ((m_1~=0) && (m_1~=1)) || ...

((m_2~=0) && (m_2~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end

elseif ka==4 k=4; n=7; P=[1 1 0; 0 1 1; 1 0 1; 1 1 1]; m_0= str2double(get(handles.edit1,'String')); m_1= str2double(get(handles.edit2,'String')); m_2= str2double(get(handles.edit3,'String')); m_3= str2double(get(handles.edit4,'String')); m=[m_0 m_1 m_2 m_3]; if ((m_0~=0) && (m_0~=1)) || ((m_1~=0) && (m_1~=1)) || ...

((m_2~=0) && (m_2~=1)) || ((m_3~=0) && (m_3~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end elseif ka==5 k=5;

95

n=7; P=[1 0; 0 1; 1 1; 1 0; 1 1]; m_0= str2double(get(handles.edit1,'String')); m_1= str2double(get(handles.edit2,'String')); m_2= str2double(get(handles.edit3,'String')); m_3= str2double(get(handles.edit4,'String')); m_4= str2double(get(handles.edit5,'String')); m=[m_0 m_1 m_2 m_3 m_4]; if ((m_0~=0) && (m_0~=1)) || ((m_1~=0) && (m_1~=1)) ||...

((m_2~=0) && (m_2~=1)) || ((m_3~=0) && (m_3~=1)) || ((m_4~=0)..

&& (m_4~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end elseif ka==6 k=6; n=9; P=[0 1 0; 1 0 0; 0 1 1; 1 1 0; 0 0 1; 1 0 1]; m_0= str2double(get(handles.edit1,'String')); m_1= str2double(get(handles.edit2,'String')); m_2= str2double(get(handles.edit3,'String')); m_3= str2double(get(handles.edit4,'String')); m_4= str2double(get(handles.edit5,'String')); m_5= str2double(get(handles.edit6,'String')); m=[m_0 m_1 m_2 m_3 m_4 m_5]; if ((m_0~=0) && (m_0~=1)) || ((m_1~=0) && (m_1~=1)) || ...

((m_2~=0) && (m_2~=1)) || ((m_3~=0) && (m_3~=1)) || ((m_4~=0)...

&& (m_4~=1)) || ((m_5~=0) && (m_5~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end elseif ka==7 k=7; n=11; P=[0 1 0 1; 1 1 0 1; 1 0 1 0; 1 0 1 1; 1 1 1 0; 0 1 1 1; 0 0 0

1]; m_0= str2double(get(handles.edit1,'String')); m_1= str2double(get(handles.edit2,'String')); m_2= str2double(get(handles.edit3,'String')); m_3= str2double(get(handles.edit4,'String')); m_4= str2double(get(handles.edit5,'String'));

m_5= str2double(get(handles.edit6,'String')); m_6= str2double(get(handles.edit7,'String')); m=[m_0 m_1 m_2 m_3 m_4 m_5 m_6]; if ((m_0~=0) && (m_0~=1)) || ((m_1~=0) && (m_1~=1)) || ...

((m_2~=0) && (m_2~=1)) || ((m_3~=0) && (m_3~=1)) || ((m_4~=0)..

&& (m_4~=1)) || ((m_5~=0) && (m_5~=1)) || ((m_6~=0) && (m_6~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end elseif ka==8 k=8; n=11; P=[0 1 0; 1 1 0; 1 0 1; 1 0 0; 1 1 1; 0 1 0; 0 1 1; 1 0 0]; m_0= str2double(get(handles.edit1,'String')); m_1= str2double(get(handles.edit2,'String')); m_2= str2double(get(handles.edit3,'String'));

96

m_3= str2double(get(handles.edit4,'String')); m_4= str2double(get(handles.edit5,'String')); m_5= str2double(get(handles.edit6,'String')); m_6= str2double(get(handles.edit7,'String')); m_7= str2double(get(handles.edit8,'String')); m=[m_0 m_1 m_2 m_3 m_4 m_5 m_6 m_7]; if ((m_0~=0) && (m_0~=1)) || ((m_1~=0) && (m_1~=1)) || ...

((m_2~=0) && (m_2~=1)) || ((m_3~=0) && (m_3~=1)) || ((m_4~=0)...

&& (m_4~=1)) || ((m_5~=0) && (m_5~=1)) || ((m_6~=0) && ...

(m_6~=1)) || ((m_7~=0) && (m_7~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end end G = [eye(k) P]; c = encode(m,n,k,'linear',G); H=[P' eye(n-k)]; if error==1 e=[randerr(1,k) zeros(1,n-k)]; r=bitxor(c,e); s=rem(r*H',2); Htran=H'; for j=1:1:n fila=Htran(j,:); if fila==s count=count+1; if count==1 pos_error=j; end end end set(handles.text_pos,'String',num2str(pos_error)); set(handles.text7,'Visible','on'); set(handles.text9,'Visible','on'); set(handles.text_H,'String',num2str(H')); else r=c; s=rem(r*H',2); end set(handles.text10,'Visible','on');

set(handles.text_sin,'String',num2str(s)); set(handles.text_c,'String',num2str(r)); guidata(hObject, handles);

97

APÉNDICE J. Archivo .m: Codificación Hamming

function codificar_Callback(hObject, eventdata, handles) menu_m=get(handles.popupmenu1,'Value');

error=get(handles.check_error,'Value'); if menu_m==1 m=3; m1=str2num(get(handles.edit1,'String')); m2=str2num(get(handles.edit2,'String')); m3=str2num(get(handles.edit3,'String')); m4=str2num(get(handles.edit4,'String')); elseif menu_m==2 m=4; m1=str2num(get(handles.edit1,'String')); m2=str2num(get(handles.edit2,'String')); m3=str2num(get(handles.edit3,'String')); m4=str2num(get(handles.edit4,'String')); m5=str2num(get(handles.edit5,'String')); m6=str2num(get(handles.edit6,'String')); m7=str2num(get(handles.edit7,'String')); m8=str2num(get(handles.edit8,'String')); m9=str2num(get(handles.edit9,'String')); m10=str2num(get(handles.edit10,'String')); m11=str2num(get(handles.edit11,'String')); end n=2^m-1; %operaciones codigo hamming if menu_m==1 if ((m1~=0) && (m1~=1)) || ((m2~=0) && (m2~=1)) || ((m3~=0) &&

(m3~=1)) || ((m4~=0) && (m4~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); else

b7=m1; b6=m2; b5=m3; b3=m4; b4=[b7 b6 b5]; b2=[b7 b6 b3]; b1=[b7 b5 b3]; unosb4=sum(b4); unosb2=sum(b2); unosb1=sum(b1); if mod(unosb4,2)==0

c3=0; else c3=1; end if mod(unosb2,2)==0 c2=0; else c2=1; end if mod(unosb1,2)==0 c1=0;

98

else c1=1; end c=[b7 b6 b5 c3 b3 c2 c1]; if error==1 e=randerr(1,n); r=bitxor(c,e); unos_ce1=sum([r(1,7) r(1,5) r(1,3) r(1,1)]); unos_ce2=sum([r(1,7) r(1,6) r(1,3) r(1,2)]); unos_ce3=sum([r(1,7) r(1,6) r(1,5) r(1,4)]); if mod(unos_ce1,2)==0 ce1=0; else ce1=1; end if mod(unos_ce2,2)==0 ce2=0; else ce2=1; end if mod(unos_ce3,2)==0 ce3=0; else ce3=1; end con_par=[ce3 ce2 ce1]; pos=binvec2dec(fliplr(con_par)); cs1=[r(1,7) r(1,6) r(1,5)]; ccs3=r(1,4); cs2=r(1,3); ccs2=r(1,2); ccs1=r(1,1); else cs1=[b7 b6 b5]; ccs3=c3; cs2=b3; ccs2=c2; ccs1=c1; end

end elseif menu_m==2 if ((m1~=0) && (m1~=1)) || ((m2~=0) && (m2~=1)) || ((m3~=0) &&

(m3~=1)) || ((m4~=0) && (m4~=1)) || ((m5~=0) && (m5~=1)) ||

((m6~=0) && (m6~=1)) || ((m7~=0) && (m7~=1)) || ((m8~=0) && (m8~=1))

|| ((m9~=0) && (m9~=1))|| ((m10~=0) && (m10~=1)) || ((m11~=0) &&

(m11~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); else b15=m1; b14=m2; b13=m3; b12=m4; b11=m5; b10=m6;

99

b9=m7; b7=m8; b6=m9; b5=m10; b3=m11; b8=[b9 b10 b11 b12 b13 b14 b15]; b4=[b5 b6 b7 b12 b13 b14 b15]; b2=[b3 b6 b7 b10 b11 b14 b15]; b1=[b3 b5 b7 b9 b11 b13 b15]; unosb8=sum(b8); unosb4=sum(b4); unosb2=sum(b2); unosb1=sum(b1); if mod(unosb8,2)==0 c4=0; else c4=1; end if mod(unosb4,2)==0 c3=0; else c3=1; end if mod(unosb2,2)==0 c2=0; else c2=1; end if mod(unosb1,2)==0 c1=0; else c1=1; end c=[b15 b14 b13 b12 b11 b10 b9 c4 b7 b6 b5 c3 b3 c2 c1]; if error==1 e=randerr(1,n); r=bitxor(c,e); unos_ce1=sum([r(1,15) r(1,13) r(1,11) r(1,9) r(1,7)...

r(1,5) r(1,3) r(1,1)]);

unos_ce2=sum([r(1,15) r(1,14) r(1,11) r(1,10) r(1,7)...

r(1,6) r(1,3) r(1,2)]); unos_ce3=sum([r(1,15) r(1,14) r(1,13) r(1,12) r(1,7)...

r(1,6) r(1,5) r(1,4)]); unos_ce4=sum([r(1,15) r(1,14) r(1,13) r(1,12) r(1,11)..

r(1,10) r(1,9) r(1,8)]); if mod(unos_ce1,2)==0 ce1=0; else ce1=1; end if mod(unos_ce2,2)==0 ce2=0; else ce2=1;

100

end if mod(unos_ce3,2)==0 ce3=0; else ce3=1; end if mod(unos_ce4,2)==0 ce4=0; else ce4=1; end con_par=[ce4 ce3 ce2 ce1]; pos=binvec2dec(fliplr(con_par)); cs1=[r(1,15) r(1,14) r(1,13) r(1,12) r(1,11) r(1,10)...

r(1,9)]; cs2=[r(1,7) r(1,6) r(1,5)]; cs3=r(1,3); ccs4=r(1,4); ccs3=r(1,3); ccs2=r(1,2); ccs1=r(1,1); else cs1=[b15 b14 b13 b12 b11 b10 b9]; cs2=[b7 b6 b5]; cs3=b3; ccs4=c4; ccs3=c3; ccs2=c2; ccs1=c1; end end end guidata(hObject, handles);

101

APÉNDICE K. Archivo .m: Codificación Cíclica

function codificar_Callback(hObject, eventdata, handles) ka=get(handles.popupmenu1,'Value');

error=get(handles.check_error,'Value'); if ka==1 n=4; k=3; m1=str2num(get(handles.edit1,'String')); m2=str2num(get(handles.edit2,'String')); m3=str2num(get(handles.edit3,'String')); mens=[m1 m2 m3]; if ((m1~=0) && (m1~=1)) || ((m2~=0) && (m2~=1)) || ((m3~=0)...

&& (m3~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end elseif ka==2 n=7; k=4; m1=str2num(get(handles.edit1,'String')); m2=str2num(get(handles.edit2,'String')); m3=str2num(get(handles.edit3,'String')); m4=str2num(get(handles.edit4,'String')); mens=[m1 m2 m3 m4]; if ((m1~=0) && (m1~=1)) || ((m2~=0) && (m2~=1)) || ((m3~=0)...

&& (m3~=1)) || ((m4~=0) && (m4~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end elseif ka==3 n=18; k=6; m1=str2num(get(handles.edit1,'String')); m2=str2num(get(handles.edit2,'String')); m3=str2num(get(handles.edit3,'String')); m4=str2num(get(handles.edit4,'String')); m5=str2num(get(handles.edit5,'String')); m6=str2num(get(handles.edit6,'String')); mens=[m1 m2 m3 m4 m5 m6]; if ((m1~=0) && (m1~=1)) || ((m2~=0) && (m2~=1)) || ((m3~=0)...

&& (m3~=1)) || ((m4~=0) && (m4~=1)) || ((m5~=0) && (m5~=1))...

|| ((m6~=0) && (m6~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end

elseif ka==4 n=24; k=8; m1=str2num(get(handles.edit1,'String')); m2=str2num(get(handles.edit2,'String')); m3=str2num(get(handles.edit3,'String')); m4=str2num(get(handles.edit4,'String')); m5=str2num(get(handles.edit5,'String')); m6=str2num(get(handles.edit6,'String')); m7=str2num(get(handles.edit7,'String')); m8=str2num(get(handles.edit8,'String'));

102

mens=[m1 m2 m3 m4 m5 m6 m7 m8]; if ((m1~=0) && (m1~=1)) || ((m2~=0) && (m2~=1)) || ((m3~=0)...

&& (m3~=1)) || ((m4~=0) && (m4~=1)) || ((m5~=0) && (m5~=1))...

|| ((m6~=0) && (m6~=1)) || ((m7~=0) && (m7~=1)) || ((m8~=0)...

&& (m8~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); end end pol_gen = cyclpoly(n,k,'min'); c = mod(conv(pol_gen,mens),2); if error==1 e=[randerr(1,k) zeros(1,n-k)]; r=bitxor(c,e); pos=find(e); set(handles.text9,'Visible','on'); set(handles.text_e,'String',num2str(pos)); else r=c; set(handles.text9,'Visible','off'); set(handles.text_e,'String',''); end [q res]=deconv(r,pol_gen); s=mod(abs(res),2); set(handles.text_g,'String',num2str(pol_gen)); set(handles.text_c,'String',num2str(r)); set(handles.text_s,'String',num2str(s)); guidata(hObject, handles);

103

APÉNDICE L. Archivo .m: Codificación Convolucional

function codificar_Callback(hObject, eventdata, handles) c=[]; m=handles.m; u1=str2num(get(handles.edit1,'String')); u2=str2num(get(handles.edit2,'String')); u3=str2num(get(handles.edit3,'String')); u4=str2num(get(handles.edit4,'String')); mje=[u1 u2 u3 u4]; lmje=length(mje); y=zeros(1,m-1);

if ((u1~=0) && (u1~=1)) || ((u2~=0) && (u2~=1)) || ((u3~=0)...

&& (u3~=1)) || ((u4~=0) && (u4~=1)) errordlg('Introduzca números binarios',' Palabra Fuente '); else for i=lmje:-1:1 s=[mje(i),y]; y=s(1:m-1); if m==2 o1=s(1);

o2=bitxor(s(1),s(2)); o3=[]; elseif m==3 o1=bitxor(s(1),s(3)); o2=bitxor(s(1),s(2)); o3=[]; elseif m==4 o1=bitxor(s(1),s(2)); o2=s(4); o3=bitxor(s(1),s(3));

end c=[o1 o2 o3 c]; end end set(handles.text_c,'String',num2str(c)); guidata(hObject, handles);

Ejemplos Jercicios de Comunicaciones en Matlab

Documents

Transcript of Ejemplos Jercicios de Comunicaciones en Matlab