Tema: 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.


.

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.

Iniciado por pedro 3232

... 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 ...

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.

Iniciado por pedro 3232

... como modula la potencia de la resistencia del termo de 50 en 50w??

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.

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.

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 ...

Ya veo que la maquinaria se ha puesto en marcha....

Iniciado por carlos6025

Ya veo que la maquinaria se ha puesto en marcha....

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

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

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

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.

Iniciado por solflitos

Cuando se alcanza un resultado razonable debes plantearte darlo por optimizado e implantarlo definitivamente.

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.

Ínimo, que el tema va por muy buen camino

Gracias. Voy muy animado! Y saldrá bien, la cosa.

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

Iniciado por espiga02

Dime por favor si hay algún emulador de Arduino para ir aprendiendo.

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.

Iniciado por el_cobarde

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.


.

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.

Iniciado por eseperao

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?

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

Iniciado por eseperao

- 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?

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 ...

Iniciado por el_cobarde

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 ...

Personalmente implantaría primero la más sencilla, sin sensor de voltaje, tendría un tiempo haciendo funcionar los excedentes y contabilizando éstos, después añadiría el sensor de corriente y comparar ambos excedentes.

Un saludo.

Iniciado por eseperao

Personalmente implantaría primero la más sencilla, sin sensor de voltaje, tendría un tiempo haciendo funcionar los excedentes y contabilizando éstos, después añadiría el sensor de corriente y comparar ambos excedentes.

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.

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":

Iniciado por carlos6025

La señal PWM ataca al módulo de potencia KEMO por la entrada PULSE. Pudiera ser (y de hecho lo es), que dicho módulo no sea capaz de modular "tan bajo" ni "tan alto". Es decir, que necesite una anchura de, por ejemplo 25, para empezar a entregar potencia a un termo. Y pudiera ser que a partir de una anchura de 210, ya derive toda la potencia posible. En ese caso nos quedaría disponible 210-25= 185 escalones para poder modular, que serían 2000W/185= 11W por escalón.

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 ...

Iniciado por el_cobarde

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.

Correcto.

Iniciado por el_cobarde

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

No, no se pierden excedentes.

Iniciado por el_cobarde

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?

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.

Iniciado por carlos6025

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.

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 ...

Iniciado por el_cobarde

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" ("Var_inicio_kemo1" con tu nomenclatura), no se pueden derivar los excedentes, porque el KEMO1 no abre. Se pierden. O me equivoco?

Correcto. El programa, en ningún momento debe hacer PWM<Var_inicio_kemo1. No tiene que "perder el tiempo" en ello.

Iniciado por el_cobarde

- Cuando los excedentes superan la "barrera alta" ("Var_fin_kemo1" con tu nomenclatura), se empieza a derivar al segundo termo. Esto lo hacemos igual los dos

Correcto. El PWM no debe ir más allá de Var_fin_kemo1. Debe pasar directamente desde Var_fin_kemo1 --> Var_inicio_kemo2.

Iniciado por el_cobarde

- Si los excedentes están entre "Var_fin_kemo1" y "Var_fin_kemo1 + Var_inicio_kemo2", se pierde algo de los excedentes, porque el KEMO2 no abre. Se empieza a derivar al KEMO2, cuando 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

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.

Iniciado por carlos6025

Que no se pierden, EL_COBARDE ... Cuando empieza a derivar, no empieza con PWM 0, empieza con PWM 25, "de golpe".
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.

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!

Iniciado por el_cobarde

Por ser menos escalones, son menos finos, pero esto no es grave. Lo importante es que no se pierden excedentes.

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.

Iniciado por el_cobarde

Muchas gracias por ayudarme en entender esto! Facilita mucho la programación!

De nada.