Resultados 1 al 25 de 315
- 23/03/2016, 14:27 #1el_cobarde Invitado
Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Carlos6025 ha ingeniado su Carlotrón V3.1, un sistema para derivar excedentes muy capaz. Hay un blog y un hilo dedicados al tema.
Me interesa mucho poder derivar excedentes, pero no tengo regulador con salida dedicada a excedentes, por lo que no me sirve el Carlotrón.
El Carlotrón en base a Arduino me ha inspirado en desarollar un sistema para derivar excedentes muy parecido a lo que hace el Carlotrón, pero con dos diferencias esenciales:
- No necesita regulador especial, funciona en base a intensidad y tensión del campo FV
- No necesita cableado entre inversor y "termo", comunica mediante WiFi (es que ya no me cabían más cables)
Hasta ahora mi proyecto se discutía en el hilo del Carlotrón, pero como va tomando forma, se merece su propio hilo, que estoy abriendo en este momento.
El que quiera participar en el proyecto, será bienvenido.
La base del concepto es un algoritmo que define la cantidad de excedentes disponibles en base a la potencia P = I * U que genera el campo FV en cada momento, siendo I la intensidad y U la tensión del campo FV.
El algoritmo es este:
. U_actual = 0
. I_actual = 0
. Incremento = const (p.e. 50W)
. PWM = 0
. Potencia_anterior = 0
Comienza el bucle
. if (PWM < 0)
. PWM = 0
. endif
. U_actual = Lee U_campoFV
. I_actual = Lee I_campoFV
. Potencia_actual = U_actual x I_actual
. if (Potencia_actual <> Potencia_anterior)
. PWM = PWM + Incremento
. else
. PWM = PWM - Incremento
. PWM = PWM - Incremento
. PWM = PWM - Incremento
. endif
. Potencia_anterior = Potencia_actual
Vuelta al principio del bucle
- - - - - - - - - - - - - - - - - - -
Breve explicación:
Para empezar, el Arduino incrementa la señal PWM un poquito (50W en el ejemplo). Si la potencia FV no le sigue, lo intenta otra vez. Si ve que la potencia FV le sigue, continúa incrementando hasta llegar a un estado de equilibrio.
En estado de equilibrio (cuando se aprovechan todos los excedentes), el Arduino da un paso adelante (incrementa la señal PWM). Si ve que la potencia FV no le sigue, da tres pasos atrás, es decir, decrementa 3 veces la señal PWM. La potencia FV se adapta a este nuevo valor. Otra vez el Arduino da un paso adelante. Si la potencia FV le sigue, da otro paso adelante. Si la potencia FV no le sigue, vuelve a dar tres pasos atrás. Asi sucesivamente, siempre intentando aprovechar todos los excedentes, pero sin pasarse. Con el "truco" de tres pasos atrás se consigue un decremente de la señal PWM, cuando éste sea necesario. Si se desea un decremento más rapido, basta programar 4 o 5 pasos atrás, en vez de tres.
- Si la potencia FV aumenta, el Arduino sigue incrementando la señal PWM
- Si la potencia FV disminuye, el Arduino va decrementando la señal PWM, comprobando en cada paso si la potencia FV se estabiliza
- Si la potencia FV no cambia, el Arduino incrementa la señal PWM, para comprobar la estabilidad
De esta forma, el Arduino busca y encuentra rápidamente cualquier estado de equilibrio nuevo, tanto si éste está a una potencia FV más alta como más baja.
- - - - - - - - - - - - - - - - - - - - - -
El concepto actual del proyecto es:
Un Arduino UNO para medir I y U del campo FV, aplicar el algoritmo de los excedentes y calcular los excedentes disponibles. Este valor analógico (en tanto por ciento) se pasaria a una placa WeMos (la placa WeMos es como un Arduino con WiFi, pero con sólo un pin analógico), que comunicaría por WiFi con otras placas WeMos, conectadas a los módulos de potencia. Las WeMos receptoras generarían la señal PWM y la pasarían a su respectivo módulo de potencia.
De esta forma el concepto quedaría en:
- Master: Arduino UNO + placa WeMos (emisora WiFi)
- Slave (uno para cada "termo"): Placa WeMos (receptora WiFi) + módulo de potencia KEMO
Una idea alternativa sería no medir la tensión FV, con lo que se necesitaría sólo una entrada analógica para la intensidad FV.
Cuando hay excedentes, el campo FV trabaja en su MPP y la tensión estará muy cerca de 92V (en mi caso). Podría definir la tensión FV como una constante de 92V, y medir sólo la intensidad FV. La potencia FV sería I*92V. El error sería <5%, supongo.
Con este "truco" me bastaría una placa WeMos para el Master, o sea, todo sería WeMos.
.Última edición por el_cobarde; 23/03/2016 a las 21:54 Razón: mejorar título
-
- 23/03/2016, 18:00 #2Forero
- Fecha de ingreso
- nov 2014
- Ubicación
- cartagena
- Mensajes
- 298
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
estoy interesado, pero para serte sincero no me entero de nada de electrónica ni con este ni con el otro...
yo si lo probáis y funciona bien os compro uno....
como modula la potencia de la resistencia del termo de 50 en 50w??
(sigo esperando que me llege el rele de voltaje y derivare excendentes con una potencia fija al termo fijándome en un determinado voltaje alto para que no chupe de baterías) es lo mas fácil que podido comprender hasta ahora.
estare atento pos si se aclara algo, suerte en tu proyecto.actualmente 1080watios.
4 placas de 270w en series de dos. hibrido mppt 24v. 6 baterías de 12v en serie paralelo.
- 23/03/2016, 21:56 #3el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Hace poco estaba como tú, pero me dí cuenta que una derivación bien hecha no es mucho más complicada, pero si mucho más eficaz. Es que derivando una potencia fija, o ciclas la batería o desperdicias mucha potencia FV.
Muy fácil. Gracias al algoritmo, en cada momento el Arduino tiene un valor PWM (digamos en watios) para enviar al módulo de potencia. Simplemente tiene que sumar el valor 50W a este valor, para incrementar un paso - y después observar como reacciona el campo FV, para saber si seguir incrementando o decrementar.
Claro que el Arduino no mide watios reales, pero sí un valor proporcional a éstos. Basta multiplicar este valor proporcional por una constante, para obtener watios reales.
Cambiando el valor del incremento, por ejemplo a 20W o a 80W, se puede hilar más o menos fino los pasos de incrementar. Será cuestión de hacer pruebas, para saber qué valor de incremento es el óptimo.
- 25/03/2016, 11:11 #4el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Me he dado cuenta que el algoritmo necesitaba mejorar un poco.
El algoritmo mejorado es este (cambios en negrilla):
. U_actual = 0
. I_actual = 0
. Incremento = const (p.e. 50W)
. PWM = 0
. Potencia_anterior = 0
COMIENZA EL BUCLE
. if (PWM < 0)
. PWM = 0
. endif
. U_actual = Lee U_campoFV
. I_actual = Lee I_campoFV
. Potencia_actual = U_actual x I_actual
. if ((Potencia_actual - Potencia_anterior) > incremento*0.8)
. PWM = PWM + Incremento
. else
. PWM = PWM - Incremento
. PWM = PWM - Incremento
. PWM = PWM - Incremento
. endif
. Potencia_anterior = Potencia_actual
VUELTA AL PRINCIPIO DEL BUCLE
- - - - - - - - - - - - - - - - - - - -
El cambio que he hecho es el siguiente:
La condición anterior rezaba: if (Potencia_actual <> Potencia_anterior)
Esto significaba, que el Arduino incrementaba PWM, siempre cuando la potencia FV cambiaba, tanto a más como a menos. Esto no era correcto. Sólo hay que incrementar PWM, si la potencia FV aumenta.
Otro problema era, que la negación de esta condición, o sea "Potencia_actual = Potencia_anterior" (el "else"), era muy exigente. Con cualquier fluctuación en la potencia FV, por pequeña que fuera, ya se cumplía la condición original y el Arduino incrementaba PWM.
La condición mejorada es: if ((Potencia_actual - Potencia_anterior) > incremento*0.8)
Con esta condición, el Arduino incrementa PWM sólamente, si la potencia FV aumenta por lo menos en un 80% del incremento. En todos los demás casos decrementa PWM. Esta condición parece funcionar en cualquier situación.
Es que hay que tener en cuenta, que la producción FV no sólo depende de lo que mande el Arduino, también (y más) depende de la irradiación solar y del consumo, que pueden variar mucho.
- 26/03/2016, 16:21 #5el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Desde ayer tengo mi primer Arduino UNO! Lo compré en eBay.es, para jugar, practicar y aprender. Todos los demás componentes los pedí en AliExpress y tardarán en llegar.
Os digo que el Arduino es una pasada! Muy versátil y fácil de programar. Estoy disfrutando como un cosaco con él!
Después de haber dado los primeros pasos, jugando con el LED incorporado e intercambiando datos con el PC por USB, ya he podido programar la primera versión del algoritmo para derivar excedentes. Es una simulación donde se entra la potencia FV actual con el teclado del PC y el Arduino dice la potencia PWM que genera. Funciona de maravilla!
Para adaptar el algoritmo que tenía publicado a la simulación, he hecho unas cuantas modificaciones:
- La condición "if ((Potencia_actual - Potencia_anterior) > incremento*0.8)" la he cambiado por
"if ((Potencia_actual - PWM) > incremento*0.8)"
- En la simulacion no es necesario dar 3 pasos atrás, basta uno
Además, me he dado cuenta de una mejora, con la que se aprovechan mejor los excedentes
- he sustituido {... > incremento * 0.8} por {... > incremento * 0.5}
- - - - - - - - - - - - - - - - - -
Para todos los que tengan un Arduino y quieran jugar un poco con la simulación, os la dejo aqui (para IDE):
//
int power = 0; //potencia FV (W)
int increment = 50; //incremento PWM (W)
int PWM = 0; //potencia PWM (W)
//
void setup()
{
Serial.begin(9600);
}
void loop()
//principio del bucle
{
char buffer[] = {' ',' ',' ',' '}; // Potencia FV (0-9999W)
while (!Serial.available()); // Espera input
Serial.readBytesUntil('n', buffer, 4);
int power = atoi(buffer);
Serial.print("potencia FV = ");
Serial.println(power);
//
if ((power - PWM) > int(increment / 2))
{PWM = PWM + increment;}
else
{PWM = PWM - increment;}
//
if (PWM < 0) {PWM = 0;}
//
Serial.print("PWM = ");
Serial.println(PWM);
}
//final del bucle
Basta cargar el código en el Arduino conectado al PC y a experimentar ...
- 26/03/2016, 19:28 #6Forero
- Fecha de ingreso
- ago 2010
- Ubicación
- alicante
- Mensajes
- 5.317
- Entradas de blog
- 2
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Ya veo que la maquinaria se ha puesto en marcha....
- 26/03/2016, 22:37 #7el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Evidentemente, y el maquinista disfruta un montón ...
El Arduino es sencillamente genial; es el instrumento ideal para sacar el máximo provecho de una planta FV.
He seguido "jugando" con el UNO y os dejo mi segunda versión de la simulación de excedentes, que ya se acerca bastante a lo que será la realidad.
En esta versión, el valor que tecleáis, es la potencia máxima FV, o sea, lo máximo que se puede derivar en excedentes en este momento. Veréis como el Arduino se va acercando a este máximo, incrementando (y decrementando) su PWM.
//
int power = 0; //potencia FV (Watt)
int increment = 50; //incremento PWM (Watt)
int PWM = 0; //potencia PWM (Watt)
int power_max = 0; //excedentes (Watt)
//
void setup()
{Serial.begin(9600);}
//
void loop()
//principio del bucle
{
//Introducir power_max (0 - 9999 Watt)
char buffer[] = {' ',' ',' ',' '}; // Excedentes max
while (!Serial.available()); // Esperando input
Serial.readBytesUntil('n', buffer, 4);
int power_max = atoi(buffer);
Serial.print("potencia FV max = ");
Serial.println(power_max);
//
PWM = PWM + increment;
power = power + increment;
if (power > power_max){power = power_max;}
//
if (power < (PWM - int(increment / 8)))
{PWM = PWM - increment - increment;}
//
if (PWM < 0) {PWM = 0;}
if (power < 0) {power = 0;}
//
Serial.print("PWM = ");
Serial.println(PWM);
Serial.print("potencia actual = ");
Serial.println(power);
}
//final del bucle
- 27/03/2016, 22:26 #8el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Como último ejemplo, antes de irme para 6 días de viaje, os dejo una simulación que ya es muy real.
Genera una producción FV aleatoria entre 0 y 3600W, con cambios aleatorios de hasta +/-300W. Espera 16 ciclos del bucle, antes de generar un nuevo valor FV aleatorio.
No hay que introducir ningún valor. Significado de los valores que nos da:
- "Excedentes" es la potencia disponible acumulada (en kW)
- "PWM_total" es la potencia derivada acumuladoa (en kW)
- "De batería" es la potencia chupada de batería, acumulada (en kW)
La simulación nos dice que el algoritmo aprovecha un 99.5% de los excedentes y sólo cicla un 0.1% por batería.
//
int power = 0; //potencia FV (Watt)
int increment = 50; //incremento PWM (Watt)
int PWM = 0; //potencia PWM (Watt)
int power_max = 0; //excedentes (Watt)
int power_old = 0; //potencia FV anterior
long power_sum = 0; //excedentes acumulados
long PWM_sum = 0; //potencia PWM acumulada
long batt = 0; //chupado de batería
int index = 0; //indice para aleatorio
//
void setup()
{Serial.begin(9600);}
//
void loop()
//principio del bucle
{
//Genera power_max al hazar (random)
index = ++index;
if(index > 14)
{
index = 0;
randomSeed(millis());
power_max = power_max + random(320);
randomSeed(PWM);
power_max = power_max - random(300);
if(power_max < 100) {power_max = 900;}
if(power_max > 3600) {power_max = 1200;}
} //endif
//
//Introducir power_max (0 - 9999 Watt)
// char buffer[] = {' ',' ',' ',' '}; // Excedentes max
// while (!Serial.available()); // Esperando input
// Serial.readBytesUntil('n', buffer, 4);
// int power_max = atoi(buffer);
Serial.print("potencia FV max = ");
Serial.println(power_max);
power_sum = power_sum + power_max;
//
PWM = PWM + increment;
power = power + increment;
if (power > power_max){power = power_max;}
//
if (power < (PWM - int(increment / 8)))
{PWM = PWM - increment - increment;}
//
if (abs(power_old - power) < int(increment/5)) {PWM = power;}
if (PWM < 0) {PWM = 0;}
if (power < 0) {power = 0;}
power_old = power;
//
Serial.print("PWM = ");
Serial.println(PWM);
if(PWM > power_max) {batt = batt + PWM - power_max;}
PWM_sum = PWM_sum + PWM;
Serial.print("Excedentes = ");
Serial.println(int(power_sum / 1000));
Serial.print("PWM_total = ");
Serial.println(int(PWM_sum / 1000));
Serial.print("De bateria = ");
Serial.println(int(batt / 1000));
Serial.println("");
// Serial.print("potencia actual = ");
// Serial.println(power);
// delay(3000);
}
//final del bucle
- 05/04/2016, 14:33 #9el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Bueno, he estado una semana fuera sin Arduino. Ahora he vuelto y he podido seguir jugando con él.
Como veo que los ejemplos de simulación que pongo no tienen gran resonancia, no pondré más (también se están haciendo más largos), pero sí os voy a contar como me va la cosa.
Pues me va de perlas! De momento solo puedo hacer simulaciones, porque solo tengo un Arduino UNO "desnudo" para hacer pruebas. Los sensores y demás componentes que he pedido aún tardarán en llegar. Pero con las pruebas ya aprendo mucho! Ahora mismo tengo una simulación en marcha, que es muy real. Y el Arduino cumple perfectamente!
Los resultados los veo en la pantalla del PC conectado al Arduino.
- La simulación crea potencia FV entre 0 y 3600W. Esto son los excedentes que hay en cada momento
- La potencia FV se mantiene sin cambiar durante 15 ciclos del bucle; en el ciclo 16 viene el cambio aleatorio
- Estos cambios aleatorios son incrementos/decrementos de +/- 0W hasta 600W (al hazar)
- Con esto se simula los cambios reales en excedentes, debidos a variación de irradiación solar y consumo
El Arduino reacciona muy rápido y muy correcto:
- Cuando la potencia FV baja de repente (paso de nube), PWM se adapta en solo dos ciclos de bucle
- Igual solo necesita dos ciclos para reducir PWM a cero, cuando de repente no hay excedentes
- Cuando la potencia FV sube de repente (tras el paso de nube), PWM incrementa en 50W con cada ciclo
- Cuando hay variaciones menores en la potencia FV, PWM incrementa / decrementa como debe
- El Arduino aprovecha casi todos los excedentes. Un ejemplo: De 28970Wh aprovecha 28678Wh (un 98.9%)
- El Arduino chupa muy poco de batería. En el ejemplo anterior 102Wh (un 0.35%)
- Esto significa que "PWM < excedentes" solo es para poco tiempo y "PWM > excedentes" para muy poco tiempo
- Con la simulación en marcha durante varias horas, no ha habido ni un sólo error
- 05/04/2016, 19:23 #10Forero
- Fecha de ingreso
- may 2015
- Ubicación
- cartaya
- Mensajes
- 2.151
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
por mucho que trabaje el "chino" automatizar un proceso es un vicio que engancha y como siempre quieres sacarle mas tajada al final trabajas tu mas que el "chino". Cuando se alcanza un resultado razonable debes plantearte darlo por optimizado e implantarlo definitivamente.
- 05/04/2016, 19:33 #11el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
100% de acuerdo, solflitos. Esto de "jugar" con el Arduino es un vicio terrible ...
Lamentablemente, en este momento no puedo hacer más que "optimizar" - estoy a la espera de que me lleguen los componentes. En cuanto los tenga, en seguida los implantaré y veremos, como se comporta el "invento" en la práctica.
- 05/04/2016, 21:33 #12Forero
- Fecha de ingreso
- feb 2009
- Ubicación
- xxx
- Mensajes
- 1.732
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Ínimo, que el tema va por muy buen camino
- 05/04/2016, 22:19 #13el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Gracias. Voy muy animado! Y saldrá bien, la cosa.
- 06/04/2016, 02:41 #14Forero
- Fecha de ingreso
- ene 2016
- Ubicación
- españa
- Mensajes
- 82
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Hola
Me interesa mucho el tema , aunque de programación solo un poco de clíper. Dime por favor si hay algún emulador de Arduino para ir aprendiendo.
saludos
- 06/04/2016, 08:32 #15el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Supongo que lo habrá, pero no lo conozco.
Te recomiendo comprar un Arduino UNO (menos de 4 euros en AliExpress) y aprender con él. Así lo estoy haciendo yo. No es emulación, es Arduino original - siempre mejor que emulación.
Puedes cargar directamente los ejemplos que he colgado y te funcionarán.
- 06/04/2016, 09:44 #16Forero
- Fecha de ingreso
- ene 2016
- Ubicación
- No lo preguntes miarma!
- Mensajes
- 215
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Una duda, la toma de datos (V e I) es desde el campo fotovoltaico, a partir de eso:
- Podrías mencionar o poner un enlace de los componentes que vas a utilizar para hacer ambas mediciones?
- No tengo claro si las mediciones van a ser de todos los strings y sacando luego un promedio, sólo de algunos o de un string por cada regulador?
Un saludo.
- 06/04/2016, 11:27 #17el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Estos detalles los había discutido antes de abrir este hilo, en el hilo del Carlotrón.
Pienso medir tanto I como U con sensores Hall, que son optoacoplados.
- el sensor de corriente es este
- el sensor de tensión es este
He pensado en las dos opciones. Finalmente he decidido medir I en todos los strings (tres orientaciones y tres reguladores diferentes) - un sensor de intensidad para cada regulador. Sumando estas intensidades, obtendré la intensidad real del campo FV.
Para obtener U del campo FV, como sólo tengo un sensor de tensión, mediré la tensión de los strings en el regulador "Master" (los que dan más intensidad) como representativa para todo el campo FV.
Multiplicando estos dos valores, obtendré la potencia real del campo FV con bastante exactitud.
Un problemita es que los strings que van a uno de los reguladores auxiliares son de sólo 2 placas seriadas, mientras los demás strings son de 3 placas seriadas (todas la placas iguales, de 72 células). Este regulador auxiliar es PWM, mientras los otros dos son MPPT. La intensidad en el regulador PWM no se puede sumar directamente a la de los MPPT.
- Para obtener la potencia real del regulador PWM, multiplicaré I * 50V (tensión media de batería)
- Para obtener la potencia real de los reguladores MPPT, multiplicaré I * U * 0.96 (eficiencia del regulador MPPT)
Posiblemente la tensión media de la batería sea más bien 53V y la eficiencia de un MPPT más bien 0.98. Con los valores más bajos me curo en salud; perderé una pizca de los excedentes, pero evitaré chupar de batería.
Otra opción sería no medir la tensión y suponer 95V fijos para los strings en regulador MPPT y 50V fijos para los strings en regulador PWM. La tensión real podría ser mayor en algún momento, pero nunca menor (habiendo excedentes).
Qué opción os parece mejor? La segunda sería más sencilla de instalar ...
- 06/04/2016, 13:26 #18Forero
- Fecha de ingreso
- ene 2016
- Ubicación
- No lo preguntes miarma!
- Mensajes
- 215
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
- 06/04/2016, 13:59 #19el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Me parece buena idea, hacerlo de esta forma. Paso a paso ...
- - - - - - - - - - - - - - - - -
Acabo de hacer una prueba de velocidad con el Arduino y resulta ser verdaderamente rápido.
Un ciclo de crear los excedentes del momento (lo que en realidad hace la FV), averiguar si hay excedentes y generar la señal PWM correspondiente dura 0,042ms, es decir, 42 microsegundos. El Arduino realiza 24000 ciclos en cada segundo!
Como ya habíamos dicho, tendré que frenar un poco al Arduino. Pienso que algo entre 10ms y 100ms para realizar un ciclo estaría bien; depende de lo rápido que reacciona el regulador.
- 06/04/2016, 20:37 #20el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Hola carlos6025
Hace unas semanas me avisaste (en el hilo del Carlotrón) que los módulos de potencia KEMO tienen una "barrera baja" y una "barrera alta":
Es decir, potencia menor que la "barrera baja" es ignorada por el KEMO y potencia mayor que la "barrera alta" es convertida en potencia máxima del termo (256 escalones).
Ejemplo numérico: Pongamos que la barrera baja sea 25 escalones (de 256 en total que tiene la señal PWM) y la barrera alta sea (256-25) = 231 escalones. En este caso, el KEMO M150 sólo acepta PWM > 25 escalones y da "full power" a partir de 231 escalones.
Cómo programo al Arduino para optimizar esta característica del KEMO?
He pensado aceptar la barrera baja del termo no.1, de forma que éste empieza a consumir a partir de que haya 25 escalones de excedentes. Con esto se pierden los excedentes, si éstos no llegan a 25 escalones.
Cuando los excedentes superan 231 escalones, el KEMO abre y el termo no.1 consume 256 escalones - si los hay. Si esto es el caso, reduzco la señal PWM a digamos 200 escalones y aplico los (256-200) = 56 escalones (máximo) al termo no.2 - de esta forma aprovecho todos los excedentes. Si hay más excedentes, el termo no.2 va consumiendo más, hasta sobrepasar los 231 escalones. En esta situación hago el mismo traspaso de escalones del termo no.2 al termo no.3 y así sucesivamente.
Te parece bueno este algoritmo o tienes una idea mejor?
He dirigido esta pregunta a carlos6025, porque es el "Rey del Carlotrón". Si me contesta otro forero, yo tan agradecido ...
- 06/04/2016, 21:22 #21Forero
- Fecha de ingreso
- ago 2010
- Ubicación
- alicante
- Mensajes
- 5.317
- Entradas de blog
- 2
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Correcto.
No, no se pierden excedentes.
Lo veo complicado, pudiendo ser más sencillo.
Tienes que crear unas variables donde almacenas los valores mínimos y máximos de PWM de cada KEMO. Por eso hay que calibrar los kemo antes de nada. Y esos valores ya no cambian.
Cuando el programa decide empezar a enviar señal PWM al termo X, no debe empezar por PWM 0, sino por el valor PWM mínimo que tienes guardado en la variable correspondiente. EN ese momento, al termo X le llega 0,1% de potencia.
Cuando está llegando al máximo, el valor PWM no debe ser 255, sino el valor máximo que tienes guardado en la variable correspondiente. En ese momento, al termo X le llega 100% de potencia.
A partir de ahí, haces PWM al siguiente termo, pero empezando, NO por PWM 0, sino por el valor que corresponda a ese 2º KEMO.
Por ejemplo:
- KEMO nº 1. Empieza a derivar potencia (0,1%) al termo1 a partir de PWM 25. Y da full power (100%) con PWM 250.
- KEMO nº 2. Empieza a derivar potencia (0,1%) al termo2 a partir de PWM 32. Y da full power (100%) con PWM 246.
- Inicio variables:
* Var_inicio_kemo1=25 (mejor 24, por seguridad)
* Var_fin_kemo1=250 (mejor 251, por seguridad)
* Var_inicio_kemo2=32 (mejor 31)
* Var_fin_kemo2=246 (mejor 247)
El programa empieza a derivar potencia, porque hay excedentes, con el termo1:
* empiezo a sacar PWM(pin_kemo1) de valor (Var_inicio_kemo1)
*...
*...
*...
* termino sacando PWM(pin_kemo1) de valor (Var_fin_kemo1), y lo mantengo.
* continuo, empezando a sacar PWM(pin_kemo2) de valor (Var_inicio_kemo2)
*...
*...
*...
* termino sacando PWM(pin_kemo2) de valor (Var_fin_kemo1) y lo mantengo
*...
*...
*...
* y así hasta el PWM(pin_kemoN) de valor (Var_fin_kemoN)
Creo que se entiende bien.
- 06/04/2016, 22:54 #22el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Muchas gracias por contestar tan extensamente, Carlos.
Me parece que decimos (casi) lo mismo, con palabras diferentes.
- Cuando los excedentes están por debajo de la "barrera baja" del KEMO1 ("Var_inicio_kemo1" con tu nomenclatura), no se pueden derivar los excedentes, porque el KEMO1 no abre. Estos excedentes se pierden. O me equivoco?
- Cuando los excedentes superan el valor "Var_inicio_kemo1", se derivan todos, sin pérdidas
- Cuando los excedentes superan la "barrera alta" del KEMO1 ("Var_fin_kemo1" con tu nomenclatura), se empieza a derivar al segundo termo. Esto lo hacemos igual los dos
- Si los excedentes están entre "Var_fin_kemo1" y "Var_fin_kemo1 + Var_inicio_kemo2", se pierden los excedentes que están entre estos límites, porque el KEMO2 no abre. Se empieza a derivar al KEMO2, en cuanto los excedentes superan el valor "Var_fin_kemo1 + Var_inicio_kemo2"
- En tu ejemplo numérico se pierden los excedentes menores de 25 (pérdida inevitable) y los que están entre 250 y 282. KEMO2 no abre hasta que los excedentes superen el valor (250+32) = 282
- Esta última pérdida la quiero evitar, reduciendo la potencia derivada al KEMO1 a (250-32) = 228. De esta forma, al superar los excedentes el valor 250 (250 + X), "salto" la barrera baja del segundo KEMO y derivo 228 al KEMO1 (mantenidos) y (32 + X) al KEMO2 (variable). Al bajar los excedentes de (228+32) tengo que derivarlos todos al KEMO1
- La misma lógica para los KEMO3, KEMO4 ... KEMO"n"
Es un poco complicado para explicar con palabras, pero estoy seguro que lo entenderás ...
- 06/04/2016, 22:58 #23Forero
- Fecha de ingreso
- ago 2010
- Ubicación
- alicante
- Mensajes
- 5.317
- Entradas de blog
- 2
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Correcto. El programa, en ningún momento debe hacer PWM<Var_inicio_kemo1. No tiene que "perder el tiempo" en ello.
Correcto. El PWM no debe ir más allá de Var_fin_kemo1. Debe pasar directamente desde Var_fin_kemo1 --> Var_inicio_kemo2.
Que no se pierden, EL_COBARDE.
Cuando empieza a derivar, no empieza con PWM 0, empieza con PWM 25, "de golpe".
Cuando llega a 250, el siguiente paso es PWM 32 al 2º termo. No hay tiempo perdido entre 250 y 32, por eso no puede haber pérdida, ni de excedentes ni de tiempo. Para el programa, desde PWM 25 hasta PWM 246 del 2º termo, hay ((250-24)+(246-31)) = 441 escalones. No hay (256+256) = 512 escalones. EL resto (512-441) = 71 escalones, simplemente NO EXISTEN.
- 07/04/2016, 00:18 #24el_cobarde Invitado
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Ahora entiendo tu lógica. Es fácil y buena.
Parece que lo que no había entendido, es el funcionamiento del KEMO, en concreto la barrera baja (Var_inicio_kemo"n").
En el ejemplo numérico, Var_inicio_kemo1 = 25.
Yo pensaba, que cuando PWM = 26, el KEMO1 de repente dejaba pasar 26 escalones de excedentes.
La realidad es, que con PWM = 26, el KEMO solo deja pasar 1 escalón de excedentes (26 - 25).
Se trata de un simple offset del KEMO en empezar a abrir su puerta. Lo mismo es cierto para la barrera alta.
O sea: El KEMO1 no trabaja desde 0 hasta 256 escalones, sino trabaja desde 25 hasta 250 escalones (225 escalones).
Por ser menos escalones, son menos finos, pero esto no es grave. Lo importante es que no se pierden excedentes.
Muchas gracias por ayudarme en entender esto! Facilita mucho la programación!
- 07/04/2016, 00:30 #25Forero
- Fecha de ingreso
- ago 2010
- Ubicación
- alicante
- Mensajes
- 5.317
- Entradas de blog
- 2
Re: Derivar excedentes con cualquier regulador MPPT, usando Arduino y WiFi
Exacto. A efectos prácticos, la potencia a regular se divide en menos partes, PERO siempre empieza desde 0W, y siempre termina en el 100% de los vatios posibles, según la potencia nominal del termo.
Aunque, en realidad, no es exactamente así tampoco. Pero eso ya te lo digo mañana, que ya es tarde.
De nada.