-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 |
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 5V 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
No hay comentarios:
Publicar un comentario