Transformación ClarkePark!¶

Introducción

ClarkePark - Es un paquete para obtener los marcos de referencia Dq0 y α,β.

ClarkePark ( Versión 0.1.7 ) puede ser utilizado para obtener los diferentes marcos de referencia como transformaciones entre los propios marcos de referencia y hacia el sistema ABC.

El módulo de Park (dq0) & Clarke (α, β ) incluye :

Transformación de componentes del tiempo, marco A, B, C a ejes nuevos de referencia estacionario ortogonal α, β.
Inversa de Clarke, ejes de referencia estacionario ortogonal α, β a componentes del dominio del tiempo, marco A, B , C.
Transformación de componentes del tiempo, marco ABC hacia un sistema de referencia dq0 en régimen permanente.
Inversa de Park, ejes de referencia rotatorio dq0 a componentes del dominio del tiempo, marco A, B, C.
Transformación de referencia estacionario ortogonal α, β hacia un marco de referencia rotatorio dq0.

¿Te gusta este proyecto?, puedes apoyarme mediante

La vida es como una batería y en cada momento uno va perdiendo una pequeña parte de esta cada día, puedes apoyarme en el desarrollo de este proyecto y motivar aún más mi creatividad para que sea de gran utilidad esta herramienta.

Puedes comprarme un café :

No es mucho pero de algo sirve para mejorar este proyecto, acepto críticas como sugerencias.

Sistema abc y marcos de referencia¶

Instalación de Park & Clarke¶

La librería Park (dq0) & Clarke (α, β ) incluye los módulos siguientes :

Transformación de componentes del tiempo, marco A, B, C a ejes nuevos ejes de referencia estacionario ortogonal α, β.
Inversa de Clarke, ejes de referencia estacionario ortogonal α, β a componentes del dominio del tiempo, marco A, B , C.
Transformación de componentes del tiempo, marco ABC hacia un sistema de referencia dq0 en régimen permanente.
Inversa de Park, ejes de referencia rotatorio dq0 a componentes del dominio del tiempo, marco A, B, C.
Transformación de referencia estacionario ortogonal α, β hacia un marco de referencia rotatorio dq0.

Instalación¶

La instalación del módulo se realiza con :

pip install ClarkePark

Sistema ABC¶

Las tensiones o corrientes trifásicas en el dominio del tiempo son :

fase A,

\begin{eqnarray} \begin{matrix} V_{A} = V_{m} \sin \left (\omega t+0 \right ) \end{matrix} \end{eqnarray}

fase B,

\begin{eqnarray} \begin{matrix} V_{B} = V_{m} \sin \left (\omega t+240 \right ) \end{matrix} \end{eqnarray}

fase C,

\begin{eqnarray} \begin{matrix} V_{C} = V_{m} \sin \left (\omega t+120 \right ) \end{matrix} \end{eqnarray}

Transformación (a,b,c) - (α, β)¶

El módulo tiene dependencias siendo necesario instalar numpy para procesar la información. También será necesario instalar e importar matplotlib.pyplot para visualizar los resultados.

alpha, beta, z = ClarkePark.abc_to_alphaBeta0(A,B,C)

Las últimas versiones de numpy y matplotlib.pyplot pueden ser utilizadas, el propio paquete las instalará.

import ClarkePark
import numpy as np
import matplotlib.pyplot as plt

end_time = 10/float(60)
step_size = end_time/(1000)
t = np.arange(0,end_time,step_size)
wt = 2*np.pi*float(60)*t
delta = 0

rad_angA = float(0)*np.pi/180
rad_angB = float(240)*np.pi/180
rad_angC = float(120)*np.pi/180

A = (np.sqrt(2)*float(127))*np.sin(wt+rad_angA)
B = (np.sqrt(2)*float(127))*np.sin(wt+rad_angB)
C = (np.sqrt(2)*float(127))*np.sin(wt+rad_angC)

alpha, beta, z = ClarkePark.abc_to_alphaBeta0(A,B,C)

