Señal compuesta

Señal compuesta

Una señal que se compone de varias señales mas simples se puede manejar como un conjunto de instrucciones por bloques.

Para ello es necesario seleccionar la forma más apropiada para definir cada señal:

  • por bloques def-return
  • en formato de linea lambda

Un escalón es mas sencillo definirlo en formato de línea. Sin embargo, una señal con más partes se recomendaría realizarla por bloques, definiendo su forma más básica para luego poder realizar cambios de escala o desplazamientos en el tiempo.

Ejemplo 1

Referencia: Lathi Ejercicio 1.8 pdf/.65

Demuestre que la señal mostrada en la figura (en libro y al final) puede ser descrita como:

x(t) = (t-1)\mu(t-1) - (t-2)\mu(t-2) - \mu(t-4)

Algoritmo en python

En el ejercicio se presenta una solución por partes, mostrando que la señal se compone de la «suma» de sus partes. Se utiliza la propiedad de la linealidad para los sistemas.

# Señales modelo varias- ejercicio
# propuesta: edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt
# Función escalón
u = lambda t: np.piecewise(t, t>=0, [1,0])

# INGRESO - tiempos de observaciÓn
a = -2
b = 8
dt = 0.05

# PROCEDIMIENTO
t = np.arange(a, b, dt)

# componentes de la señal
# escalones desplazados
u0 = u(t)
u1 = u(t-1)
u2 = u(t-2)
u4 = u(t-4)
# las partes
x1 =  (t-1)*u1
x2 = -(t-2)*u2

# señal como suma de las partes
x = x1 + x2 - u4
# SALIDA - gráfico
plt.figure(1)

plt.subplot(121)
plt.plot(t, x1, '--', label='(t-1)u(t-1)')
plt.plot(t, x2, '--', label='- (t-2)u(t-2)' )
plt.plot(t, -u4, '--', label='- u(t-4)')
plt.plot(t, x, label='x(t)')
# plt.legend(loc="upper right")
plt.ylabel('x(t) por partes')
plt.xlabel('t')
plt.margins(0.1)

plt.subplot(122)
plt.plot(t, x, label='x(t)')
plt.ylabel('x(t)')
plt.xlabel('t')
plt.margins(0.1)
plt.show()

Ejemplo 2

Referencia: Oppenheim ejemplo 1.1 pdf/p.38

Dada la señal mostrada x(t) (en el libro y la siguiente gráfica), realizar x(t+1), …

Procedemos como en el ejercicio anterior, continuando con el uso de la función escalón μ(t), las partes ahora conforman un bloque def-return.

# continuando en el intervalo de tiempo del ejercicio anterior
def senal(t):
    # componentes de la señal
    u0 = u(t)
    u1 = u(t-1)
    u2 = u(t-2)
    
    x1 = -(t-1)*u1
    x2 =  (t-2)*u2
    
    z = u0 + x1 + x2
    
    return(z)

# INGRESO - tiempos de observaciÓn
a = -2
b = 8
dt = 0.05

# PROCEDIMIENTO
t = np.arange(a, b, dt)

#señal
x = senal(t)
# SALIDA - gráfico
plt.figure(2)
plt.plot(t, u0, '--', label='u(t)')
plt.plot(t, x1, '--', label='- (t-1)u(t-1)' )
plt.plot(t, x2, '--', label='(t-2)u(t-2)')
plt.plot(t, x, label='x(t)')
plt.legend(loc=0)
plt.xlabel('t')
plt.show()


o de gráfica simplificada, solo con el resultado

# SALIDA - gráfico
plt.figure(3)
plt.plot(t, x, label='x(t)')
plt.xlabel('t')
plt.margins(0.1)
plt.show()

Ejercicio

Continuando con el ejercicio anterior, realizar la gráfica:

2x(t+1)

Para el ejercicio, se define el punto donde inicia la señal, y la escala para la amplitud. Para observar los cambios se grafica el desplazamiento y luego el cambio de escala.

# INGRESO 
inicia = -1
escala = 2

xd = senal(t-inicia)
y = escala*senal(t-inicia)

# salida - gráfico
plt.figure(4)
plt.plot(t, x, '--' , label='x(t)')
plt.plot(t, xd, '-.', label='x(t-inicia)')
plt.plot(t, y, label='escala*x(t-inicia)')
plt.xlabel('t')
plt.legend()
plt.margins(0.1)
plt.show()


Tarea

Realice el ejercicio para obtener las gráficas:

  • x(-t+1)
  • x(3t/2)
  • x(3t/2 +1)

Para mejor comprensión del proceso, se recomienda iniciar con un bloque que incluya todas las partes de forma independiente, y asi pueda modificar las instrucciones sin depender de los ejercicios anteriores.

Se adjunta lo recomendado:

# Sección para tarea, 
# se inicia con el último ejemplo

% matplotlib inline
# Señales modelo varias- ejercicio
# propuesta: edelros@espol.edu.ec
# librerias
import numpy as np
import matplotlib.pyplot as plt

# INGRESO - tiempos de observaciÓn
a = -2
b = 3
dt = 0.05

# PROCEDIMIENTO
t = np.arange(a, b, dt)
tescala = 3/2
inicio = 0
yescala = 1

