2.7 Sistemas – Interconexión serie, paralelo, retroalimentado

Referencia: Oppenheim 1.5.2 p41, Hsu 1.5.I p19, Lathi 4.5 p386

Los sistemas pueden crearse a partir de subsistemas más sencillos. La interconexion entre los sistemas permite resolver por partes los problemas de mayor complejidad y luego integrar sus respuestas.

La interconexión de dos sistemas puede ser realizada de varias formas:

1. Interconexión en serie (cascada)
2. Interconexión en paralelo
3. Interconexión en serie-paralelo
4. Interconexión con retroalimentación

Para ilustrar las formas de interconexión de forma gráfica se usan los diagramas de bloques, al interconectar las salidas y entradas entre bloques.

Interconexión en serie

sistema serie

El diagrama de bloques representa la conexión de subsistemas en forma secuencial usando la salida a una entrada del siguiente..

Ejemplo: la salida de video de la computadora hacia la entrada de video del proyector en el aula de clases, usada para proyectar el contenido del curso.

Interconexión en Paralelo

fiec05058Sistema04

El diagrama de bloques muestra que la señal de entrada se aplica simultaneamente o en paralelo a dos los subsistemas, el símbolo ‘+’ expresa que el resultado es la suma de los resultados de los sistemas h1(t) y h2(t).

Interconexión serie-paralelo

Se añade el diagrama de bloques para la conexión en paralelo de un subsistema en serie h1(t) y h2(t), en paralelo con un subsistema h3(t)

sistemas en serie y paralelo

Interconexión con retroalimentación

sistema retroalimentado ejemplo

Los sistemas retroalimentados permiten «regular» la salida «observando» una parte de la misma

2.6 Sistemas contínuos y discretos, analógicos y digitales

Referencia: Oppenheim 1.5 p38 pdf69, Hsu 1.5.B p17, Lathi 1.7-5 p107

Sistemas contínuos

En un sistema contínuo las señales contínuas de entrada son transformadas en señales contínuas de salida.

x(t) \rightarrow y(t)

fiec05058Sistema01

Por ejemplo el «audio» de una voz cantando en un micrófono es una entrada contínua, que al pasar por el sistema de amplificadores se obtiene una señal contínua eléctrica de salida hacia los parlantes.

Archivo de audio: muestra_Invernal01.wav
Archivos de Audio.wav – Abrir, extraer una porción en Curso de Fundamentos de Programación.

Sistema Discreto

Cuando las entradas de tiempo son muestras discretas se transforman en salidas de tiempo discreto, al sistema se denomina «sistema discreto«.

Simbólicamente se representa como:

x[n] \rightarrow y[n]

fiec05058Sistema02

 

Por ejemplo un filoscopio, flipbook o libro animado usa entradas y salidas de tiempo discretas.


Sistemas Analógicos y Digitales

Referencia: Lathi 1.7-6 pdf79, 1.3-2 pdf61

Un sistema con señales de entradas y salidas analógicas o contínuas se lo denomina» sistema analógico».

De forma semejante, un sistema cuyas entradas y salidas son digitales es un sistema digital, como una computadora, aunque también se conoce como un sistema discreto en el tiempo.

2.5 Sistemas Causales y No causales con Sympy-Python

Referencia: Lathi 1.7-4 p104, Oppenheim 1.6.3 p46

Un sistema es CAUSAL (no-anticipativo o físico) si la salida y(t) en un valor arbitrario de tiempo t=t0 depende solo de la entrada x(t) para t ≤ t0 , es decir depende solo de los valores presentes y/o pasados de la entrada; no depende de valores futuros.

No es posible obtener una salida antes que se aplique la entrada.


Ejemplos 1. desplazamiento en tiempo, retraso

Referencia: Hsu 1.5.D p17

y(t) = x(t - 1)

Para observar mejor el sistema del ejemplo, se inicia con un desplazamiento negativo. Si t es en segundos, la salida depende de los valores de x hace un segundo atras (t-1)

Usando como entrada:

x(t) = e^{-t} \mu (t)
      1 - t                 
yf = e     *Heaviside(t - 1)
                       1 - t                    
yw = 2.11700001661267*e     *Heaviside(t - 1.75)

