DEPARTAMENTO DE ELÉCTRICA, ELECTRÓNICA Y

TELECOMUNICACIONES

COMUNICACIÓN DIGITAL

LABORATORIO 2

TEMA: MODULACIÓN ASK, FSK, PSK, BPSK, QPSK

NRC: 5778

DOCENTE: ING. DIEGO FERNANDO VILLAMARIN ZAPATA

AUTOR:

Steven Rogel

Anthony Ocampo

Dylan Perdomo

11 DE DICIEMBRE DEL 2024

 I.​ TEMA: MODULACIÓN ASK, FSK, PSK, BPSK, QPSK

II.​ OBJETIVO GENERAL

●​ Desarrollar una interfaz gráfica en MATLAB que permita visualizar las distintas
modulaciones analógicas.

III.​ OBJETIVOS ESPECÍFICOS

●​ Diseñar una interfaz gráfica en MATLAB que presente opciones de portadora

analógica con información digital, como ASK, FSK, PSK, BPSK, QPSK.
●​ Comprobar el funcionamiento de la interfaz creada y las gráficas de las modulaciones
simuladas.
●​ Adicionar las diferentes modulaciones analógicas que permita visualizar el resultado
de forma gráfica.
●​ Diseñar mediante una cadena de bits las modulaciones ASK, FSK, PSK, BPSK,

QPSK, para de esta manera obtener las modulaciones de una manera mas aleatoria
posible sin la necesidad de generar el tren de bits.
IV.​ MARCO TEÓRICO

La modulación es un proceso fundamental en la comunicación digital, ya que permite

transmitir información a través de un canal de comunicación. Existen varias técnicas de
modulación, cada una con sus ventajas y desventajas. A continuación, se presentan las
principales características de ASK, FSK, PSK, BPSK y QPSK.

A. Modulación por Desplazamiento de Amplitud (ASK):

En la modulación por desplazamiento de amplitud, se utilizan dos niveles de amplitud de la
onda portadora para representar los dos estados de información (1 y 0). La presencia o
ausencia de la señal moduladora determina el nivel de amplitud de la onda portadora en un
instante dado. Es ampliamente utilizada en sistemas de comunicación digital, como la
transmisión de datos a través de fibra óptica y los sistemas de radio de baja potencia.

●​ Ventajas y desventajas de ASK

Ventajas:
●​ Fácil de implementar
●​ Requiere una banda de frecuencia baja
Desventajas:
●​ No es muy resistente al ruido
●​ No es muy eficiente en términos de ancho de banda
 Figura 1. Modulación ASK
Obtenido: https://jorgecanon.com/tecnicas-de-modulacion-digital/

B. Modulación por Desplazamiento de Frecuencia (FSK):

La modulación por desplazamiento de frecuencia utiliza dos o más frecuencias portadoras
para representar diferentes estados de información. Cada estado de información se asigna a
una frecuencia específica, y la selección de la frecuencia se realiza según la información a
transmitir. Es comúnmente utilizada en sistemas de comunicación inalámbrica y en
transmisión de datos, así como en sistemas de identificación por radiofrecuencia (RFID) y
módems de datos.

Ventajas y desventajas de FSK

Ventajas:
●​ Más resistente al ruido que ASK
●​ Fácil de implementar
Desventajas:
●​ Requiere una banda de frecuencia más alta que ASK
●​ No es muy eficiente en términos de ancho de banda

Figura 2. Modulación FSK

Obtenido: https://jorgecanon.com/tecnicas-de-modulacion-digital/

C. Modulación por Fase (PSK)

La modulación por fase, también conocida como PSK (Phase Shift Keying), es una técnica de
modulación en la que se varía la fase de la señal portadora en función de la información que
se desea transmitir. La señal portadora se multiplica por la información digital para producir
la señal modulada.

Figura 3. Modulación PSK

Obtenido: https://jorgecanon.com/tecnicas-de-modulacion-digital/
D. Modulación por Fase Binaria (BPSK)
La modulación por fase binaria, también conocida como BPSK (Binary Phase Shift Keying),
es una técnica de modulación por fase que utiliza dos fases diferentes para representar los bits
0 y 1.

●​ Ventajas y desventajas de BPSK