Graficando se obtiene las señales de tensión (A, B, C) balanceada.

Para obtener el gráfico de la tensión trifásica balanceada se uso

plt.figure(figsize=(8,3))
plt.plot(t, A, label="A", color='k')
plt.plot(t, B, label="B", color='darkred')
plt.plot(t, C, label="C", color="darkblue")
plt.legend(['A','B','C'])
plt.legend(ncol=3,loc=4)
plt.ylabel("Tensión [Volts]")
plt.xlabel("Tiempo [Segundos]")
plt.title(" Tensión trifásica (ABC)")
plt.grid('on')
plt.show()

Graficando el marco de referencia (α, β)

Para obtener el gráfico de la transformación de Clarke

plt.figure(figsize=(8,3))
plt.plot(t, alpha, label="\u03B1", color="darkred")
plt.plot(t, beta, label="\u03B2", color="darkblue")
plt.plot(t, z, label="zero" , color="dimgray")
plt.legend(['\u03B1','\u03B2','0'])
plt.legend(ncol=3,loc=4)
plt.ylabel("Tensión [Volts]")
plt.xlabel("Tiempo [Segundos]")
plt.title(" Transformación Clarke (\u03B1 \u03B2)")
plt.grid('on')
plt.show()

El arreglo matricial para realizar la transformación es :

\begin{eqnarray} \begin{matrix} \begin{bmatrix} i_{\alpha }\left ( t \right )\\ i_{\beta }\left ( t \right )\\ i_{z } \left ( t \right ) \end{bmatrix} = \begin{bmatrix} 1 & -\frac{1}{2} & -\frac{1}{2}\\ 0 & \frac{\sqrt{3}}{2}& -\frac{\sqrt{3}}{2}\\ \frac{1}{2} & \frac{1}{2} & \frac{1}{2} \end{bmatrix} \begin{bmatrix} i_{a}\left ( t \right )\\ i_{b}\left ( t \right )\\ i_{c}\left ( t \right ) \end{bmatrix} \end{matrix} \end{eqnarray}

Señal trifásica desbalanceada¶

Cuando se tiene una desbalance en la señal trifásica, especificamente en la «Fase B», para implementarse se usa el código siguiente:

A_unbalance = (np.sqrt(2)*float(127))*np.sin(wt+rad_angA)
B_unbalance = (np.sqrt(2)*float(115))*np.sin(wt+rad_angB)
C_unbalance = (np.sqrt(2)*float(127))*np.sin(wt+rad_angC)

Graficando se obtiene las señales de tensión (A, B, C) desbalanceada la «Fase B».

https://i.ibb.co/gWsM4xw/Fig02abc-Unbalance.png — Tensión trifásica, sistema ABC¶

Para obtener la señal desbalanceada anterior implemente las siguientes líneas.

plt.figure(figsize=(8,3))
plt.plot(t, A_unbalance, label="A", color='k')
plt.plot(t, B_unbalance, label="B", color='darkred')
plt.plot(t, C_unbalance, label="C", color="darkblue")
plt.legend(['A','B','C'])
plt.legend(ncol=3,loc=4)
plt.ylabel("Tensión [Volts]")
plt.xlabel("Tiempo [Segundos]")
plt.title(" Tensión trifásica (ABC)")
plt.grid('on')
plt.show()

Si analizámos la señal con la transformación de Clarke

https://i.ibb.co/XXYSsrn/Fig02-Unbalance.png — Transformación de Clarke¶

Podemos observar que la componente de secuencia cero tiene oscilaciones debido al desbalance y las componentes alpha y beta no presentan variación alguna. Si implementamos la transformación de Park.

https://i.ibb.co/N3mywNs/Fig03-abc-Unbalance.png — Transformación de Park¶

La componente d y q varían a la misma frecuencia pero la componente de secuencia cero no. A partir de estos ejemplos usted puede implementar el paquete para el manejo y análisis de señales oscilante en el tiempo.

Transformación (ABC) - (dq0)¶

La transformación del marco ABC al sistema de referencia dq0, implementando la misma señal se obtiene con