Considere los eventos de interés mundial que se transmiten con un retraso de segundos para corregir «fallos» o por seguridad, se puede aún editar lo que los espectadores en televisión pueden observar, en tiempo «casi real»

Por ejemplo:

» La cadena de televisión NBC transmitirá la ceremonia de apertura de los Juegos Olímpicos de Río de Janeiro 2016 con una hora de retraso …  eso permitirá a los productores «curar» la cobertura para proporcionar un contexto adecuado.»

12-Julio-2016

http://www.hoylosangeles.com/deportes/rio2016/hoyla-rio2016-nbc-transmitira-inauguracion-demora-story.html

«In radio and television, broadcast delay is an intentional delay when broadcasting live material. Such a delay may be short (often seven seconds) to prevent mistakes or unacceptable content from being broadcast.»

https://en.wikipedia.org/wiki/Broadcast_delay


En el caso contrario, los sistemas NO CAUSALES muestran una salida anticipada a la señal de entrada. ¿es posible? ¿cómo?

Ejemplo 2. desplazamiento en tiempo, adelanto

Referencia: Hsu 1.5.D p17

y(t) = x(t + 1)

si t es en minutos o años, la salida depende de los valores que x(t) tendría un minuto o año después o (t+1).

Si t es en días, la situación se vuelve complicada de realizar, es como decir: para determinar el valor de la variable y(t) HOY, necesitamos conocer el valor de x(t+1) que es MAÑANA.

https://www.elcomercio.com/guaifai/volver-futuro-tecnologia-futurologia.html

Los sistemas no-casuales por tener variable independiente referenciada a tiempo futuro, no se pueden implementar en tiempo real. Sin embargo si los sistemas no causales se realizan con variables diferentes al tiempo, por ejemplo «espacio» se podrían implementar.

Usando como entrada, la misma que el ejemplo anterior

x(t) = e^{-t} \mu (t)
      -t - 1                 
yf = e      *Heaviside(t + 1)
                       -t - 1                    
yw = 2.11700001661267*e      *Heaviside(t + 0.25)

Aunque si considera que los datos de tiempo registrado para un evento, el análisis se puede realizar en un rango donde los no-causales aún se podrían analizar o procesar aunque no en tiempo real.

«No, la lluvia no hace que te duelan las rodillas» – AS.com. 25-feb-2017. https://as.com/deporteyvida/2017/02/25/portada/1488041024_696949.html


Ejemplo 3. Sistema con amplitud variable en tiempo (AM)

Referencia: Oppenheim Ejemplo 1.12 p47

Considere el sistema dado por:

y(t) = x(t) \cos(t+1)

En este sistema, la salida en cualquier tiempo t es igual a la entrada en el mismo tiempo t multiplicada por un número que varia en el tiempo. Usando q(t) = cos(t+1) que es una función variante en el tiempo,  el sistema puede escribirse como

y(t) = x(t) q(t)

Se observa que solo el valor actual de la entrada x(t) influye en el valor de salida  de y(t). Se concluye que el sistema es causal y también sin memoria.

Usando como entrada

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

resultados con algoritmo:

      -t                        
yf = e  *cos(t + 1)*Heaviside(t)
                       -t                               
yw = 2.71828182845905*e  *cos(t + 1)*Heaviside(t - 1.0)

Ejemplo 4. Adelanto e Inversión en tiempo

y(t) = x(-(t+2))

Suponga que x(t) = cos(t) μ(t) para hacer notar el inicio de la señal de entrada


Ejemplo 5. desplazamiento e inversión en tiempo

y(t) = x(t)+x(5-t)

Suponga que x(t) = cos(t) μ(t) para hacer notar el inicio de la señal de entrada

Usando como entrada

x(t) = \cos(t) \mu (t)
yf = cos(t)*Heaviside(t) + cos(t - 5)*Heaviside(5 - t)
yw = cos(t - 4.25)*Heaviside(4.25 - t) + cos(t - 0.75)*Heaviside(t - 0.75)

Descripción a ser aplicada a TeneT:

 


Ejercicios:

a) y(t) = x(t-1)
b) y(t) = x(-t)
c) y(t) = x(t)+x(5-t)
d) otra


Instrucciones en Python

Ejemplo 1. desplazamiento en tiempo, retraso

El sistema se aplica sustituyento la variable t por t-1 en la entrada x, con la instrucción y = sym.Subs(x,t,t-1,evaluate=False)