Ventajas:
●​ Más resistente al ruido que ASK y FSK
●​ Fácil de implementar
Desventajas:
●​ No es muy eficiente en términos de ancho de banda
●​ Requiere una banda de frecuencia más alta que ASK y FSK

Figura 4. Modulación BPSK

Obtenido: https://es.fmuser.net/content/?6996.html

E. Modulación por Fase Cuadrada (QPSK)

La modulación por fase cuadrada, también conocida como QPSK (Quadrature Phase Shift
Keying), es una técnica de modulación por fase que utiliza cuatro fases diferentes para
representar los bits 0 y 1.

●​ Ventajas y desventajas de QPSK

Ventajas:
●​ Más eficiente en términos de ancho de banda que BPSK
●​ Más resistente al ruido que BPSK
Desventajas:
●​ Más compleja de implementar que BPSK
●​ Requiere una banda de frecuencia más alta que BPSK
 Figura 5. Modulación BPSK
Obtenido: https://es.fmuser.net/content/?6996.html

V.​ MATERIALES Y MÉTODOS

●​ Software Matlab
●​ Computadora

VI.​ DESARROLLO

Para el desarrollo del presente laboratorio se hace uso del software MATLAB®, en donde por
medio del App Designer realizamos la interfaz gráfica del laboratorio. El punto de partida es
programar cómo se harán las 3 diferentes modulaciones (ASK, FSK, PSK), para ello se tomó
el código compartido por el Ingeniero y se adaptó a lo requerido, una vez adaptado y
funcionando se integró a una interfaz gráfica.

Dentro de este código se encuentra una función que convierte cadenas de texto en código
binario y gráfica el código binario, las modulaciones y las gráficas de estas.

Para la interfaz se usó los siguientes bloques:

●​ Push Button: Se usa 3 de estos para seleccionar el tipo de modulación que se desea
hacer.

●​ Axes: Se usa 2 de estos, en ellos se grafica el tren de bits y la señal modulada

 ●​ Edit Field: Se usa dos numéricos, uno para colocar la frecuencia de muestreo y otro
para la frecuencia de la portadora y uno de texto para la frase a modular.

Una vez determinado todos los componentes a usar, se procede a juntar el código de las
modulaciones junto con el de la interfaz gráfica.

1.​ Se añadió un callback a cada uno de los botones, de esta forma cada vez que se
presione alguno de los botones se ejecuta una porción del código. El callback creado
en cada botón genera automáticamente una función en el apartado del código de la
interfaz gráfica, como se puede ver a continuación.

2.​ Se crearon cuatro funciones privadas, una para cada una de las modulaciones (ASK,
FSK, PSK) y una de conversión de texto a bits que a su vez gráfica el tren de bits y
dentro de cada función de modulación está la graficación de las señal modulada.

3.​ Una vez definida todas las funciones se llama a estas en cada uno de los botones
Una vez hecho todo esto se manda a correr a la interfaz para verificar que todo funcione
correctamente.

VII.​ RESULTADOS

Luego de comprobar la interfaz se obtuvo los siguientes resultados, en este caso se presenta
una ejecución del programa para cada una de las modulaciones, con esto se puede observar
claramente el funcionamiento, para este ejemplo se usa:
●​ Frecuencia de muestreo: 1 MHz
●​ Frecuencia moduladora: 10 kHz
Cabe aclarar que se usó una palabra muy corta (Test) para que se pueda observar de mejor
manera las modulaciones

Figura 6. Texto a ser modulado “Test”

Figura 7. Texto a ser modulado “Test” en ASK

Figura 8. Texto a ser modulado “Test”

Figura 9. Texto a ser modulado “Test” en FSK

 Figura 10. Texto a ser modulado “Test”

Figura 11. Texto a ser modulado “Test” en PSK

VIII.​ ANÁLISIS DE RESULTADOS