# componentes de la señal
u0 = np.piecewise(t, (t-inicio)>=0, [1,0])
u1 = np.piecewise(t, (t-inicio)>=1, [1,0])
u2 = np.piecewise(t, (t-inicio)>=2, [1,0])

x1 = -((t-inicio)-1)*u1
x2 =  ((t-inicio)-2)*u2

#señal
x = yescala*(u0 + x1 + x2)

# SALIDA - gráfico
plt.figure(5)
plt.plot(t, x, label='x(t)')
plt.xlabel('t')
plt.legend(loc='upper left')
plt.margins(0.1)
plt.show()

Otros ejercicios

Schaum problema 1.22 pdf/p.35

Referencia: Lathi Ejercicio 1.8 pdf/.65, Oppenheim ejemplo 1.1 pdf/p.38, Schaum-Hsu problema 1.22 pdf/p.35

Señal Exponencial compleja

Exponencial est

Otra función importante en señales y sistemas es la señal est, donde s es en general de tipo compleja:

s = σ + jω

lo que convierte:

est = e(σ + jω) 
    = eσ e 
    = eσt ( cos(ωt) + j sin(ωt) )

dado que la conjugada s* = σ – jω

es*t = e(σ - jω) 
    = eσ e-jω 
    = eσt ( cos(ωt) - j sin(ωt) )

por lo que sumando las ecuaciones anteriores:

e^{\sigma t} cos(\omega t) = \frac{1}{2}( e^{st} + e^{s^{*}t} )

Comparado con la formula de Euler, se muestra que est es una generalización de e. mostrando que:

# Señales modelo varias
# propuesta: edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt

# INGRESO
a = -5 # rango de tiempo
b = 5
dt = 0.1
sigma = 0  # s = 0 +0j
omega = 0

# PROCEDIMIENTO
t = np.arange(a, b, dt)
s = complex(sigma,omega)
senal = np.exp(s*t)

# SALIDA - gráfica
plt.figure(1)
plt.plot(t,np.real(senal),label='real')
plt.plot(t,np.imag(senal),label='imaginaria')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.legend()
plt.margins(0.1)
plt.title('e^('+str(sigma) +' + '+str(omega)+'j)')
plt.show()

# un exponencial simple σ>0 ω=0 
sigma = 1
omega = 0

s = complex(sigma,omega)
senal = np.exp(s*t)

# SALIDA - gráfica
plt.figure(2)
plt.plot(t,np.real(senal),label='real')
plt.plot(t,np.imag(senal),label='imaginaria')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.legend()
plt.margins(0.1)
plt.title('e^('+str(sigma) +' + '+str(omega)+'j)')
plt.show()

# un exponencial simple σ<0 ω=0
sigma = -1
omega = 0

s = complex(sigma,omega)
senal = np.exp(s*t)

# SALIDA - gráfica
plt.figure(3)
plt.plot(t,np.real(senal),label='real')
plt.plot(t,np.imag(senal),label='imaginaria')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.legend()
plt.margins(0.1)
plt.title('e^('+str(sigma) +' + '+str(omega)+'j)')
plt.show()

# un sinusiode σ=0, ω>0
sigma = 0
omega = 1

s = complex(sigma,omega)
senal = np.exp(s*t)

# SALIDA - gráfica
plt.figure(4)
plt.plot(t,np.real(senal),label='real')
plt.plot(t,np.imag(senal),label='imaginaria')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.legend()
plt.margins(0.1)
plt.title('e^('+str(sigma) +' + '+str(omega)+'j)')
plt.show()

# un sinusiode σ=0, ω<0
sigma = 0
omega = -1

s = complex(sigma,omega)
senal = np.exp(s*t)

# SALIDA - gráfica
plt.figure(5)
plt.plot(t,np.real(senal),label='real')
plt.plot(t,np.imag(senal),label='imaginaria')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.legend()
plt.margins(0.1)
plt.title('e^('+str(sigma) +' + '+str(omega)+'j)')
plt.show()

# un sinusoide con amplitud exponencial σ=0.25, ω>0
sigma = 0.25
omega = 4

s = complex(sigma,omega)
senal = np.exp(s*t)

# SALIDA - gráfica
plt.figure(6)
plt.plot(t,np.real(senal),label='real')
plt.plot(t,np.imag(senal),label='imaginaria')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.legend()
plt.margins(0.1)
plt.title('e^('+str(sigma) +' + '+str(omega)+'j)')
plt.show()

# un sinusoide con amplitud exponencial σ=-0.25, ω>0
sigma = -0.25
omega = 4

s = complex(sigma,omega)
senal = np.exp(s*t)

# SALIDA - gráfica
plt.figure(7)
plt.plot(t,np.real(senal),label='real')
plt.plot(t,np.imag(senal),label='imaginaria')
plt.xlabel('t')
plt.ylabel('x(t)')
plt.legend()
plt.margins(0.1)
plt.title('e^('+str(sigma) +' + '+str(omega)+'j)')
plt.show()

Referencia: Lathi 1.4.1 pdf/p.63 – 68, Schaum 1.3 pdf/p.17-22 Oppenheim 1.4 pdf/p.61

Señales μ(t) y δ(t)

Señales escalón e impulso