# entradas desplazadas en t, revisar salida
# Sistemas Causales y NO causales en tiempo
# Hsu 1.5.D p17
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                'numpy']

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 0.75 
# señales de entrada
f = sym.exp(-t)*sym.Heaviside(t)
w = f.subs(t,t-t0)

# sistema
y = sym.Subs(x,t,t-1,evaluate=False)

# intervalo de t[a,b] para graficar
a = 0
b = 2*np.pi
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf,modules=equivalentes)
ywt = sym.lambdify(t,yw,modules=equivalentes)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.axvline(0,color='red')
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistema y='+str(y)+ '  ¿Causal?')
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.axhline(0)
plt.axvline(0,color='red')
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

Ejemplo 2. desplazamiento en tiempo, adelanto

lo mismo que el anterior pero con desplazamiento t+1 e intervalo ampliado en la parte izquierda del plano.

# Sistema sobre señal de entrada
y = x.subs(t,t+1)
 # intervalo de t[a,b] para graficar
a = -2
b = 2*np.pi
muestras = 101

Ejemplo 3. Sistema con amplitud variable en tiempo (AM)

y(t) = x(t) \cos(t+1)
# entradas desplazadas en t, revisar salida
# Sistemas Causales y NO causales en tiempo
# Oppenheim 1.12 p47 pdf78
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                'numpy']

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 1.0 
# señales de entrada
f = sym.exp(-t)*sym.Heaviside(t)
w = f.subs(t,t-t0)

# sistema
y = x*sym.cos(t+1)

# intervalo de t[a,b] para graficar
a = 0
b = 2*np.pi
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf,modules=equivalentes)
ywt = sym.lambdify(t,yw,modules=equivalentes)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.axvline(0,color='red')
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistema y='+str(y)+ '  ¿Causal?')
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.axhline(0)
plt.axvline(0,color='red')
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

Ejemplo 4. desplazamiento e inversión en tiempo

# entradas desplazadas en t, revisar salida
# Sistemas Causales y NO causales en tiempo
# Hsu 1.5.C p17
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                'numpy']

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 0.75 
# señales de entrada
f = sym.cos(t)*sym.Heaviside(t)
w = f.subs(t,t-t0)

# sistema
y = x + sym.Subs(x,t,(5-t),evaluate=False)

# intervalo de t[a,b] para graficar
a = -2*np.pi
b = 2*np.pi
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf,modules=equivalentes)
ywt = sym.lambdify(t,yw,modules=equivalentes)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.axvline(0,color='red')
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistema y='+str(y)+ '  ¿Causal?')
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.axhline(0)
plt.axvline(0,color='red')
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

2.4 Sistemas con memoria o sin memoria

Referencia: Oppenheim 1.6.1 p44 pdf75 , Lathi 1.7-3 p103, Hsu 1.5.C p17

Si la salida de un sistema depende solo del valor aplicado en la entrada para un tiempo cualquiera, se dice que el sistema es sin memoria.

Resistor01El ejemplo más común es un sistema con un resistor:

y(t) = Rx(t)

Por otra parte, si el sistema depende de los valores anteriores de la entrada, se lo considera sistema con memoriacapacitor01

Tal es el caso de un capacitor, cuyo valor de salida depende de lo acumulado desde el tiempo -∞ hasta t.

y(t) =\frac{1}{C} \int_{-\infty}^{t} x(\tau) d\tau

Los sistemas sin memoria también se conocen como instantaneos, que son un caso particular de los sistemas dinámicos (con memoria).

Un sistema  cuya respuesta en t está determinada por los anteriores T segundos, es decir el intervalo (tT), se lo conoce como «sistema con memoria finita»

 

2.3 Sistemas Invariantes y Variantes en el tiempo con Sympy-Python

Referencia: Oppenheim 1.6.5 p50, Lathi 1.7-2 p102, Hsu 1.5.F p18

Si el comportamiento de un sistema y sus parámetros no cambian en el tiempo, se los denomina sistemas invariantes en el tiempo.

Por ejemplo, para un circuito RC, los valores de la resistencia y capacitor fijos no varian si se realiza un experimento o medición hoy o mañana.