d, q, z = ClarkePark.abc_to_dq0(A, B, C, wt, delta)

Un sistema rotatorio puede ser analizado con la transformación de Park generándose dos señales de valor constante en régimen permanente.

Para obtener el gráfico de la transformación de Park

plt.figure(figsize=(8,3))
plt.plot(t, d, label="d", color="royalblue")
plt.plot(t, q, label="q", color="orangered")
plt.plot(t, z, label="zero" , color="forestgreen")
plt.legend(['d','q','0'])
plt.legend(ncol=3,loc=4)
plt.ylabel("Tensión [Volts]")
plt.xlabel("Tiempo [Segundos]")
plt.title(" Transformación Park (dq0)")
plt.grid('on')
plt.show()

Transformación inversa (dq0) - (ABC)¶

La transformación inversa de Park, ejes de referencia rotatorio dq0 a componentes del dominio del tiempo, marco A, B, C.

a, b, c = ClarkePark.dq0_to_abc(d, q, z, wt, delta)

De un marco de referencia constante (dq0) puede ser cambiado al sistema (ABC) de variables senoidales en el tiempo.

Implementaremos un sistema balanceado y aplicaremos el marco de referencia constante (dq0) con las líneas siguientes :

import ClarkePark
import numpy as np
import matplotlib.pyplot as plt

end_time = 3/float(60)
step_size = end_time/(1000)
delta=0
t = np.arange(0,end_time,step_size)
wt = 2*np.pi*float(60)*t

rad_angA = float(0)*np.pi/180
rad_angB = float(240)*np.pi/180
rad_angC = float(120)*np.pi/180

A = (np.sqrt(2)*float(127))*np.sin(wt+rad_angA)
B = (np.sqrt(2)*float(127))*np.sin(wt+rad_angB)
C = (np.sqrt(2)*float(127))*np.sin(wt+rad_angC)

d, q, z = ClarkePark.abc_to_dq0(A, B, C, wt, delta)
a, b, c = ClarkePark.dq0_to_abc(d, q, z, wt, delta)

Los resultados obtenidos en líneas anteriores son graficadas mediante

plt.figure(figsize=(8,3))
plt.plot(t, a, label="A", color="royalblue")
plt.plot(t, b, label="B", color="orangered")
plt.plot(t, c, label="C" , color="forestgreen")
plt.legend(['A','B','C'])
plt.legend(ncol=3,loc=4)
plt.ylabel("Tensión [Volts]")
plt.xlabel("Tiempo [Segundos]")
plt.title(" Sistema trifásico ABC")
plt.grid('on')
plt.show()

Finalmente se obtiene las señales del sistema trifásico ABC mediante la transformación inversa dq0 al sistema ABC.

https://i.ibb.co/gtWbCj7/Figure-2.png — Transformación inversa dq0 - ABC¶

Transformación inversa (α, β) - (dq0)¶

La transformación inversa de Park, ejes de referencia rotatorio dq0 a componentes del dominio del tiempo, marco A, B, C.

d, q, z= ClarkePark.alphaBeta0_to_dq0(alpha, beta, zero, wt, delta)

Marcos de referencia y señal trifásica balanceada¶

Para poder usar la transformación es necesario generar las tres señales monofásicas en desfase y balanceadas siendo necesario de

Numpy : Para el manejo de los datos.
Matplotlib : Obtener las gráficas correspondientes.

import ClarkePark
import numpy as np
import matplotlib.pyplot as plt

end_time = 10/float(60)
step_size = end_time/(1000)
t = np.arange(0,end_time,step_size)
wt = 2*np.pi*float(60)*t
delta = 0

rad_angA = float(0)*np.pi/180
rad_angB = float(240)*np.pi/180
rad_angC = float(120)*np.pi/180

A = (np.sqrt(2)*float(127))*np.sin(wt+rad_angA)
B = (np.sqrt(2)*float(127))*np.sin(wt+rad_angB)
C = (np.sqrt(2)*float(127))*np.sin(wt+rad_angC)

