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».

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

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.

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.

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)