Referencia: Lathi 1.4.1 pdf/p.63 – 68, Schaum 1.3 pdf/p.17-22 Oppenheim 1.4 pdf/p.61

Escalón unitario μ(t)

En muchos de los temas de curso se usan sistemas causales que inician en t=0. La función que describe éste comporamiento es μ(t) descrita como:

\mu(t)= \begin{cases} 1, & t\geq 0 \\ 0, & t<0\end{cases}

Algunas señales pueden convenientemente ser descritas usando términos de una función μ(t) como se muestra el los siguientes ejemplos

Algoritmo Python

La función μ(t) se puede describir con la np.piecewise()

# Señales modelo varias
# propuesta: edelros@espol.edu.ec
import numpy as np

# INGRESO
u = lambda t: np.piecewise(t,t>=0,[1,0])

a = -10
b = 10
dt = 0.1

# PROCEDIMIENTO
t = np.arange(a, b, dt)
u0 = u(t-0)

# SALIDA - GRAFICA
import matplotlib.pyplot as plt
plt.figure(1)
plt.plot(t,u0)

plt.xlabel('t')
plt.ylabel('escalon u(t)')
plt.margins(dt)
plt.grid()
plt.show()

Para convertir una señal cualquiera a causal, que inicie en t=0, se multiplica la señal por μ(t).

Por ejemplo, x(t)=e-αt se puede convertir a una señal causal si se escribe como:

x(t) = e^{-\alpha t} \mu(t)

Para mostrar lo indicado y considerando α=1 tenemos que:

# señal a causal
x = np.exp(-t)*u0

# SALIDA - GRAFICA
plt.figure(2)
plt.plot(t,x)

plt.xlabel('t')
plt.ylabel('x(t)u(t)')
plt.margins(dt)
plt.grid()
plt.show()


La función escalón tambien realizar descripciones matematicas sobre diferentes segmentos del tiempo.

Por ejemplo, una señal rectangular se puede representar como la suma de dos señales μ(t) desplazadas:

x(t) = \mu (t-2) - \mu (t-4)
# Rectangular como u(t-2)-u(t-4)
# u2 = np.piecewise(t,t>=2,[1,0])
# u4 = np.piecewise(t,t>=4,[1,0])

u2 = u(t-2) 
u4 = u(t-4) 
rectangular = u2 - u4

# SALIDA - GRAFICA
plt.figure(3)
plt.plot(t,rectangular)

plt.xlabel('t')
plt.ylabel('rectangular()')
plt.margins(dt)
plt.grid()
plt.show()

Impulso unitario δ(t)

El impulso unitario δ(t) es una función definida primero por Paul Dirac de la forma:

\delta(t)=0,t\neq 0 \int_{-\infty}^{\infty} \delta(t) dt = 1

Se puede ver al impulso como un pulso rectangular muy pequeño de área unitaria. El ancho del pulso rectangular es muy pequeño.

Siguiendo el concepto, se puede representar como:

# impulso unitario
# u0 = np.piecewise(t,t>=0,[1,0])
# udt = np.piecewise(t,t>=(0+dt),[1,0])

u0 = u(t)
udt = u(t-dt)
impulso = u0 - udt

# SALIDA - GRAFICA
plt.figure(4)
plt.plot(t,impulso)

plt.margins(dt)
plt.xlabel('t')
plt.ylabel('impulso()')
plt.grid()
plt.show()


Aunque la forma mas simple de representarlo es como:

\delta(t)= \begin{cases} 1, & t = 0 \\ 0, & t \neq 0\end{cases}

En el algoritmo consiste en poner todos los valores en cero y buscar donde ocurre el cambio de signo del tiempo, para aproximar el valor más cercano a cero.

Para la gráfica también se usa stem(x,y):

def unimpulso(t):
    n = len(t)
    y = np.zeros(n)
    donde = 0
    for i in range(1,len(t)):
        if np.sign(t[i])!=np.sign(t[i-1]):
            donde=i
    y[donde]=1
    return(y)

# Calcula el impulso en t=0
elimpulso = unimpulso(t)

# SALIDA - GRAFICA
plt.figure(5)
plt.stem(t,elimpulso)

plt.margins(dt)
plt.xlabel('t')
plt.ylabel('impulso(t)')
plt.grid()
plt.show()

También se puede usar la librería scipy para tener un impulso más general:

https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.unit_impulse.html

hay que importar la libreria scipy para ese caso.

Señales operaciones en tiempo

Referencia: Oppenheim 1.2.1 pdf/p.36, Lathi 1.2 pdf/p.55

Desplazamiento en tiempo

Una señal x(t) que se retrasa por k segundos se representa como una versión desplazada hacia la derecha el eje t.

Es decir:

\phi (t+k)= x(t)

o de otra forma:

\phi (t)= x(t-k)

se podrá observar entonces que el signo determina el desplazamiento hacia:

  • la derecha si se resta k
  • la izquierda si se suma k

Para mostrar las reglas, se tiene el siguiente ejemplo:

# Señales- Operaciones
# propuesta: edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt

# INGRESO - tiempo [a,b)
a = -8
b = 8
dt = 0.1
k = 1  # desplazamiento