Expresando lo mismo como:
Un sistema es invariante en el tiempo si, ante un desplazamiento de tiempo en la señal de entrada, se ocasiona el mismo desplazamiento en el tiempo en la señal de salida. El resultado se repite si el desplazamiento del tiempo se aplica a la salida del sistema en lugar de la entrada.

x(t) \rightarrow y(t) x(t-t_0) \rightarrow y(t-t_0)

Ejemplo 1. Sistema con comportamiento senoidal

Referencia: Oppenheim 1.14 p51

Para muestra de lo indicado, considere un sistema definido como:

y(t) = \sin[x(t)]

Para revisar si es invariante en el tiempo, se debe determinar si sus propiedades de mantienen para cualquier entrada ante cualquier desplazamiento t0.

y_1 (t) = \sin[x(t - t_0)] y_2(t) = y(t - t_0)

Suponga x1(t)= e(-t)u(t) la señal bajo prueba, siendo x2(t)= e(-(t-t0))u(t-t0) la entrada x1(t) desplazada en t0. Haciendo t0=1, se puede observar en la gráfica si al aplicar el retraso antes o después del sistema tienen resultados iguales.

y_1 (t) = y_2(t)

En éste caso se observa que la señal de salida se mantiene invariante en su forma y desplazada en sincronía con la señal de entrada. Por lo que el sistema es INVARIANTE en el tiempo.

La gráfica y el siguiente resultado se realizaron con el algoritmo desarrollado a partir del tema anterior sobre sistemas lineales. El algoritmo se adjunta al final.

        / -t             \
yf = sin\e  *Heaviside(t)/
        /                  -t                   \
yw = sin\2.71828182845905*e  *Heaviside(t - 1.0)/
              /                  -t                   \
yf(t-t0) = sin\2.71828182845905*e  *Heaviside(t - 1.0)/

Por otro lado, si la respuesta de la señal se modifica en el tiempo, el sistema será VARIANTE en el tiempo.


Ejemplo 2. Sistema comprime en tiempo

Referencia: Oppenheim 1.16 p52.Hsu ejercicio 1.39 p48

Considere el sistema que tiene escalamiento en el tiempo.:

y(t) = x(2t)

y(t) es una versión comprimida en tiempo de x(t) en un factor de 2.
Los desplazamientos en el tiempo de la señal de entrada  al pasar por el sistema también se «comprimen» por un factor de 2.

Haciendo f(t) = μ(t+2)-μ(t-2) una señal rectangular centrada en el origen con color azul en la gráfica.
Si la entrada w(t) = f(t-2)= μ(t)-μ(t-4) es una real rectangular desplazada en 2 (en color verde), su resultado en la salida se encuentra centrado en 1.

Al desplazar el resultado de la señal de entrada en su forma original en azul, por t0 se obtiene la señal de salida en color rojo. Claramente los resultados de aplicar un retraso antes o después del sistema son diferentes.

Por lo que, por ésta razón el sistema NO es invariante en el tiempo.

yf = -Heaviside(2*t - 2) + Heaviside(2*t + 2)
yw = Heaviside(2*t) - Heaviside(2*t - 4.0)
yft0 = -Heaviside(2*t - 6.0) + Heaviside(2*t - 2.0)

Siguiendo las indicaciones en el problema presentado, donde T se conoce como el «operador lineal«. El sistema tiene una relación de entrada-salida dada por:

y(t) = T{x(t)} = x(2t)

y t0 es un desplazamiento en el tiempo.

Sea y2(t) la respuesta a x2(t) = x(t-t0) entonces:

y2(t) = T{x2(t)} = x2(2t) = x(2t-t0)

Si se desplaza el resultado de la señal de salida sin desplazar se tiene:

y(t-t0) = x(2(t-t0)) = x(2t-2t0))

y(t-t0) ≠ y2(t)

por lo que el sistema no es invariante en el tiempo.
El sistema x(2t) se conoce como compresor, pues crea una secuencia de salida cada 2 valores de la secuencia de entrada.


Ejemplo 3. Sistema multiplica por tiempo

Referencia: Oppenheim 1.13 p49, Oppenheim 1.17 p54, Hsu ejercicio 1.38 p47

Considere el siguiente sistema, cuya salida depende del intervalo de tiempo evaluado. Los desplazamientos afectan a la señal de salida.

y(t) = t x(t)

