Estoy desarrollando un modelo en python de un panel fotovoltaico, es análogo al que puse en una entrada anterior, pero esta vez explotaremos mas el modelo y lo usaremos para analizar la interacción entre el panel fotovoltaico con los siguientes casos:
-Punto de operación, panel fotovoltaico - carga resistiva,
-Punto de operación, panel fotovoltaico - batería
Definiremos una clase con métodos que nos permitan simular el comportamiento de un panel fotovoltaico.
import numpy as np
from scipy.special import lambertw
El código anterior importa los módulos necesarios.
Ahora declaramos la clase y algunos valores necesarios para la implementación
class pv:
"""CLASE PARA ANALIZAR PANELES FOTOVOLTAICOS"""
################################################
# constantes fisicas
K=1.3806503e-23 #constante de boltzman
q=1.60217646e-19 # carga del electron
Egap=1.124*q #Para silicio cristalino: Egap = 1.124 eV = 1.8⋅10−19 J.
################################################
# modelado de un panel fotovoltaico
###############################################
#condiciones estandar de prueba (STC)
Gstc=1.0 #valor de Irradiacion en Kw/m^2
Tstc=273.0+25.0 #Temperatura ambiente en °K
NOCT=46.0 # [°C] temperatura nominal de operación del modulo
VT_stc=K*Tstc/q # Voltaje Termico en temperatura STC ec(1.5)
Método de inicialización de los objetos de la clase "pv", cada vez que creemos un objeto
pv, debemos asignarle los parámetros listados, caso contrario se usaran los parámetros por default.
$V_{OC_{STC}}[V]$: Voltaje de circuito abierto del modulo fotovoltaico, medido en condiciones estandard de prueba (STC: del ingles Standard Test Condition).
$I_{SC_{STC}}$[A]: Corriente de cortocircuito del modulo fotovoltaico, en STC.
$V_{mpp_{STC}}$[V] : Voltaje en el punto de máxima potencia, en STC.
$I_{mpp_{STC}}$[A]: Corriente en el punto de máxima potencia para STC.
$\alpha_I$[A/°C]: Coeficiente de Temperatura de $I_{SC}$.
$\alpha_V$[V/°C]: Coeficiente de Temperatura de $V_{OC}$.
$N_S$: Numero de células solares en serie que forman el arreglo.
$N_P$: Numero de ramas en paralelo de que esta formado el arreglo.
def __init__(self,Voc_stc=10.8,Isc_stc=7.7,Vmpp_stc=8.6,
Impp_stc=7.2,alfa_i=5.39e-3,alfa_v=-0.0378,Ns=18.0,Np=1.0):
self.Voc_stc=Voc_stc
self.Isc_stc=Isc_stc
self.Vmpp_stc=Vmpp_stc
self.Impp_stc=Impp_stc
self.alfa_i=alfa_i
self.alfa_v=alfa_v
self.Ns=Ns
self.Np=Np
A continuación el método
ipanel(Va,Ga,Ta)para encontrar la corriente en el panel, a este método se le deben pasar tres parámetros,:
$V_a$: Es la tensión en los bornes del panel, para laque se desea hallar la corriente correspondiente.
$G_a$: Es el valor de la irradiación normalizado, donde una irradiación de $1000\frac{W}{m^2}$ corresponde a $G_a=1$
$T_a$: Es el valor de la temperatura ambiente, para calcular la temperatura de la celula/modulo, se usa una formula aproximada, definida dentro del método
ipanel
El procedimiento para encontrar la corriente se encuentra documentado en el libro "
Power Electronics and Control Techniques for Maximum Harvesting in Photovoltaics Systems". de los autores:
Femia, Petrone, Spagnuolo, Vitelli.
En este libro se muestra una forma para definir la corriente en el panel como una función explicita de la tensión para ello se hace uso de la función
Lambertw definida en
scipy.
def ipanel(self,Va,Ga,Ta):
# Va [V], contiene el valor de la tension en los bornes del panel
# Ga, el valor de la Iradiación solar
# Ta[°C], Temperatura ambiente
# ipanel: esta función devuelve la corriente en el panel,
# dados el valor de Ga, Ta, Va
###############################################################
T=Ta+(self.NOCT-20.0)/800.0*Ga # [°C]Temperatura del modulo
T=273.0+T #[°K]
VT=self.K*T/self.q # Voltaje Termico a la Temperatura del modulo
# Cálculo de parámetros de del modelo
Iph_stc=self.Isc_stc
aux1=self.alfa_v-self.Voc_stc/self.Tstc
aux2=self.alfa_i/Iph_stc-3/self.Tstc-self.Egap/(self.K*self.Tstc**2)
aux3=self.Ns*self.VT_stc
n=aux1/(aux2*aux3) # Factor de idealidad
Isat_stc=Iph_stc*np.exp(-self.Voc_stc/(n*self.Ns*self.VT_stc))
C=Isat_stc/(self.Tstc**3*np.exp(-self.Egap/(self.K*self.Tstc)))
Isat=C*T**3*np.exp(-self.Egap/(self.K*T))
Iph=Iph_stc*(Ga/self.Gstc)*(1.0+self.alfa_i*(T-self.Tstc))
aux1=self.Vmpp_stc*(2.0*self.Impp_stc-Iph-Isat_stc)
aux2=n*Isat_stc*self.Ns*self.VT_stc
aux3=np.exp((self.Vmpp_stc-2.0*n*self.Ns*self.VT_stc)*self.Vmpp_stc/(self.Ns**2*n**2*self.VT_stc**2))
aux4=2.0*self.Vmpp_stc/(n*self.Ns*self.VT_stc)-self.Vmpp_stc**2/(self.Ns**2*n**2*self.VT_stc**2)
x=np.abs(lambertw(aux1*aux3/aux2))+aux4 # ec(1.45)
Rs=(x*n*self.Ns*self.VT_stc-self.Vmpp_stc)/self.Impp_stc
Rp=x*n*self.Ns*self.VT_stc/(Iph_stc-self.Impp_stc-Isat*(np.exp(x)-1.0))
aux1=(Rp*Rs)/(Rp+Rs)
aux2=np.exp((Rp*Rs*(Iph+Isat)+Rp*Va)/(n*self.Ns*VT*(Rp+Rs)))
theta=aux1*Isat/(n*self.Ns*VT)*aux2
##############################################################
# ecuación de salida
I=(Rp*(Iph+Isat)-Va)/(Rs+Rp)-n*self.Ns*VT*np.abs(lambertw(theta))/Rs
# la siguiente ecuacion restringe I a valres mayores a 0
#I=0.5*np.abs(I+np.abs(I))
return I
Hasta aquí tenemos definido un método para inicializar la clase y asignar valores a los parámetros del modelo, y un método que encuentra el valor de la corriente en el panel para un conjunto de condiciones dadas.
Lo siguiente que haremos sera analizar la interaccion entre el panel fotovoltaico y una Carga Resistiva, las condiciones de operación serán: $G=1.0$(Irradiación solar de $1000\frac{W}{m^2}$ y temperatura ambiente de $25^°C$
 | |
| Circuito 1 |
|
|
|
Si tratáramos de solucionar el problema de manera gráfica, el punto de operación, es decir la corriente y la tensión en el conjunto panel fotovoltaico - resistencia, lo podemos encontrar por la intersección de ambas curvas I-V. Para solucionar el problema y encontrar los valores numéricos, plantearemos el problema de la siguiente forma:
Ecuación de la Resistencia :
(A):
$$V_{PV}=I_{PV}\cdot R$$
Corriente en el modulo fotovoltaico como función de la tensión:
(B):
$$I_{PV}=F(V_{PV})$$
Dado que la función que define la corriente $I_{PV}$ es no lineal, se hace necesaria la implementación de un método numérico que aproxime la solución. Para el presente caso emplearemos el
método de la secante, a continuación muestro su implementación en python.
def secante(funcion,a,b,rel_tol,maxiter=100):
fa=funcion(a)
for i in xrange(maxiter):
fb=funcion(b)
x=b-fb*(b-a)/(fb-fa)
a=b
b=x
fa=fb
error=abs((b-a)/b)
if error<rel_tol:
return x
break
raise RuntimeError("No hubo convergencia después de {} \
iteraciones".format(maxiter))
Teniendo ya lo necesario, encontrar la solución del Circuito 1 se reduce a plantear las ecuaciones (A) y (B) a la forma $G(V)=0$, lo cual quedaría asi
$V_{PV}-I_{PV}\cdot R=0$
$V_{PV}-F(V_{PV})\cdot R=0$
Antes de seguir con la solucion, coloco la definición de una función auxiliar que usare para imprimir resultados:
def print_resultados(titulo,v,i):
print "==============================="
print "Resultados:", titulo
print "Tension en panel Fotovoltaico",v
print "Corriente panel fotovoltaico",i
Ahora el código necesario para resolver el circuito, usando las herramientas definidas hasta ahora.
################################################
#Resolver el circuito
# R
# _________/\/\/\_____
# | |
# | |
# PV |
# | |
# |___________________|
panel=pv()#creamos un objeto pv, con
# parametros de inicializacion por defecto
#(observar codigo de definicion de la clase pv)
G=1.0 #irradiacion
T=25.0#temperatura
v=np.arange(0,10.8,0.0001)#vector de tensión, lo usaremos
# para hacer un barrido
i=panel.ipanel(v,G,T)#barrido de la corriente para el
#vector de tensiones definido arriba
#La funcion pv_r(V), define el comportamiento del circuito
# PV-R
def pv_r(V):
R=1.0
I=panel.ipanel(V,G,T)
return V-I*R#al pasar por el metodo secante(..)
#debe encontrar la raiz de G(V)=V-I*R=0
Vpv=secante(pv_r,0,10.8,0.00001)#llamamos al metodo secante,
# notese que se pasa la funcion pv_r como parametro es decir
# encontrara el valor de "V" que haga que pv_r=0,
I=panel.ipanel(Vpv,G,T) #valor de corriente correspondiente a V
# (Hallado por el metodo de la secante)
print_resultados("Circuito Panel-Carga",Vpv,I)
#ahora graficamos la solucion, para verificar
plt.hold(True)
plt.plot(v,i)
R=1.0
i2=v/R
plt.plot(v,i2)
plt.xlim(0.0,10.8)
plt.ylim(0.0,8)
plt.title("Circuito 1")
plt.show()
#################################################
Ejecutando el código anterior, obtenemos la figura:
Y en la terminal obtenemos de salida lo siguiente:
jcristhian@pc-otba-01:~$ python pv_r.py
===============================
Resultados: Circuito Panel-Carga
Tension en panel Fotovoltaico 7.55679593541
Corriente panel fotovoltaico 7.55679593176
Notar que como la resistencia de carga para la que efectuamos el análisis tiene el valor de $1.0\Omega$ entonces la tensión y corriente resultantes presentan el mismo valor.
Ahora plantearemos un segundo problema que consistirá en encontrar el flujo de corriente de un modulo fotovoltaico a una batería, para propósitos didácticos modelaremos la batería como una fuente de tensión de $5$
V en serie con una resistencia de $0.5\Omega$
 |
| Circuito 2 |
Implementación de la solucion:
#################################################
#Resolver el circuito
# R
# _________/\/\/\_____
# | |
# _|_ __|__
# PV Vdc
# | |
# |___________________|
#definimos la funcion que define el problema,
#que sera pasada a la implementacion del metodo de la secante
#para encontrar la tensión que resuelve el problema
def pv_r_v(V):
R=0.5
Vdc=5.0
I=pv().ipanel(V,1.0,25)
return V-I*R-Vdc
Vpv=secante(pv_r_v,0,10.8,0.00001)
I=panel.ipanel(Vpv,G,T)
print_resultados("Circuito Panel-Bateria",Vpv,I)
#ahora graficamos las curvas I-V para ambos elementos
#plt.subplot(1,2,2)
plt.hold(True)
plt.plot(v,i)
plt.xlim(0.0,10.8)
plt.ylim(0.0,8)
R=0.5
Vdc=5.0
i2=(v-Vdc)/R
plt.plot(v,i2)
plt.title("Circuito 2")
plt.show()
El script anterior da como salida lo sgte:
===============================
Resultados: Circuito Panel-Bateria
Tension en panel Fotovoltaico 8.60072641912
Corriente panel fotovoltaico 7.2014528405
