Diagrama de flujo CCS

[mue]

Hola a todo el mundo!

Como comenté hace tiempo estoy haciendo un proyecto sobre un seguidor de maxima potencia de una placa fotovoltaica a partir del meodo de la conductancia incremental, este metodo lo defino en el diagrama de flujo que adjunto en jpg (si alguien lo quiere en otro formato que me lo pida).

Mi problema es que de aqui muy poco tengo que entregar el proyecto y no tengo ni idea de C y C en CCS muy poco, alguna alma caritativa me podria ayudar y resolver mi problema?? o parte de el?

Me han dicho (no se si es verdad), que alguien que domine el CCS hace este programilla en 10 minutos.

El pic es 16F877,

De todas formas se aceptan consejos, criticas y comentarios .

Muchisimas gracias por mirartelo, me ayudes o no

Un saludo cordial

[Modulay]

Con esto tienes para ir abriendo boca

Código: C++

1. void algoritmo()
2. {
3.   // COMIENZO
4.   Medida: V(t1) e I(t1);
5.  
6.   while(TRUE)
7.     {
8.  
9.     Medida: V(t2) e I(t2)
10.     dV = V(t2) - V(t1);
11.     dI = I(t2) - I(t1);
12.  
13.     if(dV == 0)
14.       {
15.       if(dI != 0)
16.         {
17.         if(dI/dV > -(I/V))
18.           {
19.           Vref(t3) = Vref(t2) + C;
20.           }
21.         else
22.           {
23.           Vref(t3) = Vref(t2) - C;
24.           }
25.         }
26.       }
27.     else
28.       {
29.       ///////////////////////////////////////////////////////////////////////////
30.       // Aquí debe ir todo el código correspondiente a cuando dV es distinto de 0
31.       //
32.       //
33.       ///////////////////////////////////////////////////////////////////////////
34.       }
35.  
36.     }
37. }

[mue]

Muchas gracias Modulay por el aperitivo, te lo agradezco de veras,

Tengo una duda... donde pones medida no haría falta alguna instrucción del CCS de lectura...
o donde guarde variables...
no se una que guarde V  y otra V anterior...

un saludo, trabajaré en el resto del algoritmo y lo colgaré para que me corrijais, si hace falta.

[Modulay]

El tipo de lectura que lleves a cabo depende del hardware.
Imagino que el sensado lo harás obteniendo variaciones de voltaje a partir de las variaciones de conductancia.
Para la medición de voltajes analógicos se usan los conversores AD del pic,que convierten la tensión analógica en un valor digital (que suelen tener una resolución típica de 8-10 bits) dentro de una escala dada por una o dos tensiones de referencia.
En CCS,la función que te permite almacenar dicho valor digital en una variable es "read_adc()":

Lectura = read_adc();

La cual almacena en la variable "Lectura" el valor digital de la conversión.
Dependiendo de la resolución del conversor y de las tensiones de referencia usadas,tendrás que hacer el cálculo correspondiente tras cada lectura para adecuar el valor leído y obtener a partir de él el valor de tensión,conductancia,etc, correspondiente.

Por lo que veo en el diagrama,tomas el primer punto del intervalo incremental una única vez,y después,en cada iteración del bucle,tomas el segundo punto...no se yo si esto es del todo correcto...podría serlo si llamases al algortimo cada cierto tiempo y,entre la primera lectura y la segunda,transcurriese también cierto tiempo con el fin de que el incremento temporal sea lo suficientemente grande como para que sea factible detectar y medir incrementos de la variable dependiente,dado que la resolución del conversor es limitada.

Yo replantearía el diagrama de flujo y lo adaptaría para hacer una única lectura...tras la lectura,haría las comparaciones y acciones correspondientes en función de la lectura que se obtuvo la vez anterior...así podrías controlar el tiempo incremental simplemente estableciendo el intervalo de tiempo entre cada llamada al algoritmo.

Todo esto,evidentemente,siempre y cuando lo que quieras calcular sea la variación incremental tomando cada vez 2 puntos nuevos...si el primer punto siempre es el mismo y el único que cambia es el segundo,el diagrama está bien planteado.

[mue]

Yo tambien habia pensado en lo de la primera lectura, creo que es mas factible tu propuesta pero lo intentaré primero con este diagrama y si no me sale lo haré de tu manera e incluiré los dos algoritmos en el proyecto (el antes y el despues).