Desarrollar semejante al ejercicio anterior, en forma analítica y usando Python, para la entrada:

x(t) = \sin (t)

yf = t*sin(t)
yw = t*sin(t - 2.0)
yf(t-t0) = (t - 2.0)*sin(t - 2.0)

Para el sistema dado, al depender su magnitud de la variable t, la salida tiende a crecer con el tiempo, por lo que se puede intuir que el sistema es inestable.

Observando los resultados y la gráfica se tiene que el sistema NO es invariante en el tiempo.

Ejemplo 4. Sistema deriva la entrada

Referencia: Lathi 1.11 p103

Determine la invariabilidad de tiempo del siguiente sistema

y(t) = \frac{d}{dt} x(t) ,

Suponga x1(t)= e(-t)u(t), semejante a lo usado en el ejercicio 1.

El desarrollo con el algoritmo muestra que el sistema resulta invariante en el tiempo.

      -t                  -t             
yf = e  *DiracDelta(t) - e  *Heaviside(t)
                       -t                                         -t               
yw  = 2.71828182845905*e  *DiracDelta(t - 1.0) - 2.71828182845905*e  *Heaviside(t - 1.0)
                             -t                                         -t               
yf(t-t0) = 2.71828182845905*e  *DiracDelta(t - 1.0) - 2.71828182845905*e  *Heaviside(t - 1.0)

En este caso, dado que la señal de entrada tiene una función escalón, sympy no presenta inconvenientes en realizar la derivada. Sin embargo, la operacion de conversión con Lambdify será necesario añadir la equivalencia de DiracDelta en numpy. Por lo que la instrucción de Lambdify se le añade el parámetro para considerar los modulos equivalentes.

equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                'numpy']

Instrucciones en Python

Desarrollado a partir del algoritmo usado para sistemas lineales y no lineales

Ejemplo 1. Sistema con comportamiento senoidal

# entradas desplazadas en t, revisar salida
# Revisa Invarianza en tiempo
# Oppenheim 1.14 p51 pdf82
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 1.0 
# señales de entrada
f = sym.exp(-t)*sym.Heaviside(t)
w = f.subs(t,t-t0) # desplaza f

# sistema
y = sym.sin(x)

# intervalo de t[a,b] para graficar
a = 0
b = 2*np.pi
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()
yf0 = yf.subs(t,t-t0).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf)
ywt = sym.lambdify(t,yw)
yf0t = sym.lambdify(t,yf0)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)
yfi0 = yf0t(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)
print('yf(t-t0):')
sym.pprint(yf0)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistemas Invariante: y='+str(y))
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.plot(ti,yfi0,'.',color='red', 
         label='yft0=yf[t-t0]')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

Ejemplo 2. Sistema comprime en tiempo

Para aplicar cambios en la variable tiempo, en el algoritmo se sustituye en la expresión de la señal de entrada la variable t por 2t.

# entradas desplazadas en t, revisar salida
# Revisa Invarianza en tiempo
# Oppenheim 1.16 p52.Hsu ejercicio 1.39 p48
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 2.0
# señales de entrada
f = sym.Heaviside(t+2)-sym.Heaviside(t-2)
w = f.subs(t,t-t0) # desplaza f

# sistema
y = sym.Subs(x,t,2*t,evaluate=False)

# intervalo de t[a,b] para graficar
a = -5
b = 5
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()
yf0 = yf.subs(t,t-t0).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf)
ywt = sym.lambdify(t,yw)
yf0t = sym.lambdify(t,yf0)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)
yfi0 = yf0t(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)
print('yf(t-t0):')
sym.pprint(yf0)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistemas Invariante: y='+str(y))
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.plot(ti,yfi0,'--',color='red', 
         label='yft0=yf[t-t0]')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

Ejemplo 3. Sistema multiplica por tiempo

# entradas desplazadas en t, revisar salida
# Revisa Invarianza en tiempo
# Oppenheim 1.13 p49.Hsu ejercicio 1.38 p47
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 2.0
# señales de entrada
f = sym.sin(t)
w = f.subs(t,t-t0) # desplaza f

# sistema
y = t*x