Se logró desarrollar una interfaz gráfica interactiva que permite visualizar de manera efectiva
las modulaciones ASK, FSK y PSK. Dentro de la interfaz, el usuario puede ajustar la
frecuencia de muestreo y de la señal portadora, también puede ingresar una cadena de
caracteres y modular dicha cadena, esta interfaz muestran dos gráficas una del tren de bits y
otra de ese tren de bits modulado.
Si se ingresa una cadena de caracteres muy larga la gráfica de la señal modulada no puede
ser apreciada correctamente, y para visualizar el tipo de modulación se debe hacer un
acercamiento
IX.​ CONCLUSIONES
●​ Como se pudo observar anteriormente se necesito realizar una interfaz para las
siguientes modulaciones ya que es aun mas facil manejar las modulaciones que se
quieran tomando en cuenta que se puede colocar el tren de caracteres que se quiera y
de esta manera poder obtener una modulación más apropiada a nuestro requerimiento.
●​ Mediante la obtención de las modulaciones requeridas es más sencillo realizar la
interfaz ya que solo necesitamos de colocar los requerimientos de nuestra interfaz y
unir a nuestras modulaciones y así obtener resultados que nosotros queramos.
●​ Finalmente al colocar la cadena de bits debemos de tener en cuenta que si colocamos
una palabra muy corta esto se verá reflejado en una mejor gráfica de modulación ya
que así se podría visualizar de mejor manera las modulaciones que requeramos.

X.​ RECOMENDACIONES
●​ Al momento de realizar la interfaz debemos de conocer todos los requerimientos que
necesitamos para nuestra interfaz como en este caso frecuencia de portadora,
frecuencia moduladora, tren de bits, tipos de modulaciones.
●​ La mayor parte de modulaciones viene dado mediante la imposición de un cierto
número de caracteres lo cual en este caso se necesito realizar mediante código la
introducción de cualquier valor de tren de caracteres y así obtener una modulación
más acercada a lo que necesitamos.
●​ A la hora de realizar la interface debemos de conocer más a profundo la creación de
ventanas, botones barras de escritura, etc, ya que si no se tiene una idea de creación de
interfaces es muy complicado realizarlas e introducir las modulaciones requeridas,

XI.​ REFERENCIAS

[1] J. G. Proakis and M. Salehi, "Digital Communications," 5th ed. New York, NY, USA:
McGraw-Hill, 2008.
[2] B. Sklar, "Digital Communications: Fundamentals and Applications," 2nd ed. Upper
Saddle River, NJ, USA: Prentice-Hall, 2001.
[3] S. Haykin, "Communication Systems," 4th ed. Hoboken, NJ, USA: Wiley, 2001.
[4] A. Goldsmith, "Wireless Communications," Cambridge, UK: Cambridge University
Press, 2005.
[5] T. S. Rappaport, "Wireless Communications: Principles and Practice," 2nd ed. Upper
Saddle River, NJ, USA: Prentice-Hall, 2002.
XII.​ ANEXOS

classdef Lab1 < matlab.apps.AppBase