El diagrama lo saque de un libro y la veradad que me extrañó que la primera lectura estubiera fuera del bucle. No se... (a lo mejor divago).

Otra consulta: La finalidad del programa es que trabaje siempre en el punto de maxima potencia, variando el Duty clicle automaticamente que va a parar al convertidor (buck-bost) gracias al lazo cerrado, en mi diagrama el duty donde estaria?? (se que es una pregunta tonta pero es que no lo se), seria la Vref(t2) +/- C ?? la C?? o no lo tengo en cuenta... uff!!!

gracias.

[Modulay]

Con los pocos datos que das no puedo ser del todo concreto,aunque,por lo que voy deduciendo,Vref parece ser la tensión de entrada del convertidor,por lo que, en teoría, el duty debe permanecer constante para que el lazo cerrado juegue su papel.Imagino que C tendrá un valor constante.

[mue]

Lo único que se seguro es que el duty debe variar, para que el punto de maxima potencia sea constante dentro de lo posible.

Tengo una placa fotovoltaica que va a parar al convertidor (reductor-elevador), éste va a parar a una carga (bateria). Entre medio se cogen las lecturas de la intensidad y la tension (gracias a un sensor). Las dos lecturas van al Pic 16F877, que tiene dos CCP (PWM) ,que segun el algoritmo debe hacer variar el tanto por ciento del duty para que el la potencia no varie.

Tambien creo que C es una constante.

Si un caso no se entiende (que es lo mas probable, no lo entiendo ni yo...) escanearé el esquema el lunes y lo cuelgo.

gracias por tu paciencia.

[mue]

Ahí va mi algoritmo, por favor me lo podeis corregir para ver si está bien??? tengo dudas existenciales de como le explico al ccs que vref es el duty, sobretodo nomenclatura de ccs que haya puesto mal. Gracias

Código: C

1. void algoritmo()
2. {
3. // COMIENZO
4. lecturaV = read_adc();    
5. lecturaI = read_adc();
6. V1 = lecturaV;
7. I1 = lecturaI;
8.  
9. while(TRUE)
10.         {
11.         lecturaV = read_adc();
12.         lecturaI = read_adc();
13.         V2 = lecturaV;
14.         I2 = lecturaI;
15.  
16.         V2 = V1 + 1;    /// Medida: V(t2) e I(t2)
17.         I2 = I1 + 1;
18.         dV = V(t2) - V(t1);
19.         dI = I(t2) - I(t1);
20.         if(dV == 0)
21.                 {
22.                 if(dI != 0)
23.                         {
24.                         if(dI/dV > -(I/V))
25.                                 {
26.                                 Vref(t3) = Vref(t2) + C;
27.                                 }
28.                         else
29.                                 {
30.                                 Vref(t3) = Vref(t2) - C;
31.                                 }
32.                         }
33.                 }
34.                 else
35.                 {
36.                 if(dI/dV != -(I/V))
37.                                 {
38.                                 if(dI/dV > -(I/V))
39.                                         {
40.                                         Vref(t3) = Vref(t2) + C;
41.                                         }
42.                                 else   
43.                                         {
44.                                         Vref(t3) = Vref(t2) - C;
45.                                         }
46.                                 }
47.                 }
48.         }
49. }

[Modulay]

Deberías poner un esquema.
El pic lleva varios canales de conversión AD,y dependiendo de cómo conectes para hacer mediciones,hay que hacer las lecturas de una forma u otra.

[mue]

Adjunto el esquema, no se si es lo que me pides, pero las lecturas son por separado, en la entrada del convertidor DC/DC hay unos sensores que miden tension y intensidad esto va a parar al Convertidor A/D del pic.

[Modulay]

Tendrías que hacer uso de 2 canales A/D,por ejemplo el 0 y el 1.
Dado que vas a ir alternando la lectura entre uno y otro,precediendo a cada lectura,tienes que añadir una instrucción para seleccionar el canal en cuestión:

set_adc_channel(0);
valor1 = read_adc();
...
...
set_adc_channel(1);
valor2 = read_adc();

El pic lleva un módulo hardware generador de pwm y ccs lleva unas instrucciones específicas para su manejo,entre ellas la variación del duty.
Te aconsejo que busques ejemplos,en este foro los hay a montones.

Puedes empezar por aquí

http://www.todopic.com.ar/foros/index.php?topic=4530.0

[mue]