# intervalo de t[a,b] para graficar
a = 0
b = 3*np.pi
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()
yf0 = yf.subs(t,t-t0).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf)
ywt = sym.lambdify(t,yw)
yf0t = sym.lambdify(t,yf0)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)
yfi0 = yf0t(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)
print('yf(t-t0):')
sym.pprint(yf0)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistemas Invariante: y='+str(y))
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.plot(ti,yfi0,'--',color='red', 
         label='yft0=yf[t-t0]')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

Ejemplo 4. Sistema deriva la entrada

# entradas desplazadas en t, revisar salida
# Revisa Invarianza en tiempo
# Lathi 1.11 p103
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
                'numpy']

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

t0 = 1.0 
# señales de entrada
f = sym.exp(-t)*sym.Heaviside(t)
w = f.subs(t,t-t0) # desplaza f

# sistema
y = sym.diff(x,t,evaluate=False)

# intervalo de t[a,b] para graficar
a = 0
b = 2*np.pi
muestras = 101

# PROCEDIMIENTO
# Sistema sobre señal de entrada
yf = y.subs(x,f).doit()
yw = y.subs(x,w).doit()
yf0 = yf.subs(t,t-t0).doit()

# Para gráfica
ti = np.linspace(a,b,muestras)
# señales de entrada
ft = sym.lambdify(t,f)
wt = sym.lambdify(t,w)

# señales de salida
yft = sym.lambdify(t,yf,modules=equivalentes)
ywt = sym.lambdify(t,yw,modules=equivalentes)
yf0t = sym.lambdify(t,yf0,modules=equivalentes)