# PROCEDIMIENTO
t = np.arange(a,b,dt)

senal = np.sin(t)
derecha = np.sin(t-k)
izquierda = np.sin(t+k)


# SALIDA
plt.figure(1)
plt.plot(t,senal,label='x(t)')
plt.plot(t,derecha,label='derecha=x(t-k)')
plt.plot(t,izquierda,label='izquierda=x(t+k)')
plt.axvline(0)
plt.xlabel('t')
plt.legend(loc='lower left')
plt.show()

Escalamiento en tiempo

La compresión o expansión de la señal en el tiempo es conocida como escalamiento en el tiempo.

Considere la señal x(t) afectada en el tiempo por un factor de 2.
Se encuentra que:

\phi\Big(\frac{t}{2}\Big)=x(t) \phi(t)=x(2t)

siguiendo con la señal del ejercicio anterior x(t)=sin(t)

# Escalamiento en tiempo
factor = 2

expande = np.sin((1/factor)*t)
comprime = np.sin(factor*t)

#salida
plt.figure(2)
plt.plot(t,senal,label='x(t)')
plt.plot(t,expande,label='expande=x(t/factor)')
plt.plot(t,comprime,label='comprime=x(t*factor)')
plt.axvline(0)
plt.xlabel('t')
plt.legend(loc='lower left')
plt.show()

Inversión en tiempo

Si la función resultante es x(-t), la señal x(t) se invierte rotando sobre el eje de las ordenadas (vertical).

Observe el resultado de la ecuacion de ejemplo:

# inversion en tiempo
espejo = np.sin(-t)

#salida
plt.figure(3)
plt.plot(t,senal,label='x(t)')
plt.plot(t,espejo,label='espejo=x(-t)')
plt.axvline(0)
plt.xlabel('t')
plt.legend(loc='lower left')
plt.show()

En resumen, el efecto de transformar la variable independiente de una señal x(t) para obtener la señal modificada es de la forma:

x(at+b)

Con la transformación, la variable independiente conserva la forma de x(t). La señal puede ser:

  • alargada linealmente cuando |a| < 1 ,
  • comprimida si |a| > 1,
  • invertida en el tiempo si a < 0, y
  • desplazada en el tiempo si b es diferente de cero.
    • siendo desplazada a la derecha si se resta el valor de |b|
    • siendo desplazada a la izquierda si se suma el valor de |b|

Desplazamiento en tiempo

solo de un click y observe por un minuto el siguiente video sobre el desplazamiento en el tiempo (delay) en una guitarra.

 

 

Señales de Energía y Potencia

Señal de Energía

Una señal de energía tiene energía finita. En general toda señal en el sentido práctico tiene duración finita, por lo que la energía es finita.

La energía se define como:

E=\int_{-\infty}^{\infty} x^2(t) dt

o de una forma más general incluyendo señales de tipo compleja:

E=\int_{-\infty}^{\infty} |x(t)|^2 dt

No se considera solo como energía como el área bajo la curva, o integral de la señal, debido a que puede contener áreas de signo negativo que pueden cancelar la media. El cuadrado de la señal será siempre positivo.

La señal tiene que ser de tipo finita para que la medida tenga significado.

Una condición necesaria para que la señal sea finita es que su amplitud → 0 cuando |t|→ ∞. En cualquier otro caso la integral no converge.

Para una señal discreta:

E=\sum_{n=-\infty}^{\infty} | x[n] |^2

Ejemplo de señal de Energía

Un ejemplo de señal de Energía es un audio limitado en el tiempo, pues su amplitud tiende a 0 cuando |t|→ ∞.

Usando el mismo archivo de audio del ejercicio de señales analógicas y digitales:
Alarm01.wav

tenemos que:

# Señales de Energía y Potencia
# propuesta: edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt
import scipy.io.wavfile as waves

# INGRESO
# archivo = input('archivo de audio: ')
archivo = 'Alarm01.wav'
muestreo, sonido = waves.read(archivo)

# PROCEDIMIENTO
muestra = len(sonido)
dt = 1/muestreo
t = np.arange(0,muestra*dt,dt)
uncanal = sonido[:,0]

# SALIDA - Observación intermedia
plt.plot(t,uncanal)
plt.xlabel('t segundos')
plt.ylabel('sonido(t)')
plt.show()

El audio mostrado es una señal limitada en el tiempo, por lo que es posible calcular su energía usando la formula descrita.

Integración numérica de muestras

En el caso de las muestras disponibles de audio, las muestras estan igualmente espaciadas, se puede integrar usando la regla de Simpson´s integrate.simps(valores,t) para obtener un estimado de alta precisión.

import scipy.integrate as integrate

# cuadrado de la señal para el integral de energía
cuadrado = uncanal**2

#integrando a partir de muestras de la señal
energia = integrate.simps(cuadrado,t)

# SALIDA
print(' La energía del audio es: ',energia)
print('\n revisando el canal y sus cuadrados')
print(uncanal[2500:2510])
print(cuadrado[2500:2510])
 La energía del audio es:  3827.5753288
 revisando el canal y sus cuadrados
[-16  -1   8  -3  -8   4  11  -1  -4  10]
[256   1  64   9  64  16 121   1  16 100]

Señal de Potencia