Gracias por tu tiempo, me lo miraré y cuando lo tenga terminado lo volveré a colgar para posibles correcciones, opiniones o por si alguien quiere hacerle un buen uso.

Gracias de nuevo.

[mue]

Como ves he cambiado de diagrama de flujo y de algoritmo este nuevo metodo lo veo mas facil y eficaz, cuelgo los dos archivos. Me podrias decir si esta bien el algoritmo o si ves que le falta algo, tengo una duda con V= Vk y I= Ik del final del diagrama de flujos, tengo que ponerlo tantas veces??

Gracias por tu tiempo,

Código: C

1. void algoritmo()
2. {
3.  
4. // COMIENZO
5. // Lecturas
6.  
7.  
8. while(TRUE)
9.         {
10.         set_adc_channel(0);
11.         Vk = read_adc();            // Vk e Ik son el valor actual
12.        
13.         set_adc_channel(1)
14.         Ik = read_adc();
15.  
16.         dV = Vk - V;                // V e I son el valor anterior     
17.         dI = I - I;
18.  
19.         if(dV == 0)
20.                 {
21.                
22.                 if(dI != 0)
23.                         {
24.                        
25.                         if(dI > 0)
26.                                 {
27.                                
28.                                 D = D + dx;
29.                         //      V = Vk;      No se si hace falta repetir esto,
30.                         //      I = Ik;      o se puede poner solo una vez al
31.                                              final del algoritmo       
32.                                 }
33.                         else
34.                                 {
35.                                
36.                                 D = D - dx;
37.                         //      V = Vk;
38.                         //      I = Ik;
39.                                
40.                                 }
41.                        
42.                         }
43.                 else
44.                         {
45.  
46.                         V = Vk;
47.                         I = Ik;
48.  
49.                         }
50.                
51.         else
52.                 {
53.  
54.                 if(dI/dV != -(Ik/Vk))
55.                         {
56.  
57.                         if(dI/dV > -(Ik/Vk))
58.                                 {
59.                        
60.                                 D = D + dx;
61.                         //      V = Vk;
62.                         //      I = Ik;
63.                        
64.                                 }
65.                         else   
66.                                 {
67.  
68.                                 D = D + dx;
69.                         //      V = Vk;
70.                         //      I = Ik;
71.  
72.                                 }
73.  
74.                         }
75.                 else
76.                         {
77.  
78.                         V = Vk;
79.                         I = Ik;
80.  
81.                         }
82.  
83.                 }
84.  
85.         }
86.  
87. }

[Modulay]

Te corrijo un despiste que tuviste.
La renovación del valor anterior basta con que la hagas una vez al final,ya que no atiende a condiciones...se hace siempre.

Código: C++

1. void algoritmo()
2.   {
3.  
4.   // COMIENZO
5.   // Lecturas
6.  
7.   while(TRUE)
8.     {
9.     set_adc_channel(0);    
10.     Vk = read_adc();            // Vk e Ik son el valor actual
11.     set_adc_channel(1)
12.     Ik = read_adc();
13.     dV = Vk - V;    // V e I son el valor anterior
14.     dI = I - I;
15.     if(dV == 0)
16.       {
17.       if(dI != 0)
18.         {
19.           if(dI > 0)
20.           {
21.             D = D + dx;
22.           }
23.           else
24.           {
25.             D = D - dx;
26.           }
27.         }
28.       else
29.       {
30.         if(dI/dV != -(Ik/Vk))
31.         {
32.           if(dI/dV > -(Ik/Vk))
33.           {
34.             D = D - dx;  // Tenías puesto D = D + dx
35.            }
36.           else
37.           {
38.             D = D + dx;        
39.            }
40.          }
41.        }
42.        V = Vk;
43.        I = Ik;
44.      }
45.   }

Si no recuerdo mal,cuando se cambia de canal para proceder a la lectura, antes de efectuar la lectura hay que introducir un retardo para que la lectura se haga de forma correcta.Compruébalo en el datasheet o busca por el foro, que ya se trató el tema con anterioridad.
Por el resto,lo veo bien.

[firepic]

Saludos! 
Lo del retardo es del todo cierto... generalmente se usa entre 20us y 50us... yo uso 50us para estar seguro de que las condiciones están dadas para la siguiente conversión...
Entonces puedes agregar un delay_us(50) después de la primera conversión y justo antes de cambiarte de canal.
Ok nos leemos!