alpha, beta, z = ClarkePark.abc_to_alphaBeta0(A,B,C)
d, q, z = ClarkePark.abc_to_dq0(A, B, C, wt, delta)

# Plot ABC
plt.figure(figsize=(8,3))
plt.plot(t, A, label="A", color='k')
plt.plot(t, B, label="B", color='darkred')
plt.plot(t, C, label="C", color="darkblue")
plt.legend(['A','B','C'])
plt.legend(ncol=3,loc=4)
plt.ylabel("Tensión [Volts]")
plt.xlabel("Tiempo [Segundos]")
plt.title(" Tensión trifásica (ABC)")
plt.grid('on')
plt.show()

# Plot Alfa-Beta
plt.figure(figsize=(8,3))
plt.plot(t, alpha, label="\u03B1", color="darkred")
plt.plot(t, beta, label="\u03B2", color="darkblue")
plt.plot(t, z, label="zero" , color="dimgray")
plt.legend(['\u03B1','\u03B2','0'])
plt.legend(ncol=3,loc=4)
plt.ylabel("Tensión [Volts]")
plt.xlabel("Tiempo [Segundos]")
plt.title(" Transformación Clarke (\u03B1 \u03B2)")
plt.grid('on')
plt.show()

# Plot DQ0
plt.figure(figsize=(8,3))
plt.plot(t, d, label="d", color="royalblue")
plt.plot(t, q, label="q", color="orangered")
plt.plot(t, z, label="zero" , color="forestgreen")
plt.legend(['d','q','0'])
plt.legend(ncol=3,loc=4)
plt.ylabel("Tensión [Volts]")
plt.xlabel("Tiempo [Segundos]")
plt.title(" Transformación Park (dq0)")
plt.grid('on')
plt.show()

Sistema trifásico balanceado¶

Transformación (α, β)¶

La transformación del marco ABC al sistema de referencia α, β, implementando la misma señal se obtiene con

alpha, beta, z = ClarkePark.abc_to_alphaBeta0(A,B,C)

Un sistema rotatorio puede ser analizado con la transformación de Park generándose dos señales de valor constante en régimen permanente.

Transformación (ABC) - (dq0)¶

La transformación del marco ABC al sistema de referencia dq0, implementando la misma señal se obtiene con

d, q, z = ClarkePark.abc_to_dq0(A, B, C, wt, delta)

Un sistema rotatorio puede ser analizado con la transformación de Park generándose dos señales de valor constante en régimen permanente.

Transformación inversa (dq0) - (ABC)¶

La transformación inversa de Park, ejes de referencia rotatorio dq0 a componentes del dominio del tiempo, marco A, B, C.

a, b, c = ClarkePark.dq0_to_abc(d, q, z, wt, delta)

Transformación inversa (α, β) - (dq0)¶

La transformación inversa de Park, ejes de referencia rotatorio dq0 a componentes del dominio del tiempo, marco A, B, C.

d, q, z= ClarkePark.alphaBeta0_to_dq0(alpha, beta, zero, wt, delta)

Simulación de la Maquina de Inducción 2250 Hp¶

En este ejemplo simulares las corrientes del estator de la máquina de inducción de 2250 Hp. Para leer los resultados guardados se ocupa Pandas de esta manera las columnas del fichero fueron nombradas, los resultados del fichero se obtienen mediante el bloque de código siguiente :

import pandas as pd

db = pd.read_csv('simulacionMI2250HP.csv')
t=db.t
ias=db.ias
ibs=db.ibs
ics=db.ics

La corriente en estator cuando arranca la Maquina de Inducción de 2250 Hp es :

https://i.ibb.co/vsdkCyC/Corriente-estator-abc.png — Corrientes en el estador¶

El bloque de código para graficar la señal es :