Si en x(t) la amplitud no tiende → 0 al mismo tiempo que |t|→ ∞, la energia de la señal será infinita.

Una mejor medida de la señal en este caso es promedio de energia en el un intervalo de tiempo T, si és periódica, existe T.

La señal de potencia se define como:

P_x =\lim_{T \to \infty}\frac{1}{T} \int_{-T/2}^{T/2} | x(t) |^2 dt

y para una señal discreta:

P =\lim_{N \to \infty}\frac{1}{2N+1} \sum_{n=-N}^{N} | x[n] |^2

Ejemplo: potencia de una señal

Considere una señal periódica conocida sin(), integrando dentro de un periodo podemos calcular la energía y luego la potencia.

# INGRESO - Parámetros
w = 1
a = 0
b = 2*np.pi #un periodo
dte = 0.005

# PROCEDIMIENTO
T = 2*np.pi/w
te = np.arange(a, b, dte)
xe = np.sin(w*te)

# energía en un periodo
cuadradoxe = xe**2
energiaxe = integrate.simps(cuadradoxe,te)

# potencia en un periodo
potenciaxe = (1/T)*energiaxe

# SALIDA
print('la energia de xe es: ',energiaxe)
print('la potencia de xe es: ',potenciaxe)
# gráfica
plt.plot(te,xe,label='xe')
plt.fill_between(te,0,cuadradoxe,color='lightgreen')
plt.plot(te,cuadradoxe,'g--', label='xe^2')
plt.xlabel('t')
plt.legend()
plt.show()
la energia de xe es:  3.14159264282
la potencia de xe es:  0.499999998285

Para revisar los resultados, realizamos el cáculo de potencia haciendo x(t)=sin(t)

P_x =\lim_{T \to \infty}\frac{1}{T} \int_{-T/2}^{T/2} | x(t) |^2 dt

se tiene que:

=\frac{1}{2\pi} \int_{0}^{2\pi} | sin(t) |^2 dt = \frac{1}{2\pi} \int_{0}^{2\pi} \big[ \frac{1}{2}-\frac{cos(2t)}{2}\big] dt =\frac{1}{4\pi} \int_{0}^{2\pi} \big[ 1-{cos(2t)}\big] dt =\frac{1}{4\pi} \big[\int_{0}^{2\pi} 1 dt - \int_{0}^{2\pi}{cos(2t)} \big]dt =\frac{1}{4\pi} \big[t \Big|_0^{2\pi} \ - \frac{sin(2x)}{2}\Big|_0^{2\pi} \ \big] =\frac{1}{4\pi}\big[(2\pi-0)- (sin(2\pi)-sin(0)) \big] = \frac{1}{2}

que es el resultado de potencia obtenido usando python.

Tarea

Realice el mismo cálculo para la energía de la señal del ejemplo anterior.

Referencia: Lathi 1.1-1 pdf/p.51, Schaum 1.2.G pdf/p.16

Señales Pares e Impares

Señales Pares

Una señal x(t) ó x[n] es par si se «refleja» en el eje vertical u ordenadas.

x(t) = x(-t) x[n] = x[-n]

La señal tiene los mismos valores para el lado positivo o negativo de |t|.

Es como si se aplicara el valor absoluto de t antes de hacerlo en la ecuación.

Señales Impares

Una señal x(t) ó x[n] es impar si se cumple que:

x(t) = -x(-t) x[n] = -x[-n]

Una señal impar debe ser necesariamente 0 en t=0 o n=0.

Ejemplos

Para ilustrar mejor el concepto se reutiliza los ejemplos anteriores de señales periódicas.

Se inicializa los parámetros para:

  • el periodo T de una señal
  • el número m de periodos que se observarán de cada lado del eje vertical
  • punto de inicio t0 para el eje horizontal
  • n muestras de la señal a observar
# Señales pares e impares
# propuesta: edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt

# ingresar parámetros
T = 2*np.pi
m = 1 #periodos para la gráfica
t0 = -m*T #usa lado negativo de abscisas
n = 100

Ejemplo función par

Un señal par conocida es cos()

Para observar mejor, se marcará el área que genera la función dentro de un periodo centrado en el origen.

# PROCEDIMIENTO
# vector de tiempo
tn = -t0  # completa el reflejo positivo
dt = (tn-t0)/n
t = np.arange(t0,tn,dt)

# Señal
f = 1/T
w = 2*np.pi*f
senalpar = np.cos(w*t)

# marcar un periodo en [desde, hasta)
desde = -T/2
hasta = desde + T + dt
tperiodo = np.arange(desde,hasta,dt)
periodopar = np.cos(w*tperiodo)

Se marca un periodo comprendido en: [-T/2,T/2], sombreando alrededor de t=0

# SALIDA
# Gráficas
plt.figure(1)
plt.plot(t,senalpar)
plt.xlabel('t')
plt.ylabel('señal x[(t)]')
plt.grid(True)

# marcar un periodo
plt.title('Señal par')
plt.fill_between(tperiodo,0, periodopar,color='lightgreen')
plt.axvline(x=0, color='red')
plt.show()

Ejemplo función impar

En el ejemplo se usará una señal par como el sin()

Para observar mejor, se marcará el area que genera la función dentro de un periodo centrado en el origen.

