UNIVERSIDAD EL BOSQUE

FACULTAD DE INGENIERÍA
PROGRAMA DE INGENIERÍA ELECTRÓNICA
ANÁLISIS DE SEÑALES

Laboratorio 3:
Señales en Tiempo Discreto

CONTENIDO:

1. INTRODUCCIÓN
1

2. OBJETIVOS 2

3. REPRESENTACIÓN DE SEÑALES 2

3.1 Matrices y Operaciones 2

3.2 Señales continuas sinusoidales 6

3.3 Generar más gráficos en dos dimensiones 8

4. BIBLIOGRAFÍA 9

DESARROLLO:

1. Introducción
Continuando el laboratorio de tratamiento de señales y cómo refuerzo de la los
resultados de aprendizaje del curso (procesamiento de las señales en tiempo discreto)
se ilustrarán algunas propiedades de las señales en tiempo-discreto diferenciándolas de
las señales de tiempo continúo bajo el lenguaje Python. Una señal en tiempo-continuo
toma valores en todo punto en el tiempo, mientras que una señal en el tiempo-discreto
está definida solamente en valores enteros de la variable “tiempo”. Sin embargo,
mientras una señal en tiempo-discreto puede ser fácilmente guardada y procesada en
un computador, es imposible guardar los valores de una señal en tiempo continuo para
todos los puntos a lo largo de una línea real. En los computadores realmente no se
puede almacenar ni mostrar una señal continua pero se hace una aproximación
asignando valores de la señal a intervalos de tiempo pequeños muy inferiores a la unidad
lo cual en el fondo es una restricción de tiempo, y además, también se hace la restricción
de los posibles valores que puede tener en amplitud cuantizandola de acuerdo a las
posibles clases de variables permitidas en el software (UINT8, 16, 32, SINT8, 16, 32,
LOGICAL, SINGLE y DOUBLE), y se grafican uniendo los puntos con líneas rectas dando la
impresión de infinitos valores. En las señales discretas se usan las mismas clases de
variables pero la diferencia es que cada valor de amplitud corresponde a un intervalo de
tiempo discreto entero y su gráfica muestra espacios vacíos entre muestras.

Realmente para procesar una señal continua en un computador se requiere un

proceso de conversión de continua a discreta, pero en el presente laboratorio, se van a
crear las señales directamente en el sistema.

1. Objetivos
• Generación, la representación y el manejo de señales continuas y
discretas
• Realizar algunas operaciones entre señales
• Utilizar formas básicas de graficación, programación

2. Representación de señales

Prácticamente todos los laboratorios de este curso usarán Python como su

lenguaje de trabajo. Python es un lenguaje de programación que se puede usar dentro
de un ambiente computacional genérico y técnico que para análisis numéricos, cálculos
matriciales, procesamiento de señales, y gráficos entre muchas otras. Por ejemplo,
Python puede ser usado en un amplio rango de aplicaciones, tales como las
telecomunicaciones, procesamiento de señales e imágenes, control, matemáticas,
finanzas, bioingeniería, aeronáutica, y muchas más. En esta sección del laboratorio,
trabajarán algunas de sus funciones básicas aplicadas a la generación de señales y se
propondrá la operación entre señales.

2.1 Matrices y Operaciones

Genere una variable tipo matriz en un editor de Python de su preferencia y visualice los
resultados en consola:

a = [1 2 3]
print(a)

Crea una matriz nombrada “a” con dimensiones de 1 × 3 (fila x columna). La variable “a”
es almacenada en lo que es llamado el espacio de variables y en el editor como ya se
mencionó se podrá visualizar en el explorador de variables. Ahora, si se quiere trabajar
las variables como arreglos tal cual lo trabaja Matlab, se necesitan instalar la librería
Numpy. Por ejemplo si se quiere visualizar una lista como un arreglo tipo matriz el código
sería el siguiente:

import numpy as np
a = np.array([[1, 2], [3, 4]])
print(a)

genera una matriz 2x2 así:

Y su transpuesta por ejemplo:

b = a.T
print(b)

Guarda la transpuesta de “a” en la matriz “b”. En este caso, “b” es una matriz también
2 × 2.

A menudo, se quiere aplicar una operación por ejemplo multiplicar elemento por
elemento de dos arreglos. Por ejemplo, se puede querer elevar al cuadrado cada
elemento de “a”. En este caso, se puede usar el comando siguiente:

c = a*a

El símbolo .* le dice a Matlab que la multiplicación debe ser aplicada a cada elemento
de “a”. Entonces la operación .* no es una operación matricial. La convención trabaja
con muchos comandos tales como la división y la potenciación respectivamente, ./, .^.
El resultado entonces es un vector “c” 4x4, multiplicando los elementos:

c= [[1x1, 2x2], [3x3, 4x4]], quedando para el ejemplo:

Algunas funciones y comandos básicos que se pueden usar como referencia futura
básica son:

v1=np.array([4, 3, 7, -9, 1, 5])

v2=np.array[[4, 3, 7, -9, 1, 5])

% El producto por una constante (escalado en amplitud) es:

v3=5*(v2)
% La suma vectorial es:
v4=v3+v2
% Las operaciones dato a dato (o elemento a elemento) son:
v5=v3/v1
% para trabajar en Python con Números complejos se requiere instalar la librería de
matemática compleja cmath, magnitud:
import cmath
complejo =cmath.sqrt(-1)
 print(complejo)
y = 2 * (1 + 4*1j)
print(y)

Para visualizar las partes real e imaginaria de un número y calcular su magnitud y fase
se requiere de la librería Numpy:
import numpy as np
y = 2 * (1 + 4*1j)
# Extrayendo la parte real
pr = y.real
# Extrayendo la parte imaginaria
pi = y.imag
# Calculando la magnitud
c = np.abs(y)
# Calculando el ángulo (en radianes)
ca = np.angle(y)
# Obteniendo el conjugado
x = np.conj(y)
# Imprimiendo los resultados
print(f"Parte real: {pr}")
print(f"Parte imaginaria: {pi}")
print(f"Magnitud: {c}")
print(f"Ángulo (en radianes): {ca}")
print(f"Conjugado: {x}")

Algunas matrices especiales que se podrán utilizar durante el curso por supuesto
también con Numpy como librería clave para mantener la lógica aprendida para
programar con Matlab:
import numpy as np
# Matriz vacía
M = np.array([])
# Matriz de ceros 2x3
M1 = np.zeros((2, 3))
# Matriz de unos 2x3
M2 = np.ones((2, 3))
# Matriz identidad 3x3
M3 = np.eye(3)

# Sobreescribir un número en una posición específica de la matriz

M3[0, 1] = 5

print("M:", M)
print("M1:", M1)
print("M2:", M2)
print("M3:", M3)
Un ejemplo de creación de los vectores de tiempo para emular señales continuas y
comparando con la creación de los vectores de tiempo para generar señales discretas
sinusoidales ambas:

import numpy as np
import matplotlib.pyplot as plt

# Definición de t y n
t = np.arange(0, 10.1, 0.1) # Note que 10.1 es usado para incluir el 10 en
el rango, similar a MATLAB
n = np.arange(0, 11) # 11 para incluir el 10 en el rango

# Definición de x y x1
x = np.cos(2*t)
x1 =np.cos(2*np.pi*n/8)

plt.plot(t, x)
plt.xlabel('t')
plt.ylabel('x')
plt.title('Plot of x = cos(2t)')
plt.grid(True)
plt.show()

plt.figure()
plt.stem(n, x1, use_line_collection=True) # use_line_collection para
mejorar la eficiencia
plt.xlabel('n')
plt.ylabel('x1')
plt.title('Stem plot of x1 = cos(n)')
plt.grid(True)
plt.show()

Creando las demás señales básicas:

import numpy as np
import matplotlib.pyplot as plt

# Definiendo n y las señales

n = np.arange(-10, 11)

# Delta (impulso unitario)

d = np.where(n == 0, 1, 0)

# Escalón unitario
u = np.where(n >= 0, 1, 0)

# Rampa
r=n*u

# Exponencial
 e = (0.2**n) * u

# Graficar las señales en subplots

plt.figure(figsize=(10, 10)) # Opcional: establecer tamaño de la ventana

# Delta Dirac
plt.subplot(2, 2, 1)
plt.stem(n, d, use_line_collection=True)
plt.title('Delta function')

# Escalón unitario
plt.subplot(2, 2, 2)
plt.stem(n, u, use_line_collection=True)
plt.title('Unit step function')

# Rampa
plt.subplot(2, 2, 3)
plt.stem(n, r, use_line_collection=True)
plt.title('Ramp function')

# Exponencial Creciente
plt.subplot(2, 2, 4)
plt.stem(n, e, use_line_collection=True)
plt.title('Exponential function')

# Mostrar todas las figuras

plt.tight_layout() # Ajusta el espacio entre los subplots para que no se
superpongan
plt.show()

Informe de laboratorio:

Realice los procedimientos, No anexe ningún resultado de éste apartado en el

informe

2.2 Señales continuas sinusoidales

En el siguiente ejemplo se creará una señal “análoga” definiendo todos sus

parámetros

𝑥(𝑡) = 3cos (3𝜋𝑡 + 𝜋/3)

A=3;
Wo=3*pi;
Thita=pi/3;
T=2*pi/Wo;
t = 0:0.01:4*T;
x=A*cos(Wo*t+Thita);
plot(t,x)
Como primera asignación se pide crear un nuevo script donde se generen tres señales
continuas con frecuencia de 4KHz, y que se visualicen dos periodos. Las primeras dos
señales, x1(t), y x2(t) son descritas por las siguientes expresiones

𝑥! (𝑡) = 𝐴! cos (2𝜋(4000)(𝑡 − 𝑡"! ))

𝑥# (𝑡) = 𝐴# cos (2𝜋(4000)(𝑡 − 𝑡"# ))

Las amplitudes y desplazamientos de tiempo son funciones de su edad y fecha de

nacimiento como se describe abajo.

A1 = su edad/10

A2 = 1.2 A1

Los tiempos de desplazamiento son definidos así,

37.2
𝑡"! = 3 7𝑇
𝑀
41.3
𝑡"# = −( )𝑇
𝐷

Donde M es igual al mes de su nacimiento (de 1-Enero a 12-Diciembre), D al día de su

nacimiento (de 1 a 31), y T = 1/f = 250µS es el periodo de las señales. El vector de
tiempo, t, usado para generar las señales debe tener 25 valores por cada periodo.
Entonces el rango del vector de tiempo estará entre –T y T, o un periodo antes de t=0 y
uno después, y el paso de tiempo entre muestras debe ser de T/25.

La tercera señal es simplemente la suma de x1(t), y x2(t).

𝑥$ (𝑡) = 𝑥! (𝑡) + 𝑥# (𝑡)

Grafique las tres señales en una sola figura con la función plt.plot, genere una grilla y
ponga título a cada gráfica que la identifique con etiquetas en el eje y y en el eje x. la
primera gráfica debe ser roja, la segunda azul y la tercera verde (es decir el color de las
curvas).

Realice una segunda figura con las tres gráficas en cuadros diferentes pero en la misma
figura usando los comandos plt.subplot.

Realice los cálculos de los desfases en radianes de las tres señales, con una nueva figura
reescriba y grafique las señales en función del desfase en radianes.

𝑥(𝑡) = 𝐴𝑐𝑜𝑠(2𝜋(4000)𝑡 − 𝜑)

Reescriba las mismas señales en forma exponencial (fasorial) y grafíquelas en una nueva
figura,

𝑥(𝑡) = 𝑅𝑒A𝐴𝑒 %& 𝑒 %'( B.

Como segunda asignación se solicita que realicen el script y grafiquen las señales
mostradas a continuación en los intervalos de tiempo solicitados con un tamaño de paso
apropiado (en el caso de señales complejas se debe graficar por aparte la parte real,
imaginaria, la magnitud y la fase):

3.3.1. 𝑥(𝑡) = 3𝑒 ).+( − 2 ≤ 𝑡 ≤ 5

3.3.2. 𝑦(𝑡) = 2𝑒 ,).-( − 2 ≤ 𝑡 ≤ 5
3.3.3. 𝑦(𝑡) = 2𝑒 %.(/./$ 𝑒𝑛 𝑢𝑛 𝑝𝑒𝑟𝑖𝑜𝑑𝑜
3.3.4. 𝑥(𝑡) = 2𝑒 %.( 3𝑒 %#.( , 0 ≤ 𝑡 ≤ 5
3.3.5. 𝑦(𝑡) = 6𝑒 %$.( , 0 ≤ 𝑡 ≤ 5

Informe de laboratorio:

Anexe los procedimientos, agregue el código de python generado para cada uno de
los ítems, tareas solicitadas y los resultados del procedimiento en el informe, es decir,
incluya cada una de las gráficas y resultados que se solicitan.

2.3 Generar más gráficos en dos dimensiones

!
Realice la siguiente figura: 𝑦 = 𝑥𝑒 !" , −3 ≤ 𝑥 ≤ 3

Ahora, realice las siguientes figuras, incluyendo las leyendas, etiquetas, título y tipos de gráficas
teniendo en cuenta el color:

Por último grafique las siguientes ecuaciones:

Informe de laboratorio:

Anexe los procedimientos, tareas solicitadas y los resultados del procedimiento en el

informe.

3. BIBLIOGRAFÍA
• Signals and Systems, an introduction to analog and digital signal processing, Alan
Oppenheim. (1983). Prentice-Hall
• Signal and Systems - General. B. Girod R. Rabenstein A. Stenger – Jhon Wiley &
Sons. (2001).
• Digital Signal Processing. Schaum's Outline. Mcgraw-Hill (1999).
• Digital Signal Processing using Matlab v4. Ingle and Proakis. ()PWS publishing
Company.