apoyos didacticos para la clase de comunicaciones con

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
•
Computadora con Internet
•
Acceso a UACJ/UTEP
•
Anotaciones (libreta y lápiz)
•
Computadora
Meta 2.1
Meta 3.1
Meta 4.1
•
Computadora con Internet
•
Acceso a UACJ/UTEP
•
Anotaciones (libreta y lápiz)
•
Computadora
•
Anotaciones (libreta y lápiz)
•
Computadora
•
Anotaciones (libreta y lápiz)
•
Software Matlab 7.0
•
Computadora con Internet
•
Impresora
Meta 5.1
Meta 6.1
Meta 7.1
Plan de trabajo:
A continuación se muestra un cronograma con las actividades a realizar antes mencionadas:
Cronograma de acciones
Acciones
Numero
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
1
Agosto
Septiembre
Octubre
Noviembre
Diciembre
Semana
Semana
Semana
Semana
Semana
2
3
4
1
2
3
4 1
2
3
4
1
2
3
4
1
2
3
4
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
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 obtener el título de
INGENIERO EN SISTEMAS DIGITALES Y COMUNICACIONES
UNIVERSIDAD AUTÓNOMA DE CIUDAD JUÁREZ
Noviembre del 2010
UNIVERSIDAD AUTÓNOMA DE CIUDAD JUÁREZ
Instituto de Ingeniería y Tecnología
EVALUACiÓN DE EXAMEN
Fecha: 26 de Noviembre del 2010
Horario: 09:00 - 11 :00 HRS.
PROFESIONAL INTRACURRICULAR
NIVEL: LICENCIATURA
I 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°._
2°_
3°.4°._
Exposición por parte de los alumnos (máximo 20 minutos).
Réplica por parte del jurado.
Comentarios ylo recomendaciones.
Entrega de resultados.
Nombre del alumno: Sandra Ivonne Lara Sotelo
_-"Z",,--1-__
Calificación Maestro de la materia (30%)
3<1
Calificación Director de Trabajo (40%)
Calificación del Jurado (30%)
__0(5
TOTAL
Se recomienda que el documento se deposite para consulta en la BIBLIOTECA
SiD
NoD
Jurado
Director de Trabajo
Coordinador de la Materia
"Proyecto de Titulación"
r. Viclor Manuel Hinoslrozo Zubia
Dr. Viciar Manuel Hinoslrozo Zubia
/
a
/
/'
Oro' Nelly Gordillo Coslíllo
FIRMADO EN ORIGINAL
•
u·e
DEP
11
INGENIF
y CO,
~
ENTO Dé
FLECTRlc
JT A\l r\
ii
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.
iii
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.
__________________________
Sandra Ivonne Lara Sotelo
iv
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.
v
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
vi
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
vii
Í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
viii
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
ix
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
x
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.
1
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
2
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.
3
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.
4

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.
5
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
6
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
7
7
8
9
Matlab dispone de varias formas de definir matrices. El introd ucirlas 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
8
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
9
últimos valores de retorno de la función.
2.5 Inte rfaz 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
10
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 interfa z 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].
11
Las Componentes principales de GUIDE son:

Barra de Menús: Es donde se encuentran las funcione s 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:
12
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.
13

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.
14
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.
15
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.
16
1 t  0

1
u (t )   t  0
2
0 t  0

Figura 3.1. Función Escalón
unitario.
Función Rampa. Es una señal que cambia constantemente
con el tiempo.
t t  0 


ramp(t )  
  u ( )d  tu (t )
0 t  0


Figura 3.2 Función Rampa.
Función Sinc. Tiene una singularidad evitable en cero, que generalmente se redefine
específicamente como igual a 1.
sin c(t ) 
sen(t )
t
Figura 3.3. Función Sinc.
Función Seno. Es aquella que asocia a cada ángulo el valor del seno correspondiente.
17
y(t)=Asin(t)
Figura 3.4. Función Seno.
Función Coseno. Aquella que asocia a cada ángulo el valor del coseno
correspondiente.
y(t)=cos(t)
Figura 3.5. Función Coseno.
Función Triangular. Presenta unas velocidades de subida y bajada (Slow Rate)
constantes.
y(t)=
Figura 3.6. Función Triangular.
Función Diente de Sierra.
Figura 3.7. Función Diente de sierra
18
Función Cuadrática.
Figura 3.8. 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
19
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
20
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.
Amplitud
(Potencia)
Medición en el
dominio del tiempo
Medición en el
dominio de la frecuencia
Figura 3.9. Transformada de Fourier
21
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)
Translación en la frecuencia
e jt xt 
Conjugación
x*(t)
X*(-j ω)
Inversión en el tiempo
x(-t)
X(-j ω)
Cambio de escala en tiempo y
x(at)
frecuencia
Convolución
x(t)*y(t)
e jt0 X  j 
x(j(ω-ω0))
1  j 
X

