La respuesta de un sistema al impulso h(t), se obtiene al aplicar un impulso unitario δ(t) en la entrada x(t), semejante a un destello durante un tiempo muy pequeño.
El impulso es semejante a tomar una foto con flash en una habitación oscura, con todo tranquilo, sin movimientos. Luego del flash, a pesar que ya no exista más la luz, todos las personas o seres vivos reaccionan al destello de luz durante un tiempo y visualizaron el contenido de la habitación, ésta es la respuesta al impulso del sistema.
La respuesta del sistema se puede conformar como la suma de una señal contínua generada mediante una secuencia de impulsos cuando el tiempo entre impulsos tiende a cero (dt→0).
Un sistema de orden 2 se describe con la expresión de operadores D como:
Q(D)y(t) = P(D) x(t) (a_0 D^2+a_1 D + a_2)y(t)=(b_0 D^2 + b_1 D + b_2) x (t)
para disminuir la cantidad de variables se hace a0=1, al dividir la ecuación en ambos lados para a0. El resultado como aún tiene variables desconocidas, se mantiene la nomenclatura, que de forma simplificada se presenta como:
( D^2+a_1 D + a_2)y(t)=(b_0 D^2 + b_1 D + b_2) x (t)
La respuesta de un sistema al impulso unitario δ(t) aplicada en t=0, con todas las condiciones iniciales en cero en t=0-, se conoce como h(t).
(D^2+a_1 D + a_2)h(t)=(b_0 D^2 + b_1 D + b_2) \delta (t)
Para el análisis se consideran dos intervalos:
– Para t≥0+ donde x(t)=0, cuya respuesta es conocida como los términos de modos característicos o respuesta homogénea desarrollada en respuesta entrada cero ZIR
(D^2+a_1 D + a_2)h(t)=0, t \ge 0
h(t) = términos de modos característicos
– Para t=0 donde existe x(t)=δ(t), que suma a la respuesta anterior una constante A0 por un impulso.
h(t) = (términos de modos característicos) + A0 δ(t)
que al insertar esta ecuación en la expresión original tenemos:
(D^2+a_1 D + a_2)(A_0 \delta(t) + \text{terminos modos caracteristicos}) = =(b_0 D^2 + b_1 D + b_2) \delta (t)
que al multiplicar la parte de la izquierda, y comparando términos de ambos lados se determina que A0 = b0
Dado el caso que en la ecuacion, el orden de la derivadas de la derecha M es menor que el orden de derivadas de la izquierda N, (N>M), el término de segundo orden no se encuentra en P(D), entonces: b0=0
Un diferenciador D representa un sistema inestable, pues para una entrada acotada como el escalón μ(t) resulta en una salida no acotada como el impulso unitario δ(t). Un sistema con diferenciadores expuesto a ruido amplifica el ruido.
Para los diagramas de bloques y simuladores se prefiere usar integradores (1/D) ≈ (1/s).
Con el problema planteado, en ésta sección se cambia la expresión de la ecuación, ubicando el operador D de mayor grado a la izquierda:
Para XCOS, se añade un visor de señal de salida (Sinks/Scope) y un reloj de muestreo. Para y'(0)=5 siguiendo el diagrama se ubica y'(t)=dy/dt como la salida del primer integrador . El valor se cambia dando doble click al elemento marcado en rojo y escribiendo el valor de -5.
La gráfica se obtiene usando el osciloscopio (scope)
El tiempo de observación se establece con el valor de «Simulatión/Final Integration time» a 5 segundos.
De forma semejante se puede realizar el ejercicio en otros simuladores, como por ejemplo Simulink-Matlab.
3.2 Desarrollo como circuito en simulador
La simulación en forma de circuito usando las herramientas de Simulink/Matlab y SimPowerSystems, para cada componente (Elements) se crea con «Series RLC Branch».
Para extraer las lecturas de las señal se usa un medidor (Measurements) que se ubica en serie con los demás componentes y se visualiza con un osciloscopio (Simulink/Commonly Used Blocks/Scope).
Las conexiones son similares a las que se usarían en el laboratorio. Se puede observar que las respuestas serán las mismas.
Las condiciones iniciales se pueden establecer en los componentes que pueden tener un valor inicial como el capacitor en 5 voltios.
El signo de la corriente de salida ya está incluido en la inversión de polaridad respecto a la polaridad de la fuente.
2. Respuesta entrada cero – desarrollo numérico con Scipy-Python
Esta forma de describir el problema simplifica el desarrollo a partir de la descripción de la ecuación del sistema.
Scipy define un sistema LTI usando los coeficientes de la ecuación ordenados como la expresión P(D)/Q(D con la función Scipy.signal.lti().
Se describe una señal de entrada x(t), muestreada en un intervalo [a,b] junto a las condiciones iniciales en un vector [y'(0),y(0)].
El resultado será la simulación del paso de la señal x(t) por el sistema LTI, usando la función scipy.signal.lsim(), con lo que se obtiene la respuesta del sistema y(t) y los componentes yc=[yi(t),y0(t)], donde y0(t) representa la respuesta a entrada cero.
El algoritmo tiene el siguiente resultado:
Instrucciones en Python
# Sistema lineal usando scipy.signal# Q(D)y(t)=P(D)x(t)# ejemplo: (D^2+3D+2)y(t)=(D+0)x(t)import numpy as np
import scipy.signal as senal
import matplotlib.pyplot as plt
# INGRESO# tiempo [a,b] intervalo observación
a = 0 ; b = 5 # intervalo tiempo [a,b]
muestras = 41
# Señal de entrada x(t) = 0
x = lambda t: t*0
# Sistema LTI# coeficientes Q P de la ecuación diferencial
Q = [1., 3., 2.]
P = [1., 0.]
# condiciones iniciales [y'(0),y(0)]
cond_inicio = [-5,0]
# PROCEDIMIENTO# intervalo observado
ti = np.linspace(a, b, muestras)
xi = x(ti)
sistema = senal.lti(P,Q)
# respuesta entrada cero
[t_y, yi, yc] = senal.lsim(sistema, xi, ti, cond_inicio)
# respuesta a impulso
[t_h, hi] = sistema.impulse(T = ti)
# SALIDA - GRAFICA
plt.subplot(211)
plt.suptitle('Respuesta a Entrada cero')
plt.plot(ti, xi, color='blue', label='x(t)')
#plt.plot(t_h, hi, color='red', label='h(t)')
plt.legend()
plt.grid()
plt.subplot(212)
# plt.plot(t_y, yi, color='magenta', label='y(t)')# plt.plot(t_y, yc[:,0], 'g-.', label='y(t)')
plt.plot(t_y, yc[:,1], color='orange', label='y0(t)')
plt.xlabel('t')
plt.legend()
plt.grid()
plt.show()
3. Respuesta entrada cero – desarrollo numérico con Runge-Kutta de Métodos numéricos en Python
Se reordena el sistema de ecuaciones para plantear una solución con el algoritmo Runge-Kutta de 2do orden para ecuaciones diferenciales con segundas derivadas
Se ubica el término de mayor grado a la izquierda de la ecuación:
D^2 y(t) = - 3Dy(t) - 2y(t)
sutituyendo las expresiones de las derivadas como las funciones f(x) por z y g(x) por z’:
Dy = y’ = z = f(x)
D2y = y" = z’= -3z – 2y = g(x)
Los valores iniciales de t0=0, y0=0, z0=-5 se usan en el algoritmo.
En este caso también se requiere conocer un intervalo de tiempo a observar [0,tn=5] y definir el tamaño de paso o resolución del resultado h=dt=0.1
El algoritmo permite obtener la gráfica y la tabla de datos.
Instrucciones en Python
# Respuesta a entrada cero# solucion para (D^2+ D + 1)y = 0import numpy as np
import matplotlib.pyplot as plt
defrungekutta2_fg(f,g,x0,y0,z0,h,muestras):
tamano = muestras + 1
estimado = np.zeros(shape=(tamano,3),dtype=float)
# incluye el punto [x0,y0]
estimado[0] = [x0,y0,z0]
xi = x0
yi = y0
zi = z0
for i inrange(1,tamano,1):
K1y = h * f(xi,yi,zi)
K1z = h * g(xi,yi,zi)
K2y = h * f(xi+h, yi + K1y, zi + K1z)
K2z = h * g(xi+h, yi + K1y, zi + K1z)
yi = yi + (K1y+K2y)/2
zi = zi + (K1z+K2z)/2
xi = xi + h
estimado[i] = [xi,yi,zi]
return(estimado)
# PROGRAMA
f = lambda t,y,z: z
g = lambda t,y,z: -3*z -2*y
t0 = 0
y0 = 0
z0 = -5
h = 0.1
tn = 5
muestras = int((tn-t0)/h)
tabla = rungekutta2_fg(f,g,t0,y0,z0,h,muestras)
ti = tabla[:,0]
yi = tabla[:,1]
zi = tabla[:,2]
# SALIDA
np.set_printoptions(precision=6)
print('ti, yi, zi')
print(tabla)
# GRAFICA
plt.plot(ti,yi, color = 'orange', label='y0(t)')
plt.ylabel('y(t)')
plt.xlabel('t')
plt.title('Entrada cero con Runge-Kutta 2do Orden d2y/dx2 ')
plt.legend()
plt.grid()
plt.show()
Más detalles del algoritmo de Runge-Kutta para segunda derivada en :
Para encontrar la Respuesta a entrada cero del sistema lineal del Modelo entrada-salida, representado por un circuito, se plantea la ecuación diferencial lineal escrita desde el termino de mayor orden. Por ejemplo:
El circuito que representa la respuesta a entrada cero tiene x(t)=0 como se muestra en la figura.
La ecuación diferencial con operadores D es:
(D^2 + 3D +2)y(t) = 0
Adicionalmente, para el desarrollo se indican las condiciones iniciales y'(0)=-5, y(0)=0.
La librería Sympy-Python permite usar expresiones de derivadas en forma simbólica y resolverlas siguiendo los pasos seguidos en la solución analítica.
Para iniciar el algoritmo, se define la variable independiente t como un símbolo y las función matemática y(t) para la salida y x(t) para la entrada.
La ecuación diferencial se escribe siguiendo el orden de los lados de expresión denominados para la parte izquierda, LHS, y la parte derecha, RHS.
import sympy as sym
# INGRESO
t = sym.Symbol('t', real=True)
y = sym.Function('y')
x = sym.Function('x')
# ecuacion EDO: lado izquierdo = lado derecho# Left Hand Side = Right Hand Side
LHS = sym.diff(y(t),t,2) + 3*sym.diff(y(t),t,1) + 2*y(t)
RHS = sym.diff(x(t),t,evaluate=False)
ecuacion_edo = sym.Eq(LHS,RHS)
# condiciones iniciales [y'(t0),y(t0)]
t0 = 0
cond_inicio = [-5,0]
Las condiciones iniciales y’(0)=-5, y(0)=0 , se agrupan en una lista cond_inicio=[y'(t0),y(t0)] siguiendo el orden descendente de derivada, semejante al orden seguido al escribir la ecuación diferencial. El orden usado facilita la compatibilidad con las soluciones numéricas a realizar con Scipy-Python.
Solución general de la ecuación diferencial lineal homogénea
Se obtiene la ecuación homogénea aplicando x(t)=0 al lado derecho de la ecuación diferencial (RHS).
La solución general de la EDO se obtiene mediante la instrucción sym.dsolve() aplicada a la ecuación, indicando que se busca resolver para y(t). Para facilitar el procesamiento con Sympy, las ecuaciones se expresan con términos mas simples de sumas, aplicando la instrucción sym.expand().
# ecuacion homogenea x(t)=0, entrada cero
RHSx0 = ecuacion.rhs.subs(x(t),0).doit()
LHSx0 = ecuacion.lhs.subs(x(t),0).doit()
homogenea = LHSx0 - RHSx0
# solucion general entrada cero
general = sym.dsolve(homogenea, y(t))
general = general.expand()
Con lo que se obtiene la solución general mostrada con sym.pprint():
-t -2*t
y(t) = C1*e + C2*e
Las condiciones iniciales se aplican a la solución general para encontrar la solución homogenea o ZIR. Para aplicar cada condición inicial se usa el lado derecho (.rhs )de la ecuación general, por ejemplo:
Cada condición inicial genera una ecuación que se agrupa en un sistema de ecuaciones, eq_condicion=[]. El sistema de ecuaciones se resuelve con la instrucción sym.solve(), que entrega las constantes para las incógnitas C1 y C2 en un diccionario.
# aplica condiciones iniciales
N = sym.ode_order(LHS,y) # orden Q(D)
eq_condicion = []
for k inrange(0,N,1):
ck = cond_inicio[(N-1)-k]
dyk = general.rhs.diff(t,k)
dyk = dyk.subs(t,t0)
eq_k = sym.Eq(ck,dyk)
eq_condicion.append(eq_k)
constante = sym.solve(eq_condicion)
El resultado de eq_condicion y las constantes obtenidas se muestra a continuación
0 = C1 + C2
-5 = -C1 - 2*C2
{C1: -5, C2: 5}
La solución homogénea o ZIR de la ecuación diferencial se obtiene al sustituir las constantes encontradas en la ecuación general.
# reemplaza las constantes en general
y_c = general
for Ci in constante:
y_c = y_c.subs(Ci, constante[Ci])
# ecuacion complementaria o respuesta a entrada cero ZIR
ZIR = y_c.rhs
obteniendo solución a la ecuación homogena ‘y‘, o respuesta a entrada cero ZIR, mostrada con sym.pprint(y_homogenea). Para ZIR se toma el dado derecho de y_homogenea.
-t -2*t
y(t) = - 5*e + 5*e
y(t) = -5 e^{-t} + 5 e^{-2t}
resultado del algoritmo:
ecuación diferencial a resolver:
2
d d d
2*y(t) + 3*--(y(t)) + ---(y(t)) = --(x(t))
dt 2 dt
dt
clasifica EDO:
factorable
nth_linear_constant_coeff_variation_of_parameters
nth_linear_constant_coeff_variation_of_parameters_Integral
ecuación diferencial homogenea:
2
d d
2*y(t) + 3*--(y(t)) + ---(y(t)) = 0
dt 2
dt
Solución general:
-t -2*t
y(t) = C1*e + C2*e
Ecuaciones de condiciones iniciales:
0 = C1 + C2
-5 = -C1 - 2*C2
constantes en solucion general: {C1: -5, C2: 5}
ZIR(t):
-t -2*t
- 5*e + 5*e
>>>
Instrucciones en Python
# Respuesta a entrada cero ZIR con Sympy# Lathi 2.1.a pdf 155, (D^2+ 3D + 2)y = Dximport sympy as sym
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
{'Heaviside': lambda x,y: np.heaviside(x, 1)},
'numpy',]
# INGRESO
t = sym.Symbol('t', real=True)
y = sym.Function('y')
x = sym.Function('x')
# ecuacion: lado izquierdo = lado derecho# Left Hand Side = Right Hand Side
LHS = sym.diff(y(t),t,2) + 3*sym.diff(y(t),t,1) + 2*y(t)
RHS = sym.diff(x(t),t,1,evaluate=False)
ecuacion = sym.Eq(LHS,RHS)
# condiciones iniciales [y'(t0),y(t0)]
t0 = 0
cond_inicio = [-5,0]
# PROCEDIMIENTO
edo_tipo = sym.classify_ode(ecuacion, y(t))
# ecuación homogénea x(t)=0, entrada cero
RHSx0 = ecuacion.rhs.subs(x(t),0).doit()
LHSx0 = ecuacion.lhs.subs(x(t),0).doit()
homogenea = LHSx0 - RHSx0
# solucion general de ecuación homogénea
general = sym.dsolve(homogenea, y(t))
general = general.expand()
# aplica condiciones iniciales
N = sym.ode_order(ecuacion,y(t)) # orden Q(D)
eq_condicion = []
for k inrange(0,N,1):
ck = cond_inicio[(N-1)-k]
dyk = general.rhs.diff(t,k)
dyk = dyk.subs(t,t0)
eq_k = sym.Eq(ck,dyk)
eq_condicion.append(eq_k)
constante = sym.solve(eq_condicion)
# reemplaza las constantes en general
y_c = general
for Ci in constante:
y_c = y_c.subs(Ci, constante[Ci])
# respuesta a entrada cero ZIR
ZIR = y_c.rhs
# SALIDAprint('ecuación diferencial a resolver: ')
sym.pprint(ecuacion)
print('clasifica EDO:')
for elemento in edo_tipo:
print(' ',elemento)
print('ecuación diferencial homogenea: ')
sym.pprint(homogenea)
print('\nSolución general: ')
sym.pprint(general)
print('\nEcuaciones de condiciones iniciales:')
for eq_k in eq_condicion:
sym.pprint(eq_k)
print('constantes en solucion general: ', constante)
print('\nZIR(t):')
sym.pprint(ZIR)
Gráfica de respuesta a entrada cero ZIR
Adicionalmente se realiza la gráfica, convirtiendo la ecuación de forma simbólica a forma numérica numpy con sym.lambdify(t,ZIR,'numpy').
Se establece el intervalo de observación entre t_a=0 y t_b=5 para evaluar la función y se envía a la gráfica, con el suficiente número de muestras para que la gráfica se muestre suave.
Se añaden las siguientes instrucciones al algoritmo anterior:
Se reordena el algoritmo del ejercicio anterior para disponer de funciones que simplifiquen las instrucciones principales para obtener las respuestas de los ejercicios. Se crean las funciones respuesta_ZIR() y graficar_ft() que luego pasarán a ser parte de los algoritmos del curso en telg1001.py.
Para las definiciones de RHS y LHS dentro de la función se usa ecuación.rhs y ecuacion.lhs.
En el diccionario solución, se incorpora la respuesta en la entrada 'ZIR'.
# Respuesta a entrada cero ZIR con Sympy-Python# https://blog.espol.edu.ec/telg1001/lti-ct-respuesta-entrada-cero-con-sympy-python/# Lathi 2.1.b pdf 155, (D^2+ 6D + 9)y = (3D+5)ximport numpy as np
import matplotlib.pyplot as plt
import sympy as sym
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
{'Heaviside': lambda x,y: np.heaviside(x, 1)},
'numpy',]
import telg1001 as fcnm
# INGRESO
t = sym.Symbol('t', real=True)
y = sym.Function('y')
x = sym.Function('x')
# ecuacion: lado izquierdo = lado derecho# Left Hand Side = Right Hand Side
LHS = sym.diff(y(t),t,2) + 6*sym.diff(y(t),t,1) + 9*y(t)
RHS = 3*sym.diff(x(t),t,1,evaluate=False)+5*x(t)
ecuacion = sym.Eq(LHS,RHS)
# condiciones iniciales [y'(t0),y(t0)]
t0 = 0
cond_inicio = [-7,3]
# Grafica: intervalo tiempo [t_a,t_b]
t_a = 0 ; t_b = 5
muestras = 51
# PROCEDIMIENTOdefrespuesta_ZIR(ecuacion,cond_inicio=[],t0,
y = sym.Function('y'),x = sym.Function('x')):
''' Sympy: ecuacion: diferencial en forma(LHS,RHS),
condiciones de inicio t0 y [y'(t0),y(t0)]
cond_inicio en orden descendente derivada
'''# ecuacion homogenea x(t)=0, entrada cero
RHSx0 = ecuacion.rhs.subs(x(t),0).doit()
LHSx0 = ecuacion.lhs.subs(x(t),0).doit()
homogenea = LHSx0 - RHSx0
# solucion general entrada cero
general = sym.dsolve(homogenea,y(t))
general = general.expand()
# aplica condiciones iniciales
N = sym.ode_order(ecuacion,y(t)) # orden Q(D)
eq_condicion = []
for k inrange(0,N,1):
ck = cond_inicio[(N-1)-k]
dyk = general.rhs.diff(t,k)
dyk = dyk.subs(t,t0)
eq_k = sym.Eq(ck,dyk)
eq_condicion.append(eq_k)
constante = sym.solve(eq_condicion)
# reemplaza las constantes en general
y_c = general
for Ci in constante:
y_c = y_c.subs(Ci, constante[Ci])
# respuesta a entrada cero ZIR
ZIR = y_c.rhs
sol_ZIR = {'homogenea' : sym.Eq(homogenea,0),
'general' : general,
'eq_condicion': eq_condicion,
'constante' : constante,
'ZIR' : ZIR,}
return(sol_ZIR)
edo_tipo = sym.classify_ode(ecuacion, y(t))
# Respuesta entrada cero ZIR
sol_ZIR = respuesta_ZIR(ecuacion,cond_inicio,t0)
ZIR = sol_ZIR['ZIR']
# SALIDAprint('clasifica EDO:')
for elemento in edo_tipo:
print(' ',elemento)
fcnm.print_resultado_dict(sol_ZIR)
# GRAFICA ------------------
figura_ZIR = fcnm.graficar_ft(ZIR,t_a,t_b,muestras,'ZIR')
plt.show()
Ejemplo 3. EDO y respuesta a entrada cero ZIR con raíces complejas
Referencia: Lathi Ejemplo 2.1.c p155
Encontrar y0(t), la respuesta a entrada cero para un sistema LTI CT descrito por la ecuación diferencial ordinaria de orden 2:
(D^2 + 4D +40)y(t) = (D+2)x(t)
con condiciones iniciales y(0) = 2, y'(0)=16.78
Tarea: Use el algoritmo del ejercicio anterior y modifique lo necesario para realizar el ejercicio. Realice el desarrollo analítico en papel y lápiz y compare. En caso de ser necesario, proponga mejoras al algoritmo presentado.
Los resultados con el algoritmo son:
ecuación diferencial a resolver:
2
d d d
40*y(t) + 4*--(y(t)) + ---(y(t)) = 2*x(t) + --(x(t))
dt 2 dt
dt
ecuación diferencial homogenea:
2
d d
40*y(t) + 4*--(y(t)) + ---(y(t)) = 0
dt 2
dt
Solución general:
-2*t -2*t
y(t) = C1*e *sin(6*t) + C2*e *cos(6*t)
Ecuaciones de condiciones iniciales:
2 = C2
16.78 = 6*C1 - 2*C2
constantes en solución general: {C1: 3.46333333333333, C2: 2.00000000000000}
Solución ZIR:
-2*t -2*t
3.46333333333333*e *sin(6*t) + 2.0*e *cos(6*t)
>>>
Instrucciones con Python
# Respuesta a entrada cero ZIR con Sympy-Python# https://blog.espol.edu.ec/telg1001/lti-ct-respuesta-entrada-cero-con-sympy-python/# Lathi 2.1.c pdf 155, (D^2+ 4D + 40)y = (D+2)ximport numpy as np
import matplotlib.pyplot as plt
import sympy as sym
equivalentes = [{'DiracDelta': lambda x: 1*(x==0)},
{'Heaviside': lambda x,y: np.heaviside(x, 1)},
'numpy',]
import telg1001 as fcnm
# INGRESO
t = sym.Symbol('t', real=True)
y = sym.Function('y')
x = sym.Function('x')
# ecuacion: lado izquierdo = lado derecho# Left Hand Side = Right Hand Side
LHS = sym.diff(y(t),t,2) + 4*sym.diff(y(t),t,1) + 40*y(t)
RHS = sym.diff(x(t),t,1,evaluate=False)+2*x(t)
ecuacion = sym.Eq(LHS,RHS)
# condiciones iniciales [y'(t0),y(t0)]
t0 = 0
cond_inicio = [16.78,2]
# Grafica: intervalo tiempo [t_a,t_b]
t_a = 0 ; t_b = 5
muestras = 51
# PROCEDIMIENTO
edo_tipo = sym.classify_ode(ecuacion, y(t))
# Respuesta entrada cero ZIR
sol_ZIR = fcnm.respuesta_ZIR(ecuacion,cond_inicio,t0)
ZIR = sol_ZIR['ZIR']
# SALIDAprint('clasifica EDO:')
for elemento in edo_tipo:
print(' ',elemento)
fcnm.print_resultado_dict(sol_ZIR)
# GRAFICA ------------------
figura_ZIR = fcnm.graficar_ft(ZIR,t_a,t_b,muestras,'ZIR')
plt.show()
Resumen de funciones de Señales y Sistemas telg1001.py
Las funciones desarrolladas para uso posterior se agrupan en un archivo resumen telg1001.py.
Use una copia del archivo como telg1001.py en el directorio de trabajo, e incorpore las funciones con import y use en el algoritmo llamando a la funcion con fcnm.funcion().
iimport telg1001 as fcnm
respuesta = fcnm.funcion(parametros)
Al desarrollar más funciones en cada unidad, se incorporan al archivo del curso de Señales y Sistemas.
Mostrar el resultado del diccionario según el tipo de entrada
Para mostrar los resultados de una forma más fácil de leer, se usará sym.pprint() para las ecuaciones, y print() para los demás elementos del resultado
def print_resultado_dict(resultado):
''' print de diccionario resultado
formato de pantalla
'''
eq_sistema = ['ZIR','h','ZSR','xh']
for entrada in resultado:
tipo = type(resultado[entrada])
cond = (tipo == sym.core.relational.Equality)
cond = cond or (entrada in eq_sistema)
if cond:
print(entrada,':')
sym.pprint(resultado[entrada])
elif tipo==listor tipo==tuple:
tipoelem = type(resultado[entrada][0])
if tipoelem==sym.core.relational.Equality:
print(entrada,':')
for fila in resultado[entrada]:
sym.pprint(fila)
else:
print(entrada,':')
for fila in resultado[entrada]:
print(' ',fila)
else:
print(entrada,':',resultado[entrada])
return()
La respuesta a entrada cero de un sistema se obtiene aplicando x(t)=0 en la ecuación diferencial lineal, es decir no se le aplica una señal de entrada. La respuesta a entrada cero, Zero Input Response (ZIR), también es conocida como la solución a la ecuación diferencial homogénea, en la que x(t)=0.
Respuesta total
=
respuesta a entrada cero ZIR
+
respuesta a estado cero ZSR
La respuesta a entrada cero permite observar las condiciones internas del sistema, cargas en capacitores o corrientes en inductores como energía residual de los estados anteriores al de observación.
La ecuación diferencial lineal homogénea se obtiene también hacer x(t)=0, de una forma:
con las condiciones o valores iniciales descritos por:
y0(t) =0
y’0(t) =-5
La entrada cero del circuito, x(t)=0 convierte la ecuación lineal en homogénea. Para entrada cero se usa x(t)=0, se quita la fuente y se cierra el circuito para observar lo que hace el sistema sin señal de entrada.
Siendo el sistema LTI descrito por los polinomios de operadores D descritos como Q(D) y P(D), la ecuación se simplifica al eliminar P(D):
Q(D) y(t) = P(D) x(t) (D^2 + 3D +2)y(t) = 0
Q(D) es la ecuación característica o auxiliar del sistema:
\lambda ^2 + 3\lambda +2 = 0
Al buscar las raíces de λ, se escribe la ecuación en sus factores y se puede buscar los modos característicos,
(\lambda +1)(\lambda + 2) = 0
Raíces características
Modos característicos
λ1 = -1
e-t
λ2 = -2
e-2t
Con los modos característicos se plantea la solución general y0(t) como la suma de los modos característicos con coeficientes aún por determinar.
y_0 (t) = c_1 e^{-t} + c_2 e^{-2t}
Para determinar los valores de las constantes c1 y c2 se aplican las condiciones iniciales para t0=0. Del enunciado del ejercicio se tiene que No hay señal en la salida al tiempo cero y(0)=0, además que la variación es negativa y'(0)=-5:
Las restricciones indicadas también son conocidas como condiciones auxiliares, solo cuando estas condiciones son dadas para t=0 se denominan condiciones iniciales o valores iniciales (Lathi p161).
se resuelve obteniendo: c1 = -5 ; c2 = 5,
que al sustituir en la ecuación anterior, se encuentra la respuesta a entrada cero ZIR:
y_0(t) = -5e^{-t} +5e^{-2t}
La gráfica muestra el sentido de la corriente, usando la carga residual del capacitor dentro del circuito, a pesar de no tener señal de entrada a partir del tiempo 0 hasta 5:
Cálculos numéricos con Python
Para determinar los valores de las constantes, se puede usar algunas instrucciones sencillas con Numpy. Para las raíces del polinomio se usan solo los coeficientes de operadores D, ordenados de grado mayor a menor.
D^2 + 3D +2 = 0
import numpy as np
>>> np.roots([1,3,2])
array([-2., -1.])
Para los coeficientes se plantean las ecuaciones de la forma matricial Ax=B:
La descripción de un sistema en términos de las mediciones en los extremos se denomina Modelo de entrada-salida.
Una forma es describir la relación entre salida/entrada se expresa usando operadores de diferenciación D:
\frac{y(t)}{x(t)} = \frac{P(D)}{Q(D)}
La respuesta de un sistema lineal puede también ser expresada como la suma de dos componentes: respuesta a entrada cero ZIR y respuesta a estado cero ZSR.
Respuesta total
=
respuesta a entrada cero
+
respuesta a estado cero
Para el caso de un circuito eléctrico RLC, el modelo inicia con la descripción de la ecuación diferencial lineal que relaciona el voltaje x(t) de entrada y la corriente de salida y(t).
…
Ejemplo 1. Corriente en circuito RLC y Ecuaciones Diferenciales Lineales de 2do orden
Al multiplicar ambos lados por el operador D se convierte nuevamente en una expresión sin denominadores D, semejante a la expresión que usa solo diferenciales.
\Big( D^2 + 3D + 2 \Big) y(t) = D x(t)
Recuerde: la expresión con operadores D, NO ES una ecuación algebraica, pues la expresión de operadores D aplican solo a y(t).
En adelante, para el sistema o circuito descrito por ecuaciones diferenciales se usa el operador D=\frac{d}{dt}, por ejemplo:
Ejercicio 2. Voltaje de un Circuito RC como una Ecuación Diferencial Lineal de 1er Orden
Referencia: Lathi Ejemplo 1.17 p113.
Usando la notación del operador D, encuentre la relación de salida/entrada para el circuito RC. Para ésto defina i(t) como la corriente del circuito y como y(t) el voltaje del capacitor.
La corriente del lazo i(t) del circuito:
R i(t) +\frac{1}{C} \int_{-\infty}^{t} i(\tau) \delta \tau = x(t)
cambiando al operador D
R i(t) +\frac{1}{C} \frac{1}{D} i(t) = x(t) R D i(t) +\frac{1}{C} i(t) = D x(t) \Big(R D +\frac{1}{C}\Big) i(t) = D x(t)
Conociendo que la corriente i(t) en el capacitor depende de la variación de voltaje y(t) y la capacitancia C
i(t) = C \frac{\delta}{\delta t} y(t) = CD y(t)
se sustituye i(t) en la ecuación,
(R D +\frac{1}{C}) CD y(t) = D x(t)
simplificando un operador D
(R D +\frac{1}{C}) C y(t) = x(t) (RC D + 1 ) y(t) = x(t)
Para mostrar la relación de salida/entrada se reordena la expresión:
\frac{y(t)}{x(t)} = \frac{1}{RC D +1} \frac{y(t)}{x(t)} = \frac{\frac{1}{RC}}{D +\frac{1}{RC}}
Los sistemas pueden crearse a partir de subsistemas más sencillos. La interconexión 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
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
El diagrama de bloques muestra que la señal de entrada se aplica de forma simultánea 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)
Interconexión con retroalimentación
Los sistemas retroalimentados permiten «regular» la salida «observando» una parte de la misma
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)
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.
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]
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 p79, 1.3-2 p78
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.
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.
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 xhace un segundo atrás (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.»
«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?
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.
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.
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)
