Notebook de IPython

El notebook de IPython es una interfaz  web para IPython y hace posible ejecutar código python  de una manera interactiva y bastante atractiva.
En IPython la documentación y el código interactúan en la interfaz web, luego se puede exportar a diferentes formatos como html o pdf para su publicación
Coloco un vídeo realizado por el equipo de Pybonacci que muestra de una manera breve un ejemplo de como usar IPython.


Para instalar ipython en Windows, GNU/Linux o MAC, consultar el siguiente enlace: Instalación de IPython


A manera de prueba, coloco un notebook que contiene el código de la entrada referente a Modelado de un Panel Fotovoltaico:

-Notebook IPython Panel Fotovoltaico 

En este Link se puede visualizar el notebook con el código para analizar un panel fotovoltaico, proporcionado en la entrada anterior de este blog.

Para probar IPython sin tener que instalar nada, se puede recurrir a la web https://cloud.sagemath.com, además se puede probar también SageMath, para  usar SageMath Cloud con todos sus servicios, te debes registrar primero en su web y podrás acceder a muchos ejemplos, cuenta también con un editor de LaTeX oncloud

Saludos y hasta la próxima.

Otra de fotovoltaicos

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

Descargar código fuente

Control de Potencia en AC con triac y microcontrolador PIC 16F628A

El Triac
El Triac es un dispositivo capaz conducir en ambas direcciones,  es útil para usarlo en control potencia de corriente alterna, posee un pin a través del cual se controla la conducción.

Símbolo esquemático del triac

La conducción  empieza cuando se ingresa una corriente de magnitud mínima $I_{GT}$   positiva o negativa por la compuerta (Pin G), una vez que el triac entra en conducción, la compuerta pierde el control  y el triac permanecerá conduciendo hasta que la corriente que circula entre A1 y A2 sea menor a una corriente de mantenimiento $I_H$, si necesitamos que el triac vuelva a conducir debemos lanzar otro pulso de corriente en el gate, aun cuando existen mas formas de disparar el triac, para el propósito presente solo usaremos la que hemos mencionado.

Control de Fase
 Si conectamos la fuente Vac directamente a la carga y suponiendo que la carga "LOAD" es puramente resistiva, la potencia en la carga viene dada por:

$$P=\frac{V_{AC}^2}{R}$$

Donde:
$V_{AC}$: es el voltaje efectivo de la onda senoidal
$R$: Es el valor en $\Omega$ de la carga resistiva.

Ahora, que pasa si permitimos que se transfiera corriente a la carga solo a partir de un cierto ángulo de disparo al cual llamaremos "$\alpha$", la tensión que llega a la carga tendría la forma de la onda de color verde como muestra la siguiente figura.

Control de fase

El ángulo $\alpha$ puede tomar cualquier valor entre $0$ y $\pi$ radianes, la potencia promedio  que recibe la carga en función del ángulo de disparo $\alpha$, estará dada por la fórmula:
$$P =\frac{1}{\pi} \int_{\alpha}^{ \pi} \frac{[A \cdot sin(\alpha)]^2}{R} \cdot d\alpha$$
$$P=\frac{A^2}{2\pi R}[{\pi-\alpha +\frac{1}{2} \sin(2\alpha})]$$
Donde $A$ es la amplitud de la onda senoidal.
Por simetría del problema solo es necesario integrar hasta $pi$ .

De la misma manera si queremos calcular el voltaje efectivo de la nueva onda "senoidal troceada" , en función del ángulo $\alpha$ tenemos:
$$V_{rms}=\frac{A}{\sqrt{2\pi}}\sqrt{[{\pi-\alpha +\frac{1}{2} \sin(2\alpha})]}$$

A continuación graficamos la dependencia entre el ángulo "$\alpha$", la potencia promedio "$P$" y el voltaje efectivo de la onda troceada "$V_{rms}$"

Gráfica de Ángulo de disparo, Potencia y Tensión Eficaz

El anterior gráfico, muestra como variando el ángulo de disparo (eje $X$) del triac, podemos variar la potencia que se suministra a la carga. EN el grafico, $V_{max}$ es el valor efectivo máximo que corresponde al valor efectivo de una senoidal completa es decir $\frac{A}{\sqrt{2}}$

Un circuito típico para manejar cargas en AC es como el de la figura siguiente:

Circuito 1, para variación de potencia con triac