a  a 
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.
22
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”.
23
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 f 1 (t), quedando f ( ).
2. Reemplazar t por (- ) en f 2 (t). Esto hace girar a la función f 2 ( ) 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 origen del
sistema móvil esta en
= t; el origen fijo, en
= 0. La función en el sistema móvil
representa f 2 ( t - ); la función en el sistema fijo, f 1 ( ).
4. En cualquier desplazamiento relativo entre los ejes de referencia, por ejemplo, t 0 ,
debe hallarse el área bajo el producto de las dos funciones.
5. Este procedimiento debe repetirse para diferentes valores t = t 0 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
izquierda), t es negativo. Si es sobre el eje positivo
(a la
(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,
24
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
25
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)
26
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π (f p + Δ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) ]
27
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
28
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 P 2 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
29
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 f M. Si hacemos que los valores de m (t) sean validos solo a
intervalos regulares separados por los tiempos Ts ≤ 1/2 f M, 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)
30
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 f s, en el
caso de PAM es la misma que la requerida por el teorema de muestreo, es decir, f s>
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.
31
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 v 1 (t) si la señal es cero y una señal v 2 (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 frecue ncia, 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.
32
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
cuadratura, sen
ct
), y el eje vertical representa la componente de frecuencia en
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 NT b = 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
33
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.
a)
b)
Figura 4.2. Diagramas de constelación de PSK. a) BPSK. b) QPSK
34
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)
35
c)
d)
Figura 4.3. Diagramas de constelación de QAM. a) 4QAM. b) 8-QAM. c) 16-QAM. d) 32-QAM.
36
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
37
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 fue nte (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
38
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
39
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 . . . m k-1 b0 b1 b2 . . . bn-k-1
Donde m0 .......................m k-1 son los bits del mensaje original y b0 .......................bnk-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 m k-1
Donde los Pij deben ser tales que la matriz generadora del código tenga filas
independientes y las ecuaciones de paridad sean iguales.
40
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
. . . m k-1 )
b = (b0 b1
. . . bn-k-1 )
c = (c0 c1
. . . 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índro me. En este proceso se
utiliza la matriz de chequeo de paridad, que se define de la siguiente forma:
H = [Pt | I]
41
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
42
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,..........
43
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, el 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
44
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)
45
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.
46
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.
47
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:
48
= valor calculado
desde m=1 hasta n
= valor calculado
= valor calculado
suma = suma+( (m)*cos(m*t))+(
fin
(m)*sen(m*t))
El valor de suma será el valor de la serie de Fourier. Este valor se grafica con respecto
al tiempo.
6.1.1 Ele mentos del programa
Figura 6.1b. Elementos del programa (Serie de Fourier).
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=t 2 , los valores de los coeficientes de Fourier son:
49
=
=
bn =
= π2 /3
=
(-1)n
=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
50
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.
6.2.2 Ele mentos del programa
Figura 6.2b. Elementos del programa (Transformada de Fourier).
51
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).
52
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.
53
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 2M1 elementos.
6.3.3 Ele mentos del programa
Figura 6.3b. Elementos del programa (Convolución y Correlación).
54
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).
55
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).
6.4.2 Ele mentos del programa
56
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
57
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).
58
6.5 Conve rsió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
6.5.1 Ele mentos del programa
Figura 6.5b. Elementos del programa (Decibeles y Watts).
59
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.
60
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))
6.6.1 Ele mentos del programa
Figura 6.6b. Elementos del programa (Muestreo de señales).
61
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).
62
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
6.7.1 Ele mentos del programa
Figura 6.7b. Elementos del programa (Muestreo de señal PAM).
63
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).
64
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.
6.8.2 Ele mentos del programa
65
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).
66
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
67
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
68
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.
6.9.2 Ele mentos del programa
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
69
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)
70
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))
6.10.1 Ele mentos del programa
Figura 6.10b. Elementos del programa (Codificación Hamming).
71
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. 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.
6. Palabra código. Es donde se muestra la palabra codificada.
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.
72
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')
73
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).
6.11.2 Ele mentos del programa
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.
2. Palabra. Es donde se introduce la palabra a codificar.
3. Agregar un error. Es donde se elige si se quiere agregar un error
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
74
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)
75
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
6.12.1 Elementos del programa
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.
2. Palabra. Es donde se introduce la palabra a codificar.
3. Codificar. Es el botón que ejecuta la codificación.
4. Dibujo del codificador. Es donde se muestra el dibujo del codificador.
5. Palabra código. Es donde se muestra la palabra codificada.
6.12.2 Eje mplo
76
Figura 6.12c. Ejemplo (Codificación Convolucional).
77
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 distintas 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.
78
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.p
df, 26 de Septiembre.
[4] http://amasd.upb.edu.co/es/pregrado/programacion/Matlab6_GUI.pdf,
Septiembre.
27
de
[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.
79
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
80
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
81
[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.
82
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);
83
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
84
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
85
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)
86
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
87
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);
88
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);
89
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);
90
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);
91
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;
92
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);
93
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;
94
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'));
95
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);
96
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;
97
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;
98
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
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,5) r(1,3) r(1,1)]);
unos_ce2=sum([r(1,15) r(1,14) r(1,11)
r(1,6) r(1,3) r(1,2)]);
unos_ce3=sum([r(1,15) r(1,14) r(1,13)
r(1,6) r(1,5) r(1,4)]);
unos_ce4=sum([r(1,15) r(1,14) r(1,13)
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;
c3 b3 c2 c1];
r(1,9) r(1,7)...
r(1,10) r(1,7)...
r(1,12) r(1,7)...
r(1,12) r(1,11)..
99
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);
100
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'));
101
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);
102
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);
103