{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Análisis Temporal\n", "\n", "**¿Qué relación existe entre un sistema y su modelo?**" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "skip" } }, "source": [ "Para tener el notebook interactivo debemos \n", "\n", "1. Instalar el siguiente paquete \n", "```\n", "pip install ipywidgets\n", "```\n", "2. Activar la siguiente extension \n", "```\n", "jupyter nbextension enable --py widgetsnbextension\n", "```\n", " \n", "Para trabajar con la libreria de control debemos\n", "\n", "1. Instalar slycot \n", "```\n", "pip install slycot\n", "```\n", "2. Luego, instalar python-control \n", "```\n", "pip install control\n", "```" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "slideshow": { "slide_type": "skip" } }, "outputs": [], "source": [ "## Incluir libreria\n", "\n", "import ipywidgets as widgets\n", "import matplotlib.pyplot as plt\n", "import sympy as sp\n", "import numpy as np\n", "\n", "from control import *\n", "\n", "## Configuración \n", "\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Análisis Temporal \n", "\n", "Recordemos que el modelo representa el sistema, por lo que un análisis temporral del modelo, nos dará muchas ideas de cómo se comporta el sistema.\n", "\n", "Clásicamente la respuesta temporal se encontraba solucionando la ecuación diferencial, siguiendo estos pasos. \n", "\n", "1. Determinar la ecuación diferencial. \n", "2. Aplicar transformada de _Laplace_.\n", "3. Remplazar la entrada de la ecuación. \n", "4. Despejar la salida en función de la entrada. \n", "5. Descomponer en fracciones simples y aplicar la transformada inversa de Laplace. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Análisis Temporal\n", "\n", "Este análisis nos permite entender el comportamiento dinámico de los sistemas a traves de simulaciones de sus modelos matemáticos. Esto modelos idealmente deben ser representados como una función de transferencia. \n", "\n", "## Representación de los sistemas\n", "\n", "Los sistemas pueden ser representados de diferentes forma, dependiendo de la dimension donde se representen, en la siguiente tabla se presentan las represtaciones más comunes. \n", "\n", "|en el tiempo $(t)$|en el dominio de _Laplace_ $(s)$|\n", "|:----------------:|:------------------------------:|\n", "|ecuación diferencial | transformada de _Laplace_ |\n", "|respuesta en función del tiempo | función de transferencia |\n", "| | forma estándar |\n", "\n", "Para entender el funcionamiento de los parametros de los modelos estándar analicemos dos sistemas: \n", "\n", "| Orden | Sistema |\n", "|:-----:|:--------|\n", "|1 | Tanque con salida atmosferica |\n", "|2 | Masa-resorte-amortiguador con entrada en fuerza |" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Respuesta temporal de un tanque\n", "\n", "Empecemos analizando el tanque, el cual posee la siguiente ecuacion diferencial lineazada:\n", "\n", "$$A \\frac{dh(t)}{dt} = q(t) - \\frac{h(t)}{R}$$\n", "\n", "donde $A$ es el area del tanque y $R$ es la resistencia hidraúlica de la salida del tanque. A esta ecuación le aplicamos transformada de _Laplace_ y obtenemos:\n", "\n", "$$ As\\,H(s) = Q(s)-\\frac{H(s)}{R}$$\n", "\n", "De aquí podemos encontrar la función de transferencia del sistema:\n", "\n", "$$\\frac{H(s)}{Q(s)} = \\frac{R}{AR\\,s+1}$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Simulación de la función de transferencia\n", "\n", "Modifiquemos los valoes de $A$ y $R$ para comprender cuales son los efectos de cada parámetros en la respuesta temporal del tanque." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "scrolled": true, "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "20a517d169bf40039f960e8b57806535", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(VBox(children=(FloatSlider(value=1.0, description='A', max=10.0, min=0.1), FloatSlider(value=1.…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Parametros del modelo\n", "\n", "A = widgets.FloatSlider(value=1,min=0.1,max=10,step=0.1,description='A')\n", "R = widgets.FloatSlider(value=1,min=0.1,max=10,step=0.1,description='R')\n", "\n", "## Definicion de la simulacion\n", "\n", "def simulacion_tanque(A,R):\n", " tanque = tf([R],[R*A,1])\n", " tiempo, amplitud = step_response(tanque)\n", " plt.plot(tiempo,amplitud)\n", " plt.title('Simulación Tanque')\n", " plt.xlabel('tiempo (t)')\n", " plt.ylabel('amplitud')\n", "\n", "plot_tanque = widgets.interactive_output(simulacion_tanque,{'A':A,'R':R}) \n", "\n", "widgets.HBox([widgets.VBox([A, R]),plot_tanque])" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Análisis de la respuesta temporal del tanque\n", "\n", "**¿Qué podemos concluir de los dos parámetros usados en el modelo del tanque?**\n", "\n", "- ¿Cómo afecta el area del tanque $A$ a la amplitud de la respuesta, o al tiempo de respuesta?\n", "- ¿Cómo afecta la resistencia hidraúlica $R$ a la amplitud de la respuesta, o al tiempo de respuesta?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "La función de transferencia del tanque es : \n", "\n", "$$\\frac{H(s)}{Q(s)} = \\frac{R}{AR\\,s+1}$$\n", "\n", "La función de transferencia estándar para un sistema de primer orden es : \n", "\n", "$$\\frac{\\text{salida}}{\\text{entrada}} = \\frac{\\gamma}{\\tau\\,s+1}$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "De aquí tenemos que:\n", " \n", "$$\\gamma = R \\qquad\\text{y}\\qquad \\tau = AR$$\n", "\n", "Por lo que $R$ afecta tanto la amplitud de la respuesta, representada por la ganancia $\\gamma$, como tambien el tiempo de respuesta, representado por la constante de tiempo $\\tau$." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Respuesta temporal de un sistema masa-resorte-amortiguador\n", "\n", "Para este sistema tenemos la siguiente ecuación diferencial\n", "\n", "$$f(t) = m \\frac{d^2\\, x(t)}{dt^2} + c \\frac{d\\,x(t)}{dt} + k x(t)$$\n", "\n", "donde $m$ es la masa, $c$ es el coefficiente de amortiguamiento y $k$ es la constante de resorte. De aquí podemos igualmente construir la función de transferencia.\n", "\n", "$$\\frac{X(s)}{F(s)}=\\frac{1}{m\\,s^2+c\\,s+k}$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Simulación de la función de transferencia\n", "\n", "Modifiquemos los valores de $m$, $c$ y $k$ para comprender cuales son los efectos de cada parámetros en la respuesta temporal del tanque." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bf125e3d60a0463b8fab60bea4cdbfcb", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(VBox(children=(FloatSlider(value=1.0, description='m', max=10.0, min=0.1), FloatSlider(value=1.…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Parametros del modelo\n", "\n", "m = widgets.FloatSlider(value=1,min=0.1,max=10,step=0.1,description='m')\n", "c = widgets.FloatSlider(value=1,min=0.1,max=3,step=0.1,description='c')\n", "k = widgets.FloatSlider(value=1,min=0.1,max=10,step=0.1,description='k')\n", "\n", "## Definicion de la simulacion\n", "\n", "def simulacion(m,c,k):\n", " sistema = tf([1],[m,c,k])\n", " tiempo, amplitud = step_response(sistema)\n", " plt.plot(tiempo,amplitud)\n", " plt.title('Simulación masa-resorte-amortiguador')\n", " plt.xlabel('tiempo (t)')\n", " plt.ylabel('amplitud')\n", "\n", "plot_sistema = widgets.interactive_output(simulacion,{'m':m,'c':c,'k':k}) \n", "\n", "widgets.HBox([widgets.VBox([m,c,k]),plot_sistema])" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Análisis de la respuesta temporal del sistema masa-resorte-amortiguador\n", "\n", "**¿Qué podemos concluir de los tres parámetros usados en el modelo de la masa-resorte-amortiguador?**\n", "\n", "Respondamos a como afecta cada parámetro el desempeño de la respuesta temporal en diferentes aspectos:\n", "\n", "| | masa $m$ | amortiguamiento $c$ | resorte $k$ |\n", "|:---|:---:|:---:|:---:|\n", "|La amplitud de la respuesta temporal ||||\n", "|El número de oscilaciones visibles ||||\n", "|La frequencia de las oscilaciones ||||\n", "|El periodo de las oscilaciones ||||\n", "|La rapidez con que desaparecen las oscilaciones ||||" ] }, { "cell_type": "markdown", "metadata": {}, "source": [] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Conclusiones sobre los parámetros\n", "\n", "Recordemos las funciones de transferencia en su forma estándar:\n", "\n", "$$G_1(s) = \\frac{\\gamma}{\\tau\\,s+1} \\qquad\\text{y}\\qquad G_2(s) = \\frac{\\gamma}{1+\\frac{2\\xi}{\\omega_n}\\,s+\\frac{s^2}{\\omega_n^2}}$$\n", "\n", "- Para ambos sistemas $\\gamma$, la ganacia relaciona el valor final de la salida con el valor final de la entrada. \n", "- La constante de tiempo $\\tau$ explica cuan rápido reaciona un sistema ante un estimulo. \n", "- La frecuencia natural $\\omega_n$ denota la frecuencia a la cual un sistema oscilaría sin considerar perdidas de energía. \n", "- El coeficiente de amortiguamiento $\\xi$, reduce las oscilaciones del sistema. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Teorema del Valor Final \n", "\n", "La salida de un sistema se puede escribir como $y(t) = y_t(t)+y_ss$, donde:\n", "\n", "- $y_t(t)$ es la respuesta transitoria \n", "- $y_ss$ es la respuesta estacionaria\n", "\n", "La respuesta trasitoria se desvanecera transcurrido un tiempo luego: $\\lim_{t\\to\\infty} y_t(t) = 0$\n", "\n", "Para encontrar la respuesta estacionaria o **valor final** de un sistema podemos aplicar el siguiente teorema: \n", "\n", "$$y_{ss} = \\lim_{t\\to\\infty} y(t) = \\lim_{s\\to 0} s\\,Y(s)$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Ejercicio\n", "Dada la siguiente función de transferencia y señal de entrada encontrar el valor final:\n", "\n", "$$\\frac{F(s)}{X(s)}=\\frac{5}{s+3} \\qquad\\text{y}\\qquad X(s)=\\frac{3}{s}$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "**El valor final será**\n", "\n", "$$f(\\infty) = \\lim_{s\\to 0} s\\, F(s) = \\lim_{s\\to 0} s\\frac{5}{s+3}\\frac{3}{s}= 5$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Señales de Prueba \n", "\n", "Los sistemas responden a los estímulos de entrada, dichas señales pueden ser:\n", "\n", "- Escalón\n", "- Rampa\n", "- Pulso\n", "- Impulso\n", "\n", "existen otras como:\n", "\n", "- Parabolica\n", "- Sigmoidal" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Señal escalón " ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\begin{cases} A & \\text{for}\\: t \\geq 0 \\\\0 & \\text{otherwise} \\end{cases}$" ], "text/plain": [ "Piecewise((A, t >= 0), (0, True))" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = sp.Symbol('t')\n", "A = sp.Symbol('A')\n", "\n", "f = sp.Piecewise((A,t>=0),(0,True))\n", "f " ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "slideshow": { "slide_type": "skip" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "fb8b4d7ddfa342c0a2d0f42b841465dd", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatSlider(value=5.0, description='amplitud', max=10.0, min=0.1, orientation='vertical'), Outp…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Parametros del modelo\n", "\n", "param_A = widgets.FloatSlider(value=5,min=0.1,max=10,step=0.1,description='amplitud',orientation='vertical')\n", "\n", "## Definicion de la simulacion\n", "\n", "def simulacion_escalon(param_A):\n", " fs = lambda ts: f.subs(A,param_A).subs(t,ts)\n", " ts = np.arange(-5, 5, 0.1)\n", " plt.plot(ts,list(map(fs, ts)), 'b-')\n", " plt.ylim(0,11)\n", " plt.title('Señal Escalón')\n", " plt.xlabel('tiempo (t)')\n", " plt.ylabel('amplitud')\n", "\n", "plot_escalon = widgets.interactive_output(simulacion_escalon,{'param_A':param_A}) \n", "\n", "widgets.HBox([param_A,plot_escalon])" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "simulacion_escalon(5)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Señal Rampa" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\begin{cases} A t & \\text{for}\\: t \\geq 0 \\\\0 & \\text{otherwise} \\end{cases}$" ], "text/plain": [ "Piecewise((A*t, t >= 0), (0, True))" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = sp.Symbol('t')\n", "A = sp.Symbol('A')\n", "\n", "f = sp.Piecewise((A*t,t>=0),(0,True))\n", "f " ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "slideshow": { "slide_type": "skip" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ed7158a3fea643768afaf0724011ed78", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(FloatSlider(value=6.0, description='Pendiente', max=10.0, min=0.1, orientation='vertical'), Out…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Parametros del modelo\n", "\n", "param_A = widgets.FloatSlider(value=6,min=0.1,max=10,step=0.1,description='Pendiente',orientation='vertical')\n", "\n", "## Definicion de la simulacion\n", "\n", "def simulacion_rampa(param_A):\n", " fs = lambda ts: f.subs(A,param_A).subs(t,ts)\n", " ts = np.arange(-5, 5, 0.1)\n", " plt.plot(ts,list(map(fs, ts)), 'b-')\n", " plt.ylim(0, 30)\n", " plt.title('Señal Rampa')\n", " plt.xlabel('tiempo (t)')\n", " plt.ylabel('amplitud')\n", "\n", "plot_rampa = widgets.interactive_output(simulacion_rampa,{'param_A':param_A}) \n", "\n", "widgets.HBox([param_A,plot_rampa])" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "simulacion_rampa(6)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Señal Pulso" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\begin{cases} 0 & \\text{for}\\: t > t_{0} \\\\\\frac{A}{t_{0}} & \\text{for}\\: t \\geq 0 \\\\0 & \\text{otherwise} \\end{cases}$" ], "text/plain": [ "Piecewise((0, t > t0), (A/t0, t >= 0), (0, True))" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "t = sp.Symbol('t')\n", "t0= sp.Symbol('t0')\n", "A = sp.Symbol('A')\n", "\n", "f = sp.Piecewise((0,t>t0),(A/t0,t>=0),(0,t<0))\n", "f " ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "slideshow": { "slide_type": "skip" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "24d0a1deb3f3489584c9e7da1344dc74", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(Output(), FloatSlider(value=6.0, description='Area', max=10.0, min=0.1, orientation='vertical')…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Parametros del modelo\n", "\n", "param_A = widgets.FloatSlider(value=6,min=0.1,max=10,step=0.1,description='Area',orientation='vertical')\n", "param_t = widgets.FloatSlider(value=0.1,min=0.1,max=1,step=0.1,description='Tiempo',orientation='vertical')\n", "\n", "## Definicion de la simulacion\n", "\n", "def simulacion_pulso(param_A,param_t):\n", " fs = lambda ts: f.subs(A,param_A).subs(t0,param_t).subs(t,ts)\n", " ts = np.arange(-5, 5, 0.1)\n", " plt.plot(ts,list(map(fs, ts)), 'b-')\n", " plt.ylim(0, 30) \n", " plt.title('Señal Pulso')\n", " plt.xlabel('tiempo (t)')\n", " plt.ylabel('amplitud')\n", "\n", "plot_pulso = widgets.interactive_output(simulacion_pulso,{'param_A':param_A,'param_t':param_t}) \n", "\n", "widgets.HBox([plot_pulso,param_A,param_t])" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "simulacion_pulso(4,0.5)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Resumen de Señales de Entrada\n", "\n", "La siguiente tabla resume las transformadas de _Laplace_ de las señales de entrada. \n", "\n", "||Escalón|Rampa|Impulso|_ Señal Pulso _|\n", "|:---:|:-----:|:---:|:-----:|:---:|\n", "|$F(s)$|$\\frac{A}{s}$|$\\frac{A}{s^2}$|$A$|$\\frac{A}{st_0}\\left(1-e^{-s\\,t0}\\right)$|\n", "\n", "Para las señales unitaria se remplaza $A$ por uno $A=1$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Calculo Teórico de la Respuesta Temporal \n", "\n", "Para determinar la respuesta temporal, se siguen los pasos:\n", "\n", "1. Aplicar la entrada a la función de transferencia\n", " $$ Y(s) = G(s)\\cdot X(s)$$\n", "2. Simplificar si es posible\n", "3. Usar tablas de transformada inversa de _Laplace_ para convertir desde el dominio $s$ al dominio del tiempo." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Tiempos Característicos de la Respuesta a un Escalón \n", "\n", "|tiempo|$\\tau$|$3\\tau$|$5\\tau$|$10\\tau$|\n", "|:----:|:----:|:-----:|:-----:|:------:|\n", "|salida|$63,2\\%$|$95\\%$|$99\\%$|$99.9\\%$|" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "simulacion_tanque(1,1)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "- La constante de tiempo $\\tau$ define la velocidad de respuesta del sistema. Los sistemas rápidos tiene $\\tau$ pequeñas.\n", "- Cualquier sistema de primer orden alcanzará un $95\\%$ de su valor final a los $3\\tau$. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Efectos del amortiguamiento\n", "\n", "Dependiendo de coefficiente de amortiguamiento $\\xi$ tendremos 4 tipos de respuestas. \n", "\n", "|Respuesta|Oscilatorio|Sub Amortiguado|Amortiguado|Sobre Amortiguado|\n", "|:-------:|:---------:|:-------------:|:---------:|:---------------:|\n", "| $\\xi$ | $=0$ | $<1$ | $=1$ | $>1$ | \n", "\n", "cuando un sistema tiene un $\\xi=1$, se conoce también como críticamente amortiguado. " ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6270c2439339441e90e3c41661c7769c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(VBox(children=(FloatSlider(value=1.0, description='gamma', max=10.0, min=0.1), FloatSlider(valu…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "## Parametros del modelo\n", "\n", "gamma = widgets.FloatSlider(value=1,min=0.1,max=10,step=0.1,description='gamma')\n", "xi = widgets.FloatSlider(value=1,min=0,max=3,step=0.1,description='xi')\n", "omega = widgets.FloatSlider(value=1,min=0.1,max=10,step=0.1,description='omega')\n", "\n", "## Definicion de la simulacion\n", "\n", "def simulacion(gamma,xi,omega):\n", " sistema = tf([gamma],[1/(omega*omega),2*xi/omega,1])\n", " tiempo, amplitud = step_response(sistema)\n", " plt.plot(tiempo,amplitud)\n", " plt.title('Simulación Sistema de 2do Orden')\n", " plt.xlabel('tiempo (t)')\n", " plt.ylabel('amplitud')\n", "\n", "plot_sistema = widgets.interactive_output(simulacion,{'gamma':gamma,'xi':xi,'omega':omega}) \n", "\n", "widgets.HBox([widgets.VBox([gamma,xi,omega]),plot_sistema])" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Criterios de Desempeño\n", "\n", "|Nombre|Variable|Descripción|\n", "|:-----|:-------|:----------|\n", "|Tiempo de subida| $t_r$ | Para sistemas sub-amortiguados, es el tiempo en el que se alcanza por primera vez el valor estacionario. Para sistemas sobre-amortiguados, es el tiempo que tarda en ir de un $10\\%$ a un $90\\%$ del valor estacionario|\n", "|Tiempo de pico| $t_p$ | Tiempo que tarda en llegar al primer pico|\n", "|Valor Sobrepico|$y_{sp}$| Distancia entre el valor máximo de la respuesta y su valor estacionario|\n", "|Tiempo de establecimiento| $t_s$ | Tiempo que tarda la respuesta para llegar a un valor estacionario y donde la oscilaciones no supera el $\\pm5\\%$|\n", "|Número de oscilaciones| $n_s$ | Es el número de oscilaciones enteras que ocurren entre el inicio de la respuesta hasta el tiempo de establecimiento |" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Tiempo de Subida\n", "\n", "Si hacemos $y(t_r)=1$ para la respuesta, después de manipulaciones obtendremos:\n", "\n", "$$t_r = \\frac{1}{\\omega_d}\\left(\\pi-\\tan^{-1}\\left(\\frac{\\sqrt{1-\\xi^2}}{\\xi}\\right)\\right)$$\n", "\n", "- Bajos coeficientes de amortiguamiento producen respuestas rápidas, pero incrementan oscilaciones.\n", "- Un buen compromiso para comenzar es tener sistemas de amortiguamiento de $0.4<\\xi<0.8$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Tiempo de Pico\n", "\n", "Por inspección, para un sistema oscilatorio, este tiempo es medio periodo de la respuesta oscilatoria, es decir:\n", "\n", "$$t_p = \\frac{1}{2}\\,\\frac{2\\pi}{\\omega_d} = \\frac{\\pi}{\\omega_d}$$\n", "\n", "Esto puede ser confirmado encontrando el máximo de la respuesta $y(t)$. " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Valor Pico\n", "\n", "Se usa el tiempo de pico $t_p$ para evaluar la respuesta temporal:\n", "\n", "$$y_p= 1-e^{-\\xi\\omega_n\\,t_p}\\left(\\frac{\\xi\\omega_n}{\\omega_d}\\sin\\left(\\omega_gt_p\\right) + \\cos\\left(\\omega_gt_p\\right)\\right)$$\n", "\n", "El porcentaje de sobrepico, se calcula:\n", "\n", "$$\\frac{\\text{valor pico}-\\text{valor final}}{\\text{valor final}} = \\frac{y_p-y_{ss}}{y_{ss}} \\times 100\\%$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "## Tiempo de Establecimiento\n", "\n", "El termino de decaimiento exponencial descibribe la envolvente de la oscilación:\n", "\n", "$$e^{-\\xi\\omega_nt}$$\n", "\n", "si igualamos este termino con el $5\\%$, contraremos el tiempo de establecimiento para el $95\\%$\n", "\n", "$$-\\xi\\omega_nt_s = \\ln(0.05) = -3$$\n", "\n", "luego,\n", "\n", "$$t_s(5\\%) = \\frac{3}{\\xi\\omega_n}$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "## Número de Oscilaciones\n", "\n", "Este número antes del establecimiento se calcula\n", "\n", "$$n_s = \\frac{t_s}{\\tau_d}$$" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Etapas de Diseño de Controladores\n", "\n", "Las siguientes se sugieren como etapas para el diseño de un controlador:\n", "\n", "- Entender el sistema a controlar.\n", "- Modelizar el sistema.\n", "- Analizar el modelo.\n", "- Proponer un controlador.\n", "- Probar el controlador en el modelo.\n", "- Probar el controlador en el sistema físico/real." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Sistemas en la Universidad\n", "\n", "**Revisemos los modelos matemáticos de los sistemas encontrados**" ] } ], "metadata": { "celltoolbar": "Slideshow", "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.9" } }, "nbformat": 4, "nbformat_minor": 4 }