El proceso que llevara a cabo el microcontrolador  para variar potencia mediante el triac consta de los siguientes pasos:

1:  - Detectar inicio de un nuevo medio ciclo de onda  
2:  - Esperar un tiempo t correspondiente al ángulo alfa
3:  - Enviar la señal de disparo al circuito de control  
4:  - Volver al paso 1  

Para detectar el principio de un medio ciclo de onda, usaremos este circuito cuya salida conectaremos al pin de Interrupción externa.

Circuito 2, para detectar cruce por cero de la onda senoidal.

En el Circuito 2 muestran  las formas de onda generadas en cada etapa del circuito conformador, este circuito se encarga de acondicionar la señal de la red para que el PIC16f628A detecte cada medio ciclo de la red, por medio de la interrupción externa (pin B0).

Circuito 3, circuito completo para probar el ejemplo.

 El código usado para probar el circuito es el siguiente, se usa esta usando el oscilador interno a 4MHz:

1:  #include"16f628a.h"  
2:  #use delay(clock=4000000)  
3:  #use standard_io(a)  
4:  #use standard_io(b)  
5:  #FUSES NOWDT              //No Watch Dog Timer  
6:  #FUSES INTRC_IO            //Internal RC Osc, no CLKOUT  
7:  #FUSES PUT               //Power Up Timer  
8:  #FUSES PROTECT             //Code protected from reads  
9:  #FUSES NOBROWNOUT           //No brownout reset  
10:  #FUSES MCLR              //Master Clear pin enabled  
11:  #FUSES NOLVP              //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O  
12:  #FUSES NOCPD              //No EE protection  
13:  #FUSES RESERVED            //Used to set the reserved FUSE bits  
14:  #DEFINE PIN_TTRIAC1 PIN_A3  
15:  #DEFINE PIN_TTRIAC2 PIN_b2  
16:  // El programa funciona de la siguiente manera:  
17:  // El circuito de conformacion de onda, conectado al pin de INT0  
18:  // hace que se genere una interrupcion en cada inicio de medio ciclo de la onda senoidal  
19:  // de la red, asi para 60Hz, se generara una interrupcion cada 1/(2*60Hz)=8.33ms  
20:  // Cuando se produzca la interrupcion, desde la rutina EXT_ISR   
21:  // se habilitara la interrupcion INT_T0 y se cargara el registro TIMER0 con un valor "k"  
22:  // Luego vendra la interrupcion por desbordamiento de Timer0, y disparara el triac,  
23:  // el valor de "k" se hara variar continuamente para conseguir un efecto de destello  
24:  #int_TIMER0  
25:  void INT_T0(void)   
26:  {  
27:    output_high(PIN_TTRIAC1);  
28:    output_high(PIN_TTRIAC2);  
29:    delay_us(10);   
30:    output_low(PIN_TTRIAC1);  
31:    output_low(PIN_TTRIAC2);  
32:    disable_interrupts(INT_TIMER0);  
33:  }  
34:  int k=0;  
35:  #int_EXT  
36:  void EXT_isr(void)   
37:  {  
38:     set_timer0(k--);  
39:     enable_interrupts(INT_TIMER0);  
40:  }  
41:  void config (void)  
42:  {  
43:    setup_timer_1(T1_DISABLED);  
44:    setup_timer_2(T2_DISABLED,0,1);  
45:    setup_ccp1(CCP_OFF);  
46:    setup_comparator(NC_NC_NC_NC);  
47:    setup_vref(FALSE);  
48:    enable_interrupts(INT_EXT);  
49:    ext_int_edge(l_to_h);// interrupcion externa por flanco de subida  
50:    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_32);//timer con desbordamiento maximo de t=1/(2*60Hz)=8.33ms  
51:    enable_interrupts(GLOBAL);  
52:    disable_interrupts(Int_Timer0);//deshabilitamos interrupcion de timer 0  
53:    set_tris_b(1);  
54:    set_tris_a(0);  
56:  }  
57:  void main (void)  
58:  {  
59:   config();  
61:   while(true)  
62:   {  
63:    //  
64:   }  
65:  }  

Descargar Código Fuente

Vídeo de demostración

Este ensayo puede servir como base para implementar un controlador de temperatura o de cualquier variable, directamente en AC.
Los PCB que se muestran el vídeo contienen los circuitos expuestos, me despido hasta una próxima entrada.