Facultad de Ingeniería y

Tecnología
Lab. Teoria de
Comunicaciones
Asignatura

Tec611
Código

11237
Grupo

Convolución
Tema

Amauris Vizcaino Vallejo

Nombre

A00111294
Matrícula

Golkis Encarnación
Profesor

Julio, 2025
 Santo Domingo, D. N.

Ejercicio 1
t= -1:1/500:1; %define los valores de tiempo de -1 seg a 1 seg
u1 = [zeros(1,250), ones(1,751)]; %Genera función escalón de
amplitud unitaria, con inicio en el tiempo t=-0.5
u2 = [zeros(1,751), ones(1,250)]; %Genera una segunda función
escalón de amplitud unitaria con inicio en t = 0.5 seg
u = (u1) - (u2); %Sustrae u2 de u1 para producir un pulso
rectangular de amplitud y duración unitarias centrado en el origen
subplot (2,2,1),
plot (u,'b')
title('funciones escalón recorridas en el tiempo Amauris
Vizcaino'); %Título de la hoja gráfica
xlabel('Tiempo t'); %personifica el eje X
ylabel('x(t)'); %Personifica el eje Y
hold on
subplot (2,2,3),
plot (u1,'r')
title('inicio en el tiempo t = - 0.5 Amauris Vizcaino'); %Título de
la hoja gráfica
xlabel('Tiempo t'); %personifica el eje X
ylabel('x(t)'); %Personifica el eje Y
subplot (2,2,4),
plot (u2,'m')
title('inicio en el tiempo t = 0.5 Amauris Vizcaino'); %Título de
la hoja gráfica
xlabel('Tiempo t'); %personifica el eje X
ylabel('x(t)'); %Personifica el eje Y
hold off

Ejercicio 1 modificado
t = -1:1/500:1; % Define los valores de tiempo de -1 seg a 1 seg
% El número total de puntos es length(t) = (1 - (-1))/(1/500) + 1 = 2*500 + 1 = 1001
% Genera u1 sin usar zeros ni ones
u1 = (t >= -0.5); % Crea un array lógico: true donde t >= -0.5, false en caso
contrario
u1 = double(u1);% Convierte el array lógico a double, así true se convierte en 1 y
false en 0
% Genera u2 sin usar zeros ni ones
u2 = (t >= 0.5); % Crea un array lógico: true donde t >= 0.5, false en caso
contrario
u2 = double(u2); % Convierte el array lógico a double
u = (u1) - (u2); % Resta u2 de u1 para producir un pulso rectangular de amplitud y
duración unitarias centrado en el origen
subplot (2,2,1),
plot (t, u,'b') % Grafica u contra t
title('Funciones Escalón Recorridas en el Tiempo - Amauris Vizcaino'); % Título del
gráfico
xlabel('Tiempo t'); % Etiqueta del eje X
ylabel('x(t)'); % Etiqueta del eje Y
hold on
subplot (2,2,3),
plot (t, u1,'r') % Grafica u1 contra t
title('Inicio en el tiempo t = -0.5 - Amauris Vizcaino'); % Título del gráfico
xlabel('Tiempo t'); % Etiqueta del eje X
ylabel('x(t)'); % Etiqueta del eje Y
subplot (2,2,4),
plot (t, u2,'m') % Grafica u2 contra t
title('Inicio en el tiempo t = 0.5 - Amauris Vizcaino'); % Título del gráfico
xlabel('Tiempo t'); % Etiqueta del eje X
ylabel('x(t)'); % Etiqueta del eje Y
hold off

t = -1:1/500:1; Esta línea permanece igual, ya que define correctamente el

vector de tiempo. La longitud de este vector es de 1001 puntos.

u1 = (t >= -0.5); Este es el paso crucial. Realiza una comparación lógica

para cada elemento en el array t.
Si un elemento en t es mayor o igual a -0.5, la comparación (t >= -0.5) se
evalúa como vedadero para ese elemento.
Si un elemento en t es menor que -0.5, la comparación se evalúa como falso.
El resultado u1 en esta etapa es un array lógico que contiene valores
verdadero y falso.

u1 = double(u1); MATLAB trata veradero como 1 y falso como 0 al convertir

valores lógicos a tipos numéricos. Al aplicar double(), convertimos
explícitamente el array lógico en un array de punto flotante de doble
precisión donde true se convierte en 1.0 y false en 0.0. Esto crea
eficazmente la función escalón unitario que comienza en t = -0.5.

u2 = (t >= 0.5); Similar a u1, esta línea crea un array lógico donde true
corresponde a valores de tiempo mayores o iguales a 0.5, y false en caso
contrario.

u2 = double(u2);: Esto convierte el array lógico u2 en un array numérico de

0s y 1s, representando la función escalón unitario que comienza en t = 0.5.
Al usar este enfoque, aprovechamos las operaciones vectorizadas y las
capacidades de conversión de tipos de MATLAB para construir las
funciones escalón basándonos en lógica condicional, evitando así el uso
explícito de zeros() o ones(). Este método suele ser más conciso y eficiente
para generar este tipo de patrones.

Ejercicio 2
%Convolución en tiempo continuo
tc = -4:0.1:15;
xt = 2 .* ones(1,191);
xt(1:19) = 0;
xt(161:191) = 0;
ht = 0.9 .^tc;
ht(1:59) = 0;
ht(171:191)= 0;
ytconv = conv(xt,ht);
tf = -4:0.1:34 ;
%Impresión convolución continua
subplot(3,2,1);
plot(tc,xt);
title('Señal de entrada x(t) Amauris Vizcaino');
subplot(3,2,2);
plot(tc,ht);
title('Respuesta al Impulso h(t) Amauris Vizcaino');
subplot(3,2,3);
plot(tf,ytconv);
title('Convolución de x(t)y h(t) Amauris Vizcaino');
Ejercicio 2 Modificado
n = -4:15;
xn = 2 .* ones(1,20);
xn(1:5) = 0;
xn(17:20) = 0;
hn = 0.9 .^n;
hn(1:5) = 0;
hn(17:20) = 0;
ynconv = conv(xn,hn);
nf = -4:34;

subplot(3,2,1);
stem(n,xn);
title('Señal de entrada x[n] Amauris Vizcaino');
subplot(3,2,2);
stem(n,hn);
title('Respuesta al Impulso h[n] Amauris Vizcaino');
subplot(3,2,3);
stem(nf,ynconv);
title('Convolución de x[n] y h[n] Amauris Vizcaino');

Ejercicio 3
%Convolución en tiempo discreto
n = -2:13;
xn = 2 .* ones(1,16);
xn(16) = 0;
hn = 0.9 .^ n;
hn (1:2) = 0;
ynconv = conv(xn,hn);
nf = -2:28;
%impresión convolución discreta
subplot(3,3,4);
stem(n,xn);
title('Señal de entrada x(t)(Discreto) Amauris Vizcaino');
subplot(3,3,5);
stem(n,hn);
title('Respuesta al Impulso h(t)(Discreto) Amauris Vizcaino');
subplot(3,3,6);
stem(nf,ynconv);
 title('Convolución de x(t)y h(t)(Discreto) Amauris Vizcaino');

Ejercicio 3 Modificado
% Convolución en tiempo continuo
t = -2:0.01:13; % Mayor resolución para tiempo continuo
xt = 2 * ones(size(t));
xt(t > 12) = 0; % La señal se apaga después de t=12
ht = 0.9 .^ t;
ht(t < 0) = 0; % Sistema causal (h(t)=0 para t<0)

% Convolución (usando aproximación numérica)

dt = t(2)-t(1); % Paso temporal
ytconv = conv(xt, ht) * dt; % Multiplicar por dt para aproximar
integral
tf = -4:0.01:26; % Rango extendido para el resultado
% Gráficas de convolución continua
figure;
subplot(3,1,1);
plot(t, xt, 'b', 'LineWidth', 1.5);
xlabel('Tiempo (s)'); ylabel('Amplitud');
title('Señal de entrada x(t) - Amauris Vizcaino');
grid on;
xlim([-2 13]);
subplot(3,1,2);
plot(t, ht, 'r', 'LineWidth', 1.5);
xlabel('Tiempo (s)'); ylabel('Amplitud');
title('Respuesta al impulso h(t) - Amauris Vizcaino');
grid on;
xlim([-2 13]);
subplot(3,1,3);
plot(tf(1:length(ytconv)), ytconv, 'm', 'LineWidth', 1.5);
xlabel('Tiempo (s)'); ylabel('Amplitud');
title('Convolución y(t) = x(t)*h(t) - Amauris Vizcaino');
grid on;
xlim([-4 26]);
Ejercicio 3 con la duración de pulso de 7
% Convolución en tiempo discreto con pulso de duración 7
n = -2:13; % Rango de muestras
xn = [zeros(1,3) 2*ones(1,7) zeros(1,6)]; % Pulso de amplitud 2 y duración 7
hn = 0.9 .^ n; % Respuesta exponencial
hn(1:3) = 0; % Hacemos el sistema causal (hn=0 para n<0)
ynconv = conv(xn, hn); % Convolución discreta
nf = -2:28; % Rango extendido para el resultado

figure('Name','Convolución Discreta con Pulso - Amauris

Vizcaino','NumberTitle','off');

subplot(3,1,1);
stem(n, xn, 'filled', 'LineWidth', 1.5, 'Color', [0 0.5 0]);
xlabel('Muestras (n)'); ylabel('Amplitud');
title('Señal de entrada x[n] (Pulso de duración 7)');
grid on;
xlim([-2 13]);
ylim([-0.2 2.2]);
subplot(3,1,2);
stem(n, hn, 'filled', 'LineWidth', 1.5, 'Color', [0.8 0 0]);
xlabel('Muestras (n)'); ylabel('Amplitud');
title('Respuesta al impulso h[n] (Exponencial)');
grid on;
xlim([-2 13]);
ylim([-0.2 2.2]);
subplot(3,1,3);
stem(nf, ynconv, 'filled', 'LineWidth', 1.5, 'Color', [0 0 0.8]);
xlabel('Muestras (n)'); ylabel('Amplitud');
title('Convolución y[n] = x[n]*h[n]');
grid on;
xlim([-2 28]);
 Explique 2 aplicaciones en ingeniería de Telecomunicaciones o
electrica donde la operación de convolución se utilice.
1) Procesamiento de Señales en Sistemas de Comunicación
Ecualización de canales: Cuando una señal se transmite por un medio (como cables o
wireless), sufre distorsiones por efectos del canal (multitrayectoria, atenuación). La
respuesta al impulso del canal h(t) se convoluciona con la señal x(t). Para compensar
esto, se diseña un ecualizador (otro sistema cuya convolución con h(t) resulte en un
impulso limpio).

Análisis de Circuitos y Sistemas de Potencia

En circuitos RLC, la salida v out (t) se obtiene convolucionando la entrada v ¿ (t) con la
respuesta al impulso del circuito h(t), que deriva de su función de transferencia.

para el estudio de señales, cuando es más conveniente usar la convolución y cuando es

mejor usar la correlación de señales, porque? hay una funcion en MATLAB para la
correlación, si existe como se usa?
En el estudio de señales, la convolución es más conveniente cuando se necesita
modelar la respuesta de un sistema LTI (como en filtrado o procesamiento de señales),
ya que combina dos señales considerando la inversión temporal de una de ellas,
mientras que la correlación es ideal para medir similitud entre señales o detectar
patrones (como en radar o sincronización), ya que evalúa su alineación sin invertirlas.
En MATLAB, la convolución se calcula con conv(x,h), y la correlación cruzada
con xcorr(x,y), que permite encontrar retardos o coincidencias entre señales, incluso
con ruido, devolviendo los valores de correlación y los desplazamientos
correspondientes (lags). Por ejemplo, [Rxy, lags] = xcorr(señal, patrón) ayuda a
identificar dónde aparece el patrón en la señal. La elección depende del objetivo:
convolución para sistemas LTI y correlación para comparación o detección de señales.

Propiedad Convolución Correlación

¿Qué mide? Cómo una señal afecta a Similitud entre señales
otra
Uso principal Análisis de sistemas y Detección,
 filtros reconocimiento de
patrones
¿Se invierte una señal? Sí (se invierte una de las No (ambas señales se
señales) mantienen)
¿Se invierte una señal? Sí (se invierte una de las señales) No (ambas señales se mantienen)

En MATLAB se utiliza xcorr() para calcular la correlación cruzada (o autocorrelación si se

aplica sobre una misma señal).

Convolución: En CLARO, al transmitir datos digitales por fibra o radio, la señal se distorsiona
por el canal. El receptor usa convolución inversa (ecualización) para recuperar la señal
original.

Correlación: Cuando un celular busca una celda o sincroniza con una torre, usa correlación
para detectar patrones específicos (preambulos) en la señal que identifican a la celda.