% Properties that correspond to app components
properties (Access = public)
UIFigure matlab.ui.Figure
txtbits matlab.ui.control.EditField
TextoasermoduladoEditFieldLabel matlab.ui.control.Label
HzLabel_2 matlab.ui.control.Label
HzLabel matlab.ui.control.Label
PSKButton_2 matlab.ui.control.Button
FSKButton matlab.ui.control.Button
ASKButton matlab.ui.control.Button
MuestreoField matlab.ui.control.NumericEditField
FrecuenciadeMuestreoEditFieldLabel matlab.ui.control.Label
PortadoraField matlab.ui.control.NumericEditField
FrecuenciadePortadoraEditFieldLabel matlab.ui.control.Label
Modu matlab.ui.control.UIAxes
Bits matlab.ui.control.UIAxes
end
methods (Access = private)
function [bits] = graficarBits(app,palabra)
% Convertir la palabra a valores ASCII y luego a binario
ascii_vals = double(palabra); % Valores ASCII
bin_matrix = dec2bin(ascii_vals); % Matriz de cadenas binarias
% Concatenar la matriz binaria en una sola cadena
% Convertir la matriz binaria a un vector numérico para graficar
bits = reshape(bin_matrix' - '0', [], 1); % Vector de bits

% Crear un vector de tiempo para el eje X

tb = 1:length(bits);
% Graficar el vector de bits
stairs(app.Bits,tb, bits, 'LineWidth', 1.5);
ylim(app.Bits,[-0.5, 1.5]); % Limitar el eje Y entre -0.5 y 1.5
xlabel(app.Bits,'Índice del bit');
ylabel(app.Bits,'Valor del bit');
title(app.Bits,['Bits de la palabra "', palabra, '"']);
end
% Función para graficar modulación AM
function plotASK(app)
fs = app.MuestreoField.Value; % Frecuencia de muestreo (100 kHz)
fc = app.PortadoraField.Value; % Frecuencia de la portadora (10
kHz)
A = 5; % Amplitud de la portadora
T = 0.001; % Duración de cada bit (1 ms)
bits = graficarBits(app,app.txtbits.Value); % Secuencia de bits
t_total = T * length(bits); % Duración total de la señal

% Tiempo
t = 0:1/fs:t_total-(1/fs); % Vector de tiempo

% Señal modulada ASK

signal = zeros(1, length(t));
 samples_per_bit = T * fs;

for i = 1:length(bits)
start_index = (i-1) * samples_per_bit + 1;
end_index = i * samples_per_bit;
if bits(i) == 1
signal(start_index:end_index) = A * cos(2 * pi * fc *
t(start_index:end_index));
end
end

% Gráfica Modulada
plot(app.Modu,t * 1000, signal, 'LineWidth', 1.5);
title(app.Modu, 'Señal Modulada en ASK');
xlabel(app.Modu, 'Tiempo (ms)');
ylabel(app.Modu, 'Amplitud (V)');
end

% Función para graficar modulación FM

function plotFSK(app)
fs = app.MuestreoField.Value; % Frecuencia de muestreo (100 kHz)
fc0 = 5000; % Frecuencia para bit 0 (5 kHz)
fc1 = 15000; % Frecuencia para bit 1 (15 kHz)
T = 0.001; % Duración de cada bit (1 ms)
bits = graficarBits(app,app.txtbits.Value); % Secuencia de bits
t_total = T * length(bits); % Tiempo total de transmisión
% Tiempo
t = 0:1/fs:t_total-(1/fs);
% Señal modulada FSK
signal = zeros(1, length(t));
samples_per_bit = T * fs;
for i = 1:length(bits)
start_index = (i-1) * samples_per_bit + 1;
end_index = i * samples_per_bit;
if bits(i) == 1
signal(start_index:end_index) = cos(2 * pi * fc1 *
t(start_index:end_index));
else
signal(start_index:end_index) = cos(2 * pi * fc0 *
t(start_index:end_index));
end
end
% Gráfica Modulada
plot(app.Modu,t * 1000, signal, 'LineWidth', 1.5);
title(app.Modu, 'Señal Modulada en FSK');
xlabel(app.Modu, 'Tiempo (ms)');
ylabel(app.Modu, 'Amplitud (V)');
end

% Función para graficar modulación PM

function plotPSK(app)
fs = app.MuestreoField.Value; % Frecuencia de muestreo (100 kHz)
fc = app.PortadoraField.Value; % Frecuencia de la portadora (10 kHz)
 A = 5; % Amplitud de la portadora
T = 0.001; % Duración de cada bit (1 ms)
bits = graficarBits(app,app.txtbits.Value); % Secuencia de bits
t_total = T * length(bits); % Tiempo total de transmisión

% Tiempo
t = 0:1/fs:t_total-(1/fs);

% Señal modulada BPSK

signal = zeros(1, length(t));
samples_per_bit = T * fs;
for i = 1:length(bits)
start_index = (i-1) * samples_per_bit + 1;
end_index = i * samples_per_bit;
if bits(i) == 1
signal(start_index:end_index) = A * cos(2 * pi * fc *
t(start_index:end_index));
else
signal(start_index:end_index) = A * cos(2 * pi * fc *
t(start_index:end_index) + pi);
end
end
% Gráfica Modulada
plot(app.Modu,t * 1000, signal, 'LineWidth', 1.5);
title(app.Modu, 'Señal Modulada en PSK');
xlabel(app.Modu, 'Tiempo (ms)');
ylabel(app.Modu, 'Amplitud (V)');
end
end
% Callbacks that handle component events
methods (Access = private)
% Button pushed function: ASKButton
function ASKButtonPushed(app, event)
app.plotASK();
end
% Button pushed function: FSKButton
function FSKButtonPushed(app, event)
app.plotFSK();
end
% Button pushed function: PSKButton_2
function PSKButton_2Pushed(app, event)
app.plotPSK();
end
end
% Component initialization
methods (Access = private)
% Create UIFigure and components
function createComponents(app)
% Create UIFigure and hide until all components are created
app.UIFigure = uifigure('Visible', 'off');
app.UIFigure.Position = [126 -118 782 612];
app.UIFigure.Name = 'MATLAB App';
% Create Bits
 app.Bits = uiaxes(app.UIFigure);
title(app.Bits, 'Señal Modulada')
xlabel(app.Bits, 'Tiempo (s)')
ylabel(app.Bits, 'Amplitud (V)')
zlabel(app.Bits, 'Z')
app.Bits.YGrid = 'on';
app.Bits.Position = [222 255 340 222];
% Create Modu
app.Modu = uiaxes(app.UIFigure);
title(app.Modu, 'Señal Modulada')
xlabel(app.Modu, 'Tiempo (s)')
ylabel(app.Modu, 'Amplitud (V)')
zlabel(app.Modu, 'Z')
app.Modu.YGrid = 'on';
app.Modu.Position = [222 17 340 222];
% Create FrecuenciadePortadoraEditFieldLabel
app.FrecuenciadePortadoraEditFieldLabel = uilabel(app.UIFigure);
app.FrecuenciadePortadoraEditFieldLabel.HorizontalAlignment =
'right';
app.FrecuenciadePortadoraEditFieldLabel.Position = [137 540 137
22];
app.FrecuenciadePortadoraEditFieldLabel.Text = 'Frecuencia de
Portadora';
% Create PortadoraField
app.PortadoraField = uieditfield(app.UIFigure, 'numeric');
app.PortadoraField.Position = [299 540 186 22];
% Create FrecuenciadeMuestreoEditFieldLabel
app.FrecuenciadeMuestreoEditFieldLabel = uilabel(app.UIFigure);
app.FrecuenciadeMuestreoEditFieldLabel.HorizontalAlignment =
'right';
app.FrecuenciadeMuestreoEditFieldLabel.Position = [136 574 138
22];
app.FrecuenciadeMuestreoEditFieldLabel.Text = 'Frecuencia de
Muestreo:';
% Create MuestreoField
app.MuestreoField = uieditfield(app.UIFigure, 'numeric');
app.MuestreoField.Position = [299 574 185 22];
% Create ASKButton
app.ASKButton = uibutton(app.UIFigure, 'push');
app.ASKButton.ButtonPushedFcn = createCallbackFcn(app,
@ASKButtonPushed, true);
app.ASKButton.Position = [553 572 100 23];
app.ASKButton.Text = 'ASK';
% Create FSKButton
app.FSKButton = uibutton(app.UIFigure, 'push');
app.FSKButton.ButtonPushedFcn = createCallbackFcn(app,
@FSKButtonPushed, true);
app.FSKButton.Position = [553 539 100 23];
app.FSKButton.Text = 'FSK';
% Create PSKButton_2
app.PSKButton_2 = uibutton(app.UIFigure, 'push');
app.PSKButton_2.ButtonPushedFcn = createCallbackFcn(app,
@PSKButton_2Pushed, true);
 app.PSKButton_2.Position = [553 506 100 23];
app.PSKButton_2.Text = 'PSK';
% Create HzLabel
app.HzLabel = uilabel(app.UIFigure);
app.HzLabel.Position = [493 573 25 22];
app.HzLabel.Text = 'Hz';
% Create HzLabel_2
app.HzLabel_2 = uilabel(app.UIFigure);
app.HzLabel_2.Position = [493 540 25 21];
app.HzLabel_2.Text = 'Hz';
% Create TextoasermoduladoEditFieldLabel
app.TextoasermoduladoEditFieldLabel = uilabel(app.UIFigure);
app.TextoasermoduladoEditFieldLabel.HorizontalAlignment = 'right';
app.TextoasermoduladoEditFieldLabel.Position = [138 507 123 22];
app.TextoasermoduladoEditFieldLabel.Text = 'Texto a ser
modulado:';
% Create txtbits
app.txtbits = uieditfield(app.UIFigure, 'text');
app.txtbits.Position = [298 507 188 22];
% Show the figure after all components are created
app.UIFigure.Visible = 'on';
end
end
% App creation and deletion
methods (Access = public)
% Construct app
function app = Lab1
% Create UIFigure and components
createComponents(app)
% Register the app with App Designer
registerApp(app, app.UIFigure)
if nargout == 0
clear app
end
end
% Code that executes before app deletion
function delete(app)
% Delete UIFigure when app is deleted
delete(app.UIFigure)
end
end
end