docs/Install.rst
| |image1| |image2| |image3| |image4| |image5|
.. _header-n2:
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.
.. _header-n15:
Instalación
-----------
La instalación del módulo se realiza con :
.. code:: python
pip install ClarkePark
.. _header-n18:
Sistema ABC
-----------
Las tensiones o corrientes trifásicas en el dominio del tiempo son :
fase A,
.. math::
:nowrap:
\begin{eqnarray}
\begin{matrix}
V_{A} = V_{m} \sin \left (\omega t+0 \right )
\end{matrix}
\end{eqnarray}
fase B,
.. math::
:nowrap:
\begin{eqnarray}
\begin{matrix}
V_{B} = V_{m} \sin \left (\omega t+240 \right )
\end{matrix}
\end{eqnarray}
fase C,
.. math::
:nowrap:
\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.
.. code:: python
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á.
.. code:: python
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
.. code:: python
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
.. code:: python
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 :
.. math::
:label: Transformación alpha,beta
:nowrap:
\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}
.. _header-n31:
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:
.. code:: python
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".
.. figure:: 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.
.. code:: python
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
.. figure:: 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.
.. figure:: 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.
.. _header-n44:
Transformación (ABC) - (dq0)
----------------------------
La transformación del marco ABC al sistema de referencia dq0,
implementando la misma señal se obtiene con
.. code:: python
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
.. code:: python
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()
.. _header-n52:
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.
.. code:: python
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 :
.. code:: python
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
.. code:: python
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.
.. figure:: https://i.ibb.co/gtWbCj7/Figure-2.png
Transformación inversa dq0 - ABC
.. _header-n55:
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.
.. code:: python
d, q, z= ClarkePark.alphaBeta0_to_dq0(alpha, beta, zero, wt, delta)
.. |image1| image:: https://badge.fury.io/py/ClarkePark.svg
:target: https://badge.fury.io/py/ClarkePark
.. |image2| image:: https://img.shields.io/badge/python-3 | 3.5 | 3.6 | 3.7 | 3.8 | 3.9 | 3.10-blue
:target: https://pypi.org/project/ClarkePark/
.. |image3| image:: https://pepy.tech/badge/clarkepark
:target: https://pepy.tech/project/clarkepark
.. |image4| image:: https://pepy.tech/badge/clarkepark/month
:target: https://pepy.tech/project/clarkepark
.. |image5| image:: https://api.codeclimate.com/v1/badges/6abceb2a140780c13d17/maintainability
:target: https://codeclimate.com/github/jacometoss/ClarkePark/maintainability