# evalua entradas ti
fi = ft(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ywi = ywt(ti)
yfi0 = yf0t(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yw:')
sym.pprint(yw)
print('yf(t-t0):')
sym.pprint(yf0)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,wi,'--',color='green',
         label='w(t)=f(t-t0)')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('entradas')
plt.title('Sistemas Invariante: y='+str(y))
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--',label='yf=y[f(t)]')
plt.plot(ti,ywi,'--',color='green',
         label='yw=y[w(t)]')
plt.plot(ti,yfi0,'.',color='red', 
         label='yft0=yf[t-t0]')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

2.2 Sistemas Lineales y No Lineales con Sympy-Python

Referencia: Oppenheim 1.6.6 p53, Lathi 1.7-1 p97, Hsu 1.5.E p18

En un sistema lineal cumple con el principio de superposición que se compone de la propiedad de aditividad y de la escalabilidad.

cantante03

La superposición puede ser un resultado deseado en un sistema de audio que no añada «distorsiones» a lo que ingresa por un micrófono y se reproduce en los parlantes.

Un sistema lineal cumple la propiedad de aditividad, si la respuesta a una suma de señales en la entrada es igual a la suma de las salidas de las señales anteriores.

x_1(t) + x_2(t) \rightarrow y_1(t) + y_2(t)

La propiedad de escalabilidad u homogeneidad muestra una relación de «amplificación» o «atenuación» representada por una constante.
Para los ejemplos, las constantes a usar son α y β que podrían ser reales o complejas.

\alpha x_1(t) \rightarrow \alpha y_1(t)

La propiedad de escalabilidad implica que una amplificación o atenuación  puede ser aplicada antes o después del sistema, el resultado debería ser semejante.

La propiedad de superposición se plantea como una combinación de las propiedades anteriores:

en el tiempo contínuo:

\alpha x_1(t) + \beta x_2 (t) \rightarrow \alpha y_1(t) + \beta y_2(t)

en tiempo discreto:

\alpha x_1[n] + \beta x_2 [n] \rightarrow \alpha y_1[n] + \beta y_2[n]

Nota: De ser necesario, revisar los conceptos para Sympy en el curso de Métodos Numéricos: Fórmulas y funciones simbólicas con Python – Sympy


Ejemplo 1. Un micrófono inductivo, sistema que deriva x(t)

Referencia: Lathi 1.11 b p103.

Para el sistema dado, determine si cumple la propiedad de aditividad y escalabilidad para revisar si es un sistema lineal:

y(t) = \frac{\delta}{\delta t}x(t)

La salida del sistema es solo la derivada de la señal de entrada. Al sumar dos entradas diferentes antes del sistema, representada como w(t), se  produce el mismo resultado que la suma de las salidas del sistema para las señales de entrada individuales.

Suponiendo como entradas las señales f(t) = sin(t), graficada en azul, g(t) = cos(t) en color naranja, al aplicarse cada una al sistema, se obtienen las gráficas de salida usando los mismos colores para facilidad de comparación.

Para el análisis, se añade una entrada adicional w(t) = α f(t) + β g(t) que en la gráfica es de color verde para entrada y salida.
Se obtiene la expresión para el sistema α y[f(t)] + β y[g(t)]  (color rojo) y se observa si son iguales con y[w(t)], de ser iguales, el sistema es lineal.

El desarrollo analítico se encuentra en el libro guía en la referencia, por lo que se adjunta la parte algorítmica para la gráfica con Python, y se obtienen también las expresiones para los resultados correspondientes con Sympy:

yf = cos(t)
yg = -sin(t)
yw  = -3*sin(t) + 2*cos(t)
yfg = -3*sin(t) + 2*cos(t)

Un ejemplo de aplicación para un sistema que deriva una entrada es un microfono dinámico o de bobina, usado como preferencia por sus propiedades en locución de radio.

Referencia: Micrófonos dinámicos de bobina móvil: la guía detallada. Micrófono Rocks. https://microfono.rocks/microfonos-dinamicos-de-bobina-movil-la-guia-detallada/

Diferencias entre un Micrófono Dinámico y de Condensador – StudioMusic.cl


Ejemplo 2. Sistema con salida (x(t))2

Referencia: Oppenheim 1.18 p54

Para un sistema cuya entrada x(t) y salida y(t) se encuentra relacionada por:

y(t) = x^2(t)

Desarrolle las expresiones para determinar si el sistema es lineal, semejante al ejemplo del texto guía.

Se adjunta el resultado realizado con el algoritmo en Python, modificando las expresiones para y = x**2 mostrando que el sistema es NO lineal.

        2   
yf = sin (t)
        2   
yg = cos (t)
                          2
yw = (2*sin(t) + 3*cos(t)) 

           2           2   
yfg = 2*sin (t) + 3*cos (t)


Ejemplo 3. Sistema t(x(t))

Referencia: Oppenheim 1.17 p54

Considere un sistema cuya entrada x(t) y salida y(t) se encuentra relacionada por:

y(t) = t x(t)

Para determinar si S es o no lineal, se consideran dos entradas arbitrarias iguales a las del ejercicio anterior, haciendo w(t) = α f(t) y β g(t)

Desarrolle las expresiones para determinar si el sistema es lineal

Se adjunta el resultado realizado con el algoritmo en Python, modificando las expresiones para y = t*x mostrando que el sistema es lineal.

yf = t*sin(t)
yg = t*cos(t)
yw = 2*t*sin(t) + 3*t*cos(t)
yfg =2*t*sin(t) + 3*t*cos(t)


Instrucciones con Sympy-Python

Se usa Sympy para generar las expresiones de las señales de entrada al pasar por el sistema. De ser necesario, revisar los conceptos para Sympy en el curso de Métodos Numéricos: Fórmulas y funciones simbólicas con Python – Sympy

En Sympy se puede derivar una expresión usando sym.diff(). Sin embargo para un sistema que aplica derivadas, las expresiones de salida se generan sin aplicar la derivada pues primero se sustituye la variable x con la expresión de la entrada y luego se aplica sym.Derivative(x,t). Para que se ejecute la derivada se tiene la instrucción doit().

En caso que la señal de entrada sea una expresión mas compleja que la de los ejemplos, se recomienda usar la instrucción a la expresión .expand(). Expand() genera términos más simples de la expresión que facilitan la ejecución de Python.

# Sistema Lineal prueba
# Revisa propiedad de aditividad y escalabilidad
# Lathi ej1.11 p103
import numpy as np
import sympy as sym
import matplotlib.pyplot as plt

# INGRESO
t = sym.Symbol('t', real=True)
x = sym.Symbol('x', real=True)

# señales de entrada
f = sym.sin(t)
g = sym.cos(t)
alpha = 1
beta  = 1

# sistema, aplica a entrada
#   expresión sin evaluar
y = sym.diff(x,t, evaluate=False)

# intervalo de t[a,b] para graficar
a = 0
b = 2*np.pi
muestras = 41

# PROCEDIMIENTO
# señales suma de entradas
w = alpha*f + beta*g

# Sistema sobre señal de entrada
#  se evalua la expresión con doit()
yf = y.subs(x,f).doit()
yg = y.subs(x,g).doit()
yw = y.subs(x,w).doit()
yfg = alpha*yf+ beta*yg

# Para gráfica
ti = np.linspace(a,b,muestras)

# señales de entrada
ft = sym.lambdify(t,f)
gt = sym.lambdify(t,g)
wt = sym.lambdify(t,w)
# señales de salida
yft = sym.lambdify(t,yf)
ygt = sym.lambdify(t,yg)
ywt = sym.lambdify(t,yw)
yfgt = sym.lambdify(t,yfg)

# evalua entradas ti
fi = ft(ti)
gi = gt(ti)
wi = wt(ti)
# evalua salidas ti
yfi = yft(ti)
ygi = ygt(ti)
ywi = ywt(ti)
yfgi = yfgt(ti)

# SALIDA
print('yf:')
sym.pprint(yf)
print('yg:')
sym.pprint(yg)
print('yw:')
sym.pprint(yw)
print('yfg:')
sym.pprint(yfg)

# grafica
plt.subplot(211) # entradas
plt.plot(ti,fi,'--', label='f(t)')
plt.plot(ti,gi,'--', label='g(t)')
plt.plot(ti,wi, label='w(t)')
plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('entradas')
untitulo = 'Sistemas Linealidad ' + str(y)
plt.title(untitulo)
plt.legend()
plt.grid()

plt.subplot(212) # salidas
plt.plot(ti,yfi,'--', label='y(f(t))')
plt.plot(ti,ygi,'--', label='y(g(t))')
plt.plot(ti,ywi, label='y(w(t))')
etqLatex = r'$ \alpha y[f(t)]+\beta y[g(t)] $'
plt.plot(ti,yfgi,'.',
         label=etqLatex)

plt.axhline(0)
plt.xlabel('ti')
plt.ylabel('salidas')
plt.legend()
plt.grid()

plt.show()

Referencia: Derivadas con Sympy. Expresión sin evaluar y evaluación de expresión con Derivative. https://docs.sympy.org
Conceptos para Sympy en el curso de Métodos Numéricos: Fórmulas y funciones simbólicas con Python – Sympy

2.1 Sistemas

Referencia: Lathi 1.6 p95, Oppenheim 1.5 p38 pdf 69, Hsu 1.5 p16

Los sistemas se usan para procesar una señal con el objetivo de modificarla, por ejemplo sumar o restar informacion adicional.

fiec05058Sistema01


Ejemplo

un sistema amplificador de audio, tiene como señal de entrada el sonido captado por un micrófono y como salida el sonido amplificado en los parlantes.

cantante02Otro ejemplo de sistema se observa en los efectos que se aplican a una señal de audio de un piano, y por medio de un sistema se modifica la señal para que suene como guitarra.

Para otros ejemplos revisar videos sobre: wah pedals para efectos de guitarra, sintetizadores analógicos, etc.

Representación de sistemas

Un sistema para análisis y diseño es una representación de un proceso físico, que relaciona las señales de entrada x(t) y las señales de salida y(t) obtenidas como respuesta.

La representación puede ser de tipo matemática o en diagramas de bloques con flechas. El sentido de las flechas indican la entrada o salida.

y(t) = h(t) * x(t)
       h(t) = k
y(t) =  k x(t)

fiec05058Sistema01

Entradas y salidas de un sistema

Los sistemas pueden tener.

– Una entrada y una salida (SISO – Single Input, Single output)
– Varias entradas, varias salidas (MIMO – Multiple Input, Multiple output)

Durante el curso para simplificar el análisis, se usan las representaciones de una entrada y una salida (SISO), Ejemplo: audio monofónico o de un solo canal.

El bloque del sistemasistema por circuitos

Un sistema se puede realizar por:

– Componentes físicos (hardware: componentes electrónicos)

 

– Con su representación en diagrama de circuito:FIEC05058_RLC_solo

 

– Algoritmos (software: calculan la nueva señal a partir de la entrada)

arduinouno01arduinouno02

Un sistema puede estar compuesto de subsistemas interconectados, caracterizados por sus terminales de entrada y salida.

hometheater01

Dependiendo de las propiedades que tiene un sistema o las que se quieren utilizar, se realizan diferentes aplicaciones de los sistemas.