4/4/2019 Python: Simulación de un motor de corriente directa

(https://elrobotista.com/)

Inicio (https://elrobotista.com/) Blog (https://elrobotista.com/blog/)

Nosotros (https://elrobotista.com/about/)

PROGRAMACIÓN
(HTTPS://ELROBOTISTA.COM/CATEGORY/PROGRAMACION/)

Simulación de Sistemas Dinámicos

POSTED APRIL 6, 2017 (HTTPS://ELROBOTISTA.COM/SIMULACIONES-NUMERICAS/) ELROBOTISTA
(HTTPS://ELROBOTISTA.COM/AUTHOR/ELROBOTISTA/)

En la entrada anterior, les platiqué cómo se modela un motor (https://elrobotista.com/modelado/)

de corriente directa. En esta entrada les mostraré como se puede realizar una simulación utilizando
herramientas de código abierto; en este caso: el lenguaje de programación Python. Pero antes, un
poco de teoría.

Integrales y derivadas numéricas

Si recuerdan sus clases de cálculo, seguramente recordaran que la integral es el “área bajo la
curva” y la derivada: “la recta tangente a la curva” que los profesores repiten hasta casi hacernos
vomitar. Pero, ¿cuál es el significado en la realidad, o la aplicación práctica de una integral o una
derivada? En este caso, les presento una: resolver ecuaciones diferenciales de forma numérica.
Esto no es importante solo por el hecho de que sea tedioso o aburrido resolver ecuaciones
diferenciales de forma analítica y a mano como en sus exámenes de cálculo. Verán, la mayoría de
las ecuaciones diferenciales que representan fenómenos físicos son demasiado complejas para
resolver de forma analítica, y en muchos otros casos las soluciones ni siquiera existen. Entonces,
podemos recurrir a las computadoras para resolver las ecuaciones diferenciales y poder estudiar la
respuesta de los modelos bajo diferentes condiciones.

Podrían pensar que, si de por si ya es complicado resolver una integral o derivada en lápiz y papel,
ha de ser aún más difícil resolverlas con una computadora. Están equivocados. Déjenme aburrirlos
con un poco de teoría. Será breve. Lo prometo.

https://elrobotista.com/simulaciones-numericas/ 1/9
4/4/2019 Python: Simulación de un motor de corriente directa

Es posible aproximar una integral de la siguiente forma:

∫ ∑ f(k)Δx
b b
f (x)dx ≈ (https://elrobotista.com/)
a k= a

ILnaicsio
um(hatttposr:i/
a/ceolrnovbeortgisetaa.claom
in/ culoagn(dhottlpism
te) gral B ://Δ ro→
elx boti0s,tap.c
eorome/sbtolongo/)nos interesa mucho ahorita:
Nosotros (https://elrobotis ta.com/ab out/)
nos interesa la sumatoria. Entonces, vemo s que podemos aproximar una integral con una
sumatoria, siempre y cuando Δ sea lo suficientemente pequeño.De manera similar, podemos
aproximar la derivada

Δf(x) d f (x )
≈ ,
Δx dx

si Δx es suficientemente pequeño. Entonces todo esto comienza a tomar sentido. Las integrales se
vuelven sumas, mientras que las derivadas se vuelven restas. !Esto sí es sencillo! Veamos cómo
podemos usar estas aproximaciones para simular el motor de la entrada anterior:

Ω(s) K
= ,
Vin (s) τs + 1

donde K es la ganancia de DC del sistema y τ es la constante de tiempo. Demos un paso atrás y

transformaremos este modelo de una función de transferencia a una ecuación diferencial de
primer orden:

dω
τ + ω = Kvin ,
dt

donde ω es la velocidad del motor y vin es el voltaje de entrada. El objetivo es encontrar la

evolución de ω en el tiempo. Cambiemos la derivada por la aproximación que definimos
anteriormente:

Δω
τ + ω ≈ Kvin .
Δt

¿Y qué representa la fracción Δω / Δt realmente? Sólo representa la magnitud del cambio de la

velocidad del motor de un instante anterior al momento actual. Este es el significado en la realidad
de una derivada: es la medida del cambio de una variable: posición, velocidad, voltaje, corriente,
etc. Podemos usar las derivadas para obtener la medida del cambio de señales que nos interesan.
Entonces, si esta fracción representa el cambio en la velocidad, podemos redefinir la ecuación de
diferencias (ya no es ecuación diferencial, pues aproximamos la derivada con una resta y división):

https://elrobotista.com/simulaciones-numericas/ 2/9
4/4/2019 Python: Simulación de un motor de corriente directa

ωk– ωk−1 1
≈ (Kvin – ωk−1 ),
Δt τ

donde ωk es la velocidad en el instante actual, y ωk−1 en el instante ante(h

ritotrp.s¿:Q
//ueélro
vabroiatibstlea.ecsom
la/)
que nos interesa? La velocidad el motor en el instante actual. Entonces, solo necesitamos resolver
Ilnaiceicou(ahcttió
pn a/leglerborbaoictiastya.lcisotm
s:/ o:/) Blog (https://elrobotista.com/blog/)
Nosotros (https://elrobotista.com/about/)
Δt
ωk ≈ (Kvin– ωk−1 ) + ωk−1 ,
τ

Esta es la ventaja de resolver una ecuación diferencial en una computadora: las integrales se
transforman en sumas y las derivadas en restas. Una ecuación diferencial se vuelve una ecuación
de diferencias.

Simulación del motor en Python

De nada nos sirve la ecuación si no podemos estudiar la respuesta. Podemos resolverla paso a paso
y obtener la evolución del sistema; sin embargo, estarán de acuerdo que esto sería tedioso y
aburrido. Por otro lado, las computadoras son perfectas para esto. Existen diversas herramientas
de simulación y lenguajes de programación tanto libres como propietarios para simular sistemas.
En esta ocasión usaremos Python por la sintaxis tan limpia que caracteriza a este lenguaje y
además, es un lenguaje de programación de código abierto.

La simulación del motor es algo así:

https://elrobotista.com/simulaciones-numericas/ 3/9
4/4/2019 Python: Simulación de un motor de corriente directa
1 # IMPORTAR modulo PARA GRAFICAR.
2 import MATPLOTLIB.pyplot AS plt
3 K = 145.47 # GANANCIA de DC del motor.
4 TAU = 0.087 # CONSTANTE de tiempo,
5 ti = 0. # Tiempo INICIAL. (https://elrobotista.com/)
6 tf = 2. # Tiempo FINAL.
7 dt = 0.01 # Tiempo de muestreo.
8 t = ti # Tiempo ACTUAL de SIMULACION.
In9icioV(ihnttp
= s2
:/4/e#lroVb E .cdo
oTtiAsJta
OL emE/N)TRADAB.log (https://elrobotista.com/blog/)
10 w = 0. # VELOCIDAD INICIAL del motor.
N1o1soWtro=s [(h
wt]tp#s:/
V/
eecltroorbodteistsao.c
lo mi/
uc aebso.ut/)
on
12 T = [t] # Vector de tiempo.
13 ts = 1e-2 # Tiempo de muestreo.
14
15 # INTEGRAR LA ECUACION de DIFERENCIAS
16 # por el tiempo ESPECIFICADO.
17 while t < tf:
18
19 # ESTA es LA ECUACION de DIFERENCIAS.
20 w = (dt / TAU) * (K * Vin - w) + w
21
22 t += ts # Siguiente MUESTRA de tiempo.
23 # AGREGAR AL vector de soluciones PARA GRAFICAR
24 # LA VELOCIDAD CONTRA el tiempo.
25 W.APPEND(w / 1000.)
26 T.APPEND(t)
27
28 # GRAFICAR LA VELOCIDAD CONTRA el tiempo.
29 plt.plot(T, W)
30
31 # ADORNAR LA GRAFICA.
32 plt.title('RESPUESTA del motor')
33 plt.XLABEL('Tiempo (s)')
34 plt.YLABEL('VELOCIDAD (RPM x 1000)')
35 plt.show()

La gráfica debería verse similar a esta:

Respuesta del motor de corriente directa a un escalón de voltaje

https://elrobotista.com/simulaciones-numericas/ 4/9
4/4/2019 Python: Simulación de un motor de corriente directa

(https://elrobotista.com/)

Inicio (https://elrobotista.com/) Blog (https://elrobotista.com/blog/)

Nosotros (https://elrobotista.com/about/)

(https://elrobotista.com/simulaciones-numericas/motor_response1_1024/)

Figura 1.- Respuesta del motor de corriente directa a un escalón de voltaje.

Simular sistemas dinámicos utilizando métodos numéricos permite evaluar el desempeño del
sistema a variación de parámetros: sea del sistema mismo, condiciones de operación, diferentes
paradigmas de control, etc. Por ejemplo, supongamos que queremos estudiar el impacto de la
variación de los parámetros τ, K. Si tienen conocimiento en teoría de ecuaciones diferenciales, les
será obvio el impacto que tienen estos parámetros en la respuesta del motor. Pero tengamos en
cuenta que estamos hablando de un sistema lineal de primer orden; no es tan sencillo deducirlo
para modelos de sistemas dinámicos más complejos.

Supongamos que el modelo es más complejo y queremos estudiar el impacto de estos parámetros
usando Python. ¿Cómo sería?

https://elrobotista.com/simulaciones-numericas/ 5/9
4/4/2019 Python: Simulación de un motor de corriente directa
1 import MATPLOTLIB.pyplot AS plt
2
3 # Vectores de VARIACION de PARAMETROS
4 _K = [145.47 * (i / 2.) for i in RANGE(2, 7)]
5 _TAU = [0.087 * (i / 2.) for i in RANGE(2, 7)] (https://elrobotista.com/)
6
7 ti = 0. # Tiempo INICIAL.
8 tf = 1.5 # Tiempo FINAL.
In9iciot(sht=tp0s.:/0/2el#
robTioetimspta
o .cdoemm/u)estreBol.og (https://elrobotista.com/blog/)
10
N1o1sottro=s t(h
itt#psT:/ i/
eemlpro
obAoCtTisUtAaL.co
dem/ aMbUoLuAtC/I)ON.
SI
12 Vin = 24 # VOLTAJE de ENTRADA.
13 x = 0. # VELOCIDAD INICIAL del motor.
14
15 _X = [[x] for _ in _K] # Vector de soluciones
16 _T = [[t] for _ in _K] # Vector de tiempo
17 # LEYENDAS
18 leg = []
19
20 for K, TAU, X, T in zip(_K, _TAU, _X, _T):
21 x, t = X[0], T[0]
22 # ASIGNAR LEYENDA PARA distinguir GRAFICO.
23 leg.APPEND('K={0}, TAU={1}'.FORMAT(K, TAU))
24 while t < tf:
25 dx = (K * Vin - x) / TAU
26 x += dx * ts
27 t += ts # Siguiente MUESTRA de tiempo.
28 X.APPEND(x / 1000)
29 T.APPEND(t)
30 plt.plot(T, X, linewidth = 2.)
31 plt.title('IMPACTO de LA VARIACION de PARAMETROS del Motor')
32 plt.XLABEL('Tiempo (s)')
33 plt.YLABEL('VELOCIDAD (RPM x 1000)')
34 plt.xlim([ti, tf])
35 plt.grid()
36 plt.legend(leg, loc='best')
37 plt.show()

https://elrobotista.com/simulaciones-numericas/ 6/9
4/4/2019 Python: Simulación de un motor de corriente directa

(https://elrobotista.com/simulaciones-numericas/var_motor_response_1024/)

Figura 2.- Respuesta del motor con diferentes parámetros a un escalón de voltaje.
(https://elrobotista.com/)

Se puede apreciar en la Figura 2 que el impacto de la constante de tiempo τ es aumentar o

Idniiscm
ioin
(huttirplsa:/r/eeslp
roubeostiastdae.clom
mo/to
) r, mB
ieln
og
tra(hstq
tpuse:/l/aeglraonbaonticsitaa.K
com
de/tbelromgi/n)a la magnitud que alcanza
N
laovseoltoro
cisd(ahdtt:ptsa:l//
coem
lrooblootiesstap.e
croám
b/aamboosu. t/)
(https://elrobotista.com/simulaciones-numericas/motor_response1_1024/)

Entonces, podemos concluir que fácilmente podemos desarrollar simulaciones para estudiar la
respuesta de sistemas dinámicos bajo condiciones de operación que nos interesen.

Integrador ODE-1

Podemos establecer un algoritmo un poco más sencillo de recordar que nos permitirá desarrollar
las simulaciones aún con más facilidad: el método de integración “ODE-1” o método de Euler. Va
algo así: redefinamos, por sencillez, la notación de la derivada en el tiempo de una señal arbitraría
y:

dy
≡ y.
dt

Esta es la denominada notación de Newton, o “flux notation” en inglés. Ahora, si sustituimos la

aproximación de la derivada:

yk − yk−1
≈ y,
Δt

y resolvemos para el momento actual de la señal y:

yk ≈ yΔt + yk−1 .

¡Y esto es todo! Entonces, integrar una ecuación diferencial se convierte en un algoritmo de 3

pasos: Calcular la dinámica del sistema y, multiplicar por el tiempo de muestreo Δt, y sumar el
valor anterior de la señal y. Sencillo, ¿no?

Si se dieron cuenta, este algoritmo nos sirve para resolver derivadas de primer orden. En futuras
entradas veremos como podemos generalizar el método para resolver un sistema dinámico de
dimensión n > 1. Esto nos permitirá estudiar sistemas más complejos, como por ejemplo un
“Quadcopter”.

https://elrobotista.com/simulaciones-numericas/ 7/9
4/4/2019 Python: Simulación de un motor de corriente directa

Acertijo: ¿Si, además de estudiar la velocidad del motor, también necesitamos estudiar la posición
del motor. Qué necesitamos añadir a la simulación para que también calcule la posición del motor
y no sólo la velocidad? Y la situación inversa también es válida: ¿Si neces(ihtattms:s//oeblrtoebnoetrislata.com/)
po
aceleración del motor a partir de la velocidad, ¿cómo sería el algoritmo en Python?

Inicio (https://elrobotista.com/) Blog (https://elrobotista.com/blog/)

Insisto. Este tipo de problemas realmente se presentan en la industria. Recientemente, el equipo
Nosotros (https://elrobotista.com/about/)
con el que trabajo necesitaba obtener la aceleración de un sistema mecánico, y el sistema sólo
contaba con sensores de velocidad. ¿Qué harían en esta situación ustedes?

Compartir:

(https://elrobotista.com/simulaciones-numericas/?share=facebook&nb=1)

(https://elrobotista.com/simulaciones-numericas/?share=twitter&nb=1)

(https://api.whatsapp.com/send?
text=Simulaci%C3%B3n%20de%20Sistemas%20Din%C3%A1micos%20https%3A%2F%2Felrobotista.com%2Fsimulaciones-
numericas%2F)

(https://elrobotista.com/simulaciones-numericas/?share=linkedin&nb=1)

(https://elrobotista.com/simulaciones-numericas/?share=reddit&nb=1)

(https://elrobotista.com/simulaciones-numericas/?share=google-plus-1&nb=1)

PYTHON (HTTPS://ELROBOTISTA.COM/TAG/PYTHON/)

SIMULACION (HTTPS://ELROBOTISTA.COM/TAG/SIMULACION/)

SISTEMAS DINÁMICOS (HTTPS://ELROBOTISTA.COM/TAG/SISTEMAS-DINAMICOS/)

⟵ Modelado de un Motor de Corriente Buuer Circular en C

Directa (https://elrobotista.com/modelado/) (https://elrobotista.com/buuer-circular/) ⟶

https://elrobotista.com/simulaciones-numericas/ 8/9
4/4/2019 Python: Simulación de un motor de corriente directa

Proudly powered by WordPress (https://wordpress.org/) | Theme: Sydney

(https://athemes.com/theme/sydney) by aThemes. (https://elrobotista.com/)

Inicio (https://elrobotista.com/) Blog (https://elrobotista.com/blog/)

Nosotros (https://elrobotista.com/about/)

https://elrobotista.com/simulaciones-numericas/ 9/9