plt.figure(figsize=(8,3))
plt.plot(t, ias, label="ias", color='k')
plt.plot(t, ibs, label="ibs", color='darkred')
plt.plot(t, ics, label="ics", color="darkblue")
plt.legend(['ias','ibs','ics'])
plt.legend(ncol=3,loc=4)
plt.ylabel("Corriente [Amperios]")
plt.xlabel("Tiempo [Segundos]")
plt.title(" Motor de Inducción 2550Hp Corrientes Estátor")
plt.grid('on')
plt.show()

Transformación ABC al sistema de referencia α, β.¶

La transformación del marco ABC al sistema de referencia α, β se obtiene mediante el código siguiente :

import ClarkePark
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd


db = pd.read_csv('simulacionMI2250HP.csv')
t=db.t
ias=db.ias
ibs=db.ibs
ics=db.ics

alpha, beta, z = ClarkePark.abc_to_alphaBeta0(ias,ibs,ics)

plt.figure(figsize=(8,3))
plt.plot(t, alpha, label="\u03B1", color="darkred")
plt.plot(t, beta, label="\u03B2", color="darkblue")
plt.plot(t, z, label="zero" , color="dimgray")
plt.legend(['\u03B1','\u03B2','0'])
plt.legend(ncol=3,loc=4)
plt.ylabel("Corriente Estátor [Amperios]")
plt.xlabel("Tiempo [Segundos]")
plt.title(" Transformación Clarke Motor Inducción 2250Hp (\u03B1 \u03B2)")
plt.grid('on')
plt.show()

De esta manera se obtiene la gráfica

https://i.ibb.co/9cLwWP1/Corriente-estator-alpha-beta.png — Transformación u03B1, u03B2, corrientes en el estator.¶

Realizando un acercamiento a la figura 2.

https://i.ibb.co/f40qFSs/Corriente-estator-alpha-beta-zoom.png — Acercamiento en las corrientes¶

Referencias¶

[1] Kundur, P. (1994). Power System Stability and Control. McGraw-Hill Education.

[2] J.C.DAS. (2016). Understanding Symmetrical Components for Power System Modeling. Piscataway: IEEE Press Editorial Board.

Contribución y desarrollo¶

La versión y nombre del paquete son :

[Packqge]: ClarkePark 0.1.6
[Autor]: MSc. Marco Polo Jácome Toss
[Licencia]: GNU General Public License v3.0

Donativos¶

¿Te gusta este proyecto?, puedes apoyarme mediante …

La vida es como una batería y en cada momento uno va perdiendo una pequeña parte de esta cada día, puedes apoyarme en el desarrollo de este proyecto y motivar aún más mi creatividad para que sea de gran utilidad esta herramienta.

Puedes comprarme un café en forma de donativo en el enlace siguiente :

No es mucho pero de algo sirve para mejorar este proyecto, acepto críticas como sugerencias.

       ─▄▀─▄▀
       ──▀──▀
       █▀▀▀▀▀█▄
       █░░░░░█─█
       ▀▄▄▄▄▄▀▀
   Url para donativos
https://ko-fi.com/jacometoss

Módulos ClarkePark¶

Descripción¶

ClarkePark presenta los módulos siguientes:

Transformación (abc) -> (alpha,beta)¶: La transformación del marco ABC al sistema de referencia α, β, implementando la misma señal se obtiene con

alpha, beta, z = ClarkePark.abc_to_alphaBeta0(ABC)

Transformación (ABC) -> (dq0)¶: La transformación del marco ABC al sistema de referencia dq0, implementando la misma señal se obtiene con

d, q, z = ClarkePark.abc_to_dq0(A, B, C, wt, delta)

Transformación inversa (dq0) - (ABC)¶: La transformación inversa de Park, ejes de referencia rotatorio dq0 a componentes del dominio del tiempo, marco A, B, C.

a, b, c = ClarkePark.dq0_to_abc(d, q, z, wt, delta)

Transformación inversa (alpha,beta) - (dq0)¶: La transformación inversa de Park, ejes de referencia rotatorio dq0 a componentes del dominio del tiempo, marco A, B, C.

d, q, z= ClarkePark.alphaBeta0_to_dq0(alpha, beta, zero, wt, delta)