Como el eje t ya fué generado en el ejercicio anterior, se continúa con la generación de la gráfica.

# señal
senalimpar = np.sin(w*t)

# marcar un periodo
periodoimpar = np.sin(w*tperiodo)

Se marca un periodo comprendido en: [-T/2,T/2], sombreando alrededor de t=0

# SALIDA
# Gráficas
plt.figure(2)
plt.plot(t,senalimpar)
plt.xlabel('t')
plt.ylabel('señal x[(t)]')
plt.grid(True)

# marcar un periodo
plt.title('Señal impar')
plt.fill_between(tperiodo,0, periodoimpar,color='lightblue')
plt.axvline(x=0, color='red')
plt.show()

Tarea

probar con otras funciones tales como:

  • t
  • |t|
  • t2
  • t3
  • |- et|

nota: el valor absoluto en python para t se escribe como abs(t), o usando numpy np.abs(t)

Referencia: Oppenheim 1.2.3 pdf/p41, Schaum 1.2.E pdf/p.14

Señales Periódicas y No periódicas

'señales

Señal Periódica

Una señal periódica contínua tiene la propiedad que su valor se repite luego de un desplazamiento de tiempo T.

x(t) = x(t+T)

El valor de T es conocido como el periodo de la señal.

La relación entre el periodo T y la frecuencia f se da por la ecuacion:

f = \frac{1}{T} \text{, en Hz} \omega = 2 \pi f = \frac{2 \pi}{T} \text{, en rad/s}

otra forma de escribir la ecuación es:

x(t) = x(t + mT)

para cualquer valor de t y cualquier número entero m. El periodo fundamental T0 de x(t) es el valor positivo más pequeño que hace posible la ecuación descrita.

Algoritmo en Python

Se analiza una señal coseno(), con periodo T=2π, en un rango de dos periodos m=2, y 50 muestras, luego se determina el vector t para el rango de observación y se calcula la señal:

# Señales periodicas
# propuesta: edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt

# ingresar parámetros
T = 2*np.pi
m = 2 #periodos para la gráfica
t0 = 0
n = 50

# PROCEDIMIENTO
# vector de tiempo
tn = T*m
dt = (tn-t0)/n
t = np.arange(t0,tn,dt)

# señal
f = 1/T
w = 2*np.pi*f
senal = np.cos(w*t)

# marcar un periodo en [desde, hasta)
desde = T/4
hasta = desde + T + dt
tperiodo = np.arange(desde,hasta,dt)
periodo = np.cos(w*tperiodo)

La gráfica se conforma de dos partes:

  • la señal calculada
  • la señal marcada en un periodo
# SALIDA
# Gráficas
plt.plot(t,senal)
plt.xlabel('t')
plt.ylabel('señal x[(t)]')

# marcar un periodo
plt.title('marcando un periodo')
plt.fill_between(tperiodo,0, periodo,facecolor='green')
plt.show()

Señal periódica discreta

Se define semejante a las señales periódicas contínuas como una secuencia discreta en el tiempo x[n]. La señal es periódica con periodo N si existe un número entero positivo para el que:

x[n + N] = x[n] \text{, para todo n} x[n + mN] = x[n]

para todo n y cualquier entero m

El periodo fundamental N0 de x[n] es el valor positivo mas pequeño para que se cumpla la ecuación en la secuencia de datos de la señal.

Como ejemplo se usa una señal muestreada del coseno:

# ingreso de parámetros
N = 8
m = 4
t0 = 0

# Procedimiento
tn = m*N
w = 2*np.pi/N
n = np.arange(t0,tn,1)
xn = np.cos(w*n)

# Salida
plt.figure(2)
plt.stem(n,xn)
plt.xlabel('n')
plt.ylabel('x[n]')
plt.show()

Señal No periódica

En éste caso, los valores de la señal no se repiten para ningun valor de T.

También para algunos problemas se considera que T → ∞.

Un ejemplo del tipo de señal es: x(t)=t^2

# continuando con el mismo t del problema anterior
x = t**2

# Gráfica
plt.figure(3)
plt.plot(t,x)
plt.xlabel('t')
plt.ylabel('x(t)')
plt.show()


Para el caso de señal discreta:

yn = n**2

# SALIDA - Gráfica
plt.figure(4)
plt.stem(n,yn)
plt.xlabel('n')
plt.ylabel('y[n]')
plt.show()

Tarea

Pruebe con otras funciones contínuas para x(t) como:

  • t^3
  • e^t
  • \frac{1}{t}

en python, el exponente se escribe como: t**3 y en la otra función np.exp(t)

Realizar el mismo paso para sus formas discretas.

Referencia: Oppenheim 1.2.2 pdf/p.39, schaum cap1.F pdf/p.4, lathi 1.3.3. pdf/p.61

Señales Analógicas y Digitales

Señales Analógicas y Digitales

Señal Analógica vs Digital

Señales analógicas

Una señal se clasifica como analógica cuando su amplitud puede tomar un infinito numero de valores en un rango contínuo de tiempo.

Por ejemplo, una señal de sonido como la del archivo: Alarm01.wav

Descargue el archivo use un programa como windows media player para escuchar su contenido.

Algoritmo Python

Para observar en una gráfica la señal del archivo anterior, use las siguientes instrucciones:

# Señales analógicas
# propuesta: edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt
import scipy.io.wavfile as waves

# INGRESO
# archivo = input('archivo de audio: ')
archivo = 'Alarm01.wav'
muestreo, sonido = waves.read(archivo)
# SALIDA - Observacion intermedia
print('frecuencia de muestreo: ', muestreo)
print('dimensiones de matriz: ', np.shape(sonido))
print('datos de sonido: ')
print(sonido)
frecuencia de muestreo:  22050
dimensiones de matriz:  (122868, 2)
datos de sonido: 
[[0 0]
 [0 0]
 [0 0]
 ..., 
 [0 0]
 [0 0]
 [0 0]]

Con los resultados mostrados, se observa que:

  • la señal de audio tiene frecuencia de muestreo de 22050 Hz
  • Las dimensiones de la matriz sonido (122868,2) indican que es de tipo estéreo por usar columnas
  • el valor de 122868 corresponde a la cantidad de muestras por canal.
  • Los índices para seleccionar un canal son 0 ó 1.

Para observar la forma del sonido se extrae solo un fragmento usando el canal 0.

Para observar otros fragmentos la señal de audio cambie los valores de  [inicia,termina).

# Fragmento de tiempo
inicia = 2600
termina = 2720
canal = 0

# Extrae el fragmento de sonido
dt = 1/muestreo
t = np.arange(inicia*dt,termina*dt,dt)
muestras = len(t)
fragmento = sonido[inicia:inicia+muestras, canal]

#SALIDA
plt.plot(t,fragmento)
plt.xlabel('t segundos')
plt.ylabel('sonido(t)')
plt.show()

Señales digitales

Una señal se clasifica como digital cuando la amplitud  puede tomar solo un número finito de valores, para un número finito de muestras en el tiempo.

Siguiendo el ejemplo de la señal de audio, las señales digitales se las asocia con computadoras. Para almacenar una señal de audio, se la cuantifica en amplitud a espacios iguales de tiempo dt.

Por ejemplo, datos del vector fragmento del audio del ejercicio anterior muestran el caracter finito, discreto, por muestras de la señal.

# SALIDA - datos del fragmento de audio
print(fragmento)
[  -36   -52    11  -280  -595  -186   656   800   141  -237   -53  -246  -910  -739   569  1347   620  -288  -195   -57  -812 -1229   -37  1419  1183   -51  -348    47  -424 -1322  -778   955  1531   432  -363   -62  -123 -1062 -1189   306  1514   910  -172  -224   -57  -720 -1191  -164  1241  1134    75  -295  -144  -533 -1035  -367   953  1144   262  -234  -202  -499  -931  -423   781  1095   344  -152  -174  -491  -916  -440   739  1088   353  -149  -158  -467  -901  -472   693  1116   405  -164  -172  -434  -906  -558   608  1139   478  -159  -181  -370  -870  -655   494  1151   565  -130  -180  -307  -812  -735   358  1149   666   -95  -213  -291  -785  -824   214  1143   784   -31  -217  -249  -727  -888    54]

los datos del fragmento de audio, muestran que la señal de audio se almacena como una señal discreta, o digital, por lo que una gráfica más apropiada es:

# grafica fragmento de sonido en forma discreta
n = np.arange(inicia,inicia+muestras,1)
plt.stem(n,fragmento)
plt.xlabel('n')
plt.ylabel('fragmento sonido[n]')
plt.show()

Observaciones

Los términos «contínuo en el tiempo» y «discreto en el tiempo» cuantifican la naturaleza de la señal solo en el eje de las abscisas (horizontal).

Los términos «analógicos» y «digitales» cuantifican la amplitud de la señal o eje de las ordenadas (vertical).

Una señal de audio, por su naturaleza es de tipo analógica, que para almacenarla o procesarla en un computador se convierte a digital al cuantificar sus valores de amplitud, de la forma mostrada en el ejercicio.

Tarea

  • cambie los rangos de observación de la señal de audio y repita las gráficas para su forma analógica aproximada (parte 1) y para su forma digital (parte 2)
  • comente sobre el fragmento inicial y final donde los valores de la señal son 0’s

Referencia: Lathi 1.3.2 pdf/p.61, Schaum pdf/p.13

Señales Discretas

De forma similar, siguiendo el ejemplo anterior para una señal contínua, se realiza el muestreo de la señal, generando una secuencia numérica:

\sin [\omega _0]

señal discreta 01

El muestreo para cada valor n se establece en el  intervalo [0, m) , para m muestras y con frecuencia ω0 = 2π/12 radianes/segundo.

Para el ejercicio se usa m=20

# Señales discretas
# propuesta: edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt

# INGRESO - parámetros
n0 = 0
m = 20
w0 = 2*np.pi/12

Los valores discretos de n se almacenan en un vector de tamaño m.

La señal se puede crear usando la funcion sin() incluida en numpy, obteniendo como resultado:

# PROCEDIMIENTO
# vector n discreto
n = np.arange(n0,m,1)
# señal
senal = np.sin(w0*n)

observe que los valores para n corresponden a una secuencia numérica.

# SALIDA
print('n: ')
print(n)
print('señal x[n]: ')
print(senal)
n: 
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
señal x[n]: 
[  0.00000000e+00   5.00000000e-01   8.66025404e-01   1.00000000e+00   8.66025404e-01   5.00000000e-01   1.22464680e-16  -5.00000000e-01  -8.66025404e-01  -1.00000000e+00  -8.66025404e-01  -5.00000000e-01  -2.44929360e-16   5.00000000e-01   8.66025404e-01   1.00000000e+00   8.66025404e-01   5.00000000e-01   3.67394040e-16  -5.00000000e-01]

Para observar el resultado de la señal, se grafica n vs señal[n], añadiendo las etiquetas para cada eje, y mostrando el resultado con plt.show().

Se usa la gráfica stem() para obtener en la gráfica el punto y una línea que muestre la magnitud, semejante a las gráficas de los libros de texto.

# Gráficas
plt.stem(n, senal)
plt.xlabel('n')
plt.ylabel('señal x[n]')
plt.show()

señal discreta 01

Tarea

Para ésta sección, se cambiarán los parámetros de n y ω0.

  • m = 50
  • ω0 = π/4 y ω0 = 15π/8
  • cambiar la función a np.cos()
  • ¿se puede cambiar la amplitud de la señal a 2 y ω0=1/6?

Referencia: Oppenheim 1.3.2 fig.1.25 pdf/p.52, Schaum 1.2.A p.12

Señales Contínuas

Para la clasificación se señales empezamos con un ejemplo clásico de una señal contínua:

\sin (\omega t)

El tiempo se define en el intervalo [t0, tn) para n muestras y una frecuencia ω en radianes/segundo.

Para facilitar la tarea se usan las librerias para el manejo de vectores y gráficas:

    • vectores – numpy
    • gráficas – matplotlib.pyplot
# Señales continuas
# propuesta: edelros@espol.edu.ec

import numpy as np
import matplotlib.pyplot as plt

# INGRESO parámetros
t0 = 0
tn = 2*np.pi
n = 50
w = 1

Los valores de tiempo t se almacenan en un vector de tamaño n.
Entre cada valor de t existe una diferencia dt deteminada por n.

# PROCEDIMIENTO
# vector de tiempo
dt = (tn-t0)/n
t = np.arange(t0,tn,dt)

# señal
senal = np.sin(w*t)

El resultado puede ser observado de dos formas:
– mostrando sus valores o
– sus gráficas.
Se presentan las dos opciones a escoger.

# SALIDA
print('tiempo: ')
print(t)
print('señal: x(t) ')
print(senal)
tiempo: 
[ 0.          0.12566371  0.25132741  0.37699112  0.50265482  0.62831853  0.75398224  0.87964594  1.00530965  1.13097336  1.25663706  1.38230077  1.50796447  1.63362818  1.75929189  1.88495559  2.0106193   2.136283  2.26194671  2.38761042  2.51327412  2.63893783  2.76460154  2.89026524  3.01592895  3.14159265  3.26725636  3.39292007  3.51858377  3.64424748  3.76991118  3.89557489  4.0212386   4.1469023   4.27256601  4.39822972  4.52389342  4.64955713  4.77522083  4.90088454  5.02654825  5.15221195  5.27787566  5.40353936  5.52920307  5.65486678  5.78053048  5.90619419  6.03185789  6.1575216 ]
señal: x(t) 
[  0.00000000e+00   1.25333234e-01   2.48689887e-01   3.68124553e-01   4.81753674e-01   5.87785252e-01   6.84547106e-01   7.70513243e-01   8.44327926e-01   9.04827052e-01   9.51056516e-01   9.82287251e-01   9.98026728e-01   9.98026728e-01   9.82287251e-01   9.51056516e-01   9.04827052e-01   8.44327926e-01   7.70513243e-01   6.84547106e-01   5.87785252e-01   4.81753674e-01   3.68124553e-01   2.48689887e-01   1.25333234e-01  -3.21624530e-16  -1.25333234e-01  -2.48689887e-01  -3.68124553e-01  -4.81753674e-01  -5.87785252e-01  -6.84547106e-01  -7.70513243e-01  -8.44327926e-01  -9.04827052e-01  -9.51056516e-01  -9.82287251e-01  -9.98026728e-01  -9.98026728e-01  -9.82287251e-01  -9.51056516e-01  -9.04827052e-01  -8.44327926e-01  -7.70513243e-01  -6.84547106e-01  -5.87785252e-01  -4.81753674e-01  -3.68124553e-01  -2.48689887e-01  -1.25333234e-01]

Para observar el resuldado de la señal, se grafica t vs señal. Para mejor identificación de ejes, se añade las etiquetas.

# Gráficas
plt.plot(t,senal)
plt.xlabel('t')
plt.ylabel('señal x[(t)]')
plt.show()

Tarea

Para ésta sección, se cambiarán los parámetros de tiempo.

      • tn=8π
      • ω=2
      • cambiar la función a np.cos()
      • ¿se puede cambiar la amplitud de la señal a 4?

Referencia: Oppenheim 1.1 pdf/p.29, Lathi 1.3.1 pdf/p.60, Schaum 1.2.A pdf/p.12