Tema: Carlotrón versión 3.0. Derivar excedentes con Arduino.

Iniciado por oxid

Y no hay que poner nada más ? No monitorizas tensión de batería, ni consumo AC ?

Si, tendré que pensar y decidir lo que necesito y hacer el listado. Gracias por ofrecer ayuda ...

Iniciado por oxid

Lo del mini panel no se aplica aquí ?

Con Arduino no se necesita mini-panel. Hemos desarollado la idea de usar los incrementos* de I y U del campo FV como entrada al Arduino, para que éste construya la señal PWM proporcional a la potencia en excedentes disponibles. Sólo se necesita un pequeño algoritmo con unos cuantos cálculos, nada de hardware adicional.
Este concepto es la que más me convence. Se explica con más detalle en posts anteriores de este mismo hilo. A partir del post #123, más o menos.

*incrementos: Por incremento entiendo la derivada. Es decir, si medimos U (lo mismo para I), en dos momentos seguidos T1 y T2, obtendremos los valores U1 y U2. Entonces el incremento de U es (U2-U1)/U1.
El algoritmo consiste en un bucle infinito, en el que el Arduino conecta un pequeño incremento de carga, p.e. 50W (esto el Arduino lo hace modificando su señal PWM) y observa los incrementos de I y U.
Los pasos básicos serán:
- Si I aumenta y U disminuye, el Arduino conecta otros 50W y vuelve a medir I y U (subiendo rampa al MPP)
- Si I aumenta y U no varía, el Arduino conecta otros 50W y vuelve a medir I y U (campo FV en su MPP)
- Si I no varía y U tampoco varía, el Arduino no hace nada y vuelve a medir I y U (todos los excedentes aprovechados)
- Si I no varía y U aumenta, el Arduino no hace nada y vuelve a medir I y U (MPP nuevo)
- Si I disminuye y U aumenta, el Arduino desconecta 50W de carga y vuelve a medir I y U (bajando rampa del MPP)
- Si I < 5A, el Arduino desconecta todas las cargas de excedentes y vuelve a medir I y U (está pasando una nube o el regulador ha desconectado los paneles o algo por el estilo)

Este algoritmo habrá que hacerlo más fino, teniendo en cuenta el rastreo del regulador y otros efectos secundarios, pero básicamente será esto.

Rectifico el esquema que puse anteriormente, pues evidentemente esta mal, no creo que el arduino consiga medir tensiones negativas en el shunt de corriente, siempre tropiezo con la misma piedra !!

Iniciado por oxid

Es buena práctica en las entradas analógicas, dependiendo de la impedancia de entrada del Arduino ( que no sé cual es ), poner una resistencia en serie ( 100R ?), y en el conector del Arduino un diodo por ejemplo tipo 1N4148 entre la entrada y los 5V, esto protege mucho las entradas analógicas.

Gracias por el esquema corregido, oxid.
Referente a la "buena práctica": Veo los diodos y la resistencia 100R en serie, pero no entiendo su finalidad. Me la explicas?

Demasiado complicado el algoritmo, a mi entender.
Para empezar y resumiendo, yo haría:


U_actual I_actual = 0
Potencia_anterior = 0
Comienza el bucle

. U_actual = Lee U_paneles
. I_actual = Lee I_paneles
. Potencia_actual = U_actual x I_actual

. if (Potencia_actual > Potencia_anterior)
. Aumento PWM
. else
. Disminuyo PWM
. termina endif
.
.
. Potencia_anterior = Potencia_actual

vuelvo al bucle

La idea principal es medir y comparar potencias, en vez de U o I por separado.

Iniciado por el_cobarde

Gracias por el esquema corregido, oxid.
Referente a la "buena práctica": Veo los diodos y la resistencia 100R en serie, pero no entiendo su finalidad. Me la explicas?

Es para proteger las entradas, según comentais en post anterior, no se le puede aplicar >5V a las entradas del arduino, el diodo deriva corriente al +5V, y la resistencia de 100R la limita. En el divisor de tensión la de 100R no haría falta, pues ya hay una resistencia serie equivalente resultado del divisor de tensión.

Iniciado por carlos6025

Demasiado complicado el algoritmo, a mi entender ... La idea principal es medir y comparar potencias, en vez de U o I por separado.

Me gusta mucho tu algoritmo, carlos6025. Es mucho más sencillo que el mío. Pero no veo que funcione.

La base es "aumentar PWM", es decir "incrementar la carga" y ver si sube (o baja) la potencia FV.
Hagamos un ejemplo: Pongamos que el consumo normal sea de 1000W y que haya 820W de excedentes. Pongamos que el incremento PWM sea de 50W.
El Arduino empieza con cero e incrementa la carga en 50W. Ve que la potencia FV aumenta (a 1050W) y vuelve a incrementar en 50W. Asi sucesivamente, hasta llegar a 1800W. Con el próximo incremento, la potencia FV sube solo a 1820W, porque no hay más potencia. Los 30W que faltan serán de batería. El Arduino hará un incremento más (70W de batería) y se dará cuenta de que ya no aumenta la potencia FV. En el próximo paso decrementará la carga en 50W. Como no hay cambio en la potencia que mide, volverá a decrementar la carga. Esta vez, la potencia FV disminuye, por lo que el Arduino volverá a decrementar la carga ...
Allí está el fallo: El Arduino decrementará la carga de excedentes hasta cero, dejando solo el consumo normal. Después volverá a incrementar la carga hasta aprovechar todos los excedentes y así sucesivamente ...

Me parece que la lógica no es:
. if (Potencia_actual > Potencia_anterior)

sino debería ser:
. if (Potencia_actual = Potencia_anterior + incremento PWM)
pudiendo ser el "incremento" positivo o negativo


- - - - - - - - - - - - - - - - - - -

Iniciado por oxid

Es para proteger las entradas ... el diodo deriva corriente al +5V, y la resistencia de 100R la limita.

Entiendo, gracias. Los diodos derivan, cuando U > 5V, de esta forma solo llega U <= 5V a las entradas.

Otra pregunta: Por qué hay 3 resistencias en el divisor de tensión? Para indicar que R1 + R2 >> R3 ??

Iniciado por el_cobarde

Entiendo, gracias. Los diodos derivan, cuando U > 5V, de esta forma solo llega U <= 5V a las entradas.

Otra pregunta: Por qué hay 3 resistencias en el divisor de tensión? Para indicar que R1 + R2 >> R3 ??

Porque hay que dividir al tensión desde 150 a 5, relación 30/1, y es más dificil encontrar resistencias del 1% de tolerancia de potencia > 1/4W, para suplirlo se montan 2 en serie, aunque todavía está por ver que valores se ponen, de eso depende.

Iniciado por oxid

... es más dificil encontrar resistencias del 1% de tolerancia de potencia > 1/4W, para suplirlo se montan 2 en serie ...

Gracias. O sea, si tenemos 100V, 0.25W serían 2.5mA de intensidad, R = 40kOhm. A 100V, resistencias de <40kOhm son más precisas que resistencias >40kOhm. Poco a poco voy entendiendo ...

Iniciado por el_cobarde

Gracias. O sea, si tenemos 100V, 0.25W serían 2.5mA de intensidad, R = 40kOhm. A 100V, resistencias de <40kOhm son más precisas que resistencias >40kOhm. Poco a poco voy entendiendo ...

Nooo, las que (creo) no son tan corrientes son las de potencia >1/4W con tolerancia del 1%.
Cuando me pueda mirar el datasheet del ATMEGA328p consultaré las características del pin analógico y determinar los valores...

Que por cierto, ya pueden ser baratos los Arduino UNO, he visto en el esquema que no llevan nada de protección en las entradas / salidas.

Iniciado por oxid

Nooo, las que (creo) no son tan corrientes son las de potencia >1/4W con tolerancia del 1%.

No es esto lo que he escrito?
1/4W es 0.25W o 250mW. P = U²/R ---> R = U²/P; a 100V, R = 100*100/0.25 = 40kOhm
- R > 40kOhm ---> más difícil de encontrar con tolerancia del 1% (para U=100V)
- R < 40kOhm ---> más fácil de encontrar con tolerancia del 1% (para U=100V)

Iniciado por oxid

... ya pueden ser baratos los Arduino UNO, he visto en el esquema que no llevan nada de protección en las entradas / salidas.

No son baratos, son baratísimos. He visto copias chinas del Arduino UNO por menos de 5 euros!

Iniciado por el_cobarde

Me gusta mucho tu algoritmo, carlos6025. Es mucho más sencillo que el mío. Pero no veo que funcione.

La base es "aumentar PWM", es decir "incrementar la carga" y ver si sube (o baja) la potencia FV.
Hagamos un ejemplo: Pongamos que el consumo normal sea de 1000W y que haya 820W de excedentes. Pongamos que el incremento PWM sea de 50W.
El Arduino empieza con cero e incrementa la carga en 50W. Ve que la potencia FV aumenta (a 1050W) y vuelve a incrementar en 50W. Asi sucesivamente, hasta llegar a 1800W. Con el próximo incremento, la potencia FV sube solo a 1820W, porque no hay más potencia. Los 30W que faltan serán de batería. El Arduino hará un incremento más (70W de batería) y se dará cuenta de que ya no aumenta la potencia FV. En el próximo paso decrementará la carga en 50W. Como no hay cambio en la potencia que mide, volverá a decrementar la carga. Esta vez, la potencia FV disminuye, por lo que el Arduino volverá a decrementar la carga ...
Allí está el fallo: El Arduino decrementará la carga de excedentes hasta cero, dejando solo el consumo normal. Después volverá a incrementar la carga hasta aprovechar todos los excedentes y así sucesivamente ...

Es cierto, la potencia se quedaría a cero.

Pero repito, creo que será mejor comparar potencias que tensiones e intensidades por separado

Iniciado por el_cobarde

No es esto lo que he escrito?
1/4W es 0.25W o 250mW. P = U²/R ---> R = U²/P; a 100V, R = 100*100/0.25 = 40kOhm
- R > 40kOhm ---> más difícil de encontrar con tolerancia del 1% (para U=100V)
- R < 40kOhm ---> más fácil de encontrar con tolerancia del 1% (para U=100V)

Y de dónde sacas los 100V ?
Olvídate del tema de los voltios ahora...
Las capsulas de las resistencias determinan su disipación térmica, que te lo dice el fabricante. Además, no le vas a hacer disipar el 100% de potencia continuamente... para servicio contínuo yo no pasaría del 50% o apurando mucho el 70%.
La precisión en % no depende del valor óhmico.
Lo que quería decir es que son más corrientes de pequeño tamaño ( 250mW ), de mayor potencia no hay tantas.

Iniciado por carlos6025

Es cierto, la potencia se quedaría a cero.

Bueno, creo que con tu algoritmo, lo que haría el Arduino es incrementar la señal PWM hasta aprovechar todos los excedentes y después decrementar la señal PWM hasta desperdiciar todos los excedentes. Después otra vez a incrementar hasta todo, decrementar hasta nada y así sucesivamente.
Como promedio aprovecharía el 50% de los excedentes, más o menos.

Iniciado por carlos6025

Pero repito, creo que será mejor comparar potencias que tensiones e intensidades por separado

Ya he dicho que me gusta tu idea. Es más sencilla. Creo que imita lo que hace un regulador con salida PWM para excedentes.
Mi concepto hila más fino. Se sabe mejor en qué punto de la curva I-U se encuentra el campo FV y se podría adaptar la modulación de la señal PWM a ello. Creo que los reguladores MPPT emplean un algoritmo similar para buscar el MPP.
Ya me decidiré si emplear "tu" comparación de potencia o "mi" incremento de I y U ...
De momento me parece suficientemente "bueno" tu algoritmo.

Para que tu algoritmo funcione correctamente, lo he modificado un poco:

. U_actual = 0
. I_actual = 0
. Incremento = const (p.e. 50W)
. PWM = 0

Comienza el bucle

. U_actual = Lee U_paneles
. I_actual = Lee I_paneles
. Potencia_actual = U_actual x I_actual

. if PWM = 0
. Potencia_anterior = Potencia_actual - Incremento
. endif

. if (Potencia_actual <> Potencia_anterior)
. PWM = PWM + Incremento
. else
. PWM = PWM - Incremento
. PWM = PWM - Incremento
. PWM = PWM - Incremento
. endif

. Potencia_anterior = Potencia_actual

Vuelvo al bucle


La negación de la condición:
. if (Potencia_actual <> Potencia_anterior)
es muy exigente; puede fallar fácilmente. Mejor sustituir el "if" por:
. if (abs(Potencia_actual - Potencia_anterior) > (0.2 * Incremento)

Con esto se da un margen de +/- 20% para reconocer que la potencia FV ha variado correctamente


- - - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - - - - - - - -

Iniciado por oxid

Olvídate del tema de los voltios ahora... Lo que quería decir es que son más corrientes de pequeño tamaño (250mW ) ...

Vale, entiendo, de acuerdo. Las R sirven para cualquier tensión, por eso hay que hablar de potencia que aguantan.
Y las pequeñas, que aguantan 250mW, suelen ser las más precisas.


.

Iniciado por el_cobarde

Vale, entiendo, de acuerdo. Las R sirven para cualquier tensión, por eso hay que hablar de potencia que aguantan.

NO ! no aguantan cualquier tensión, cada fabricante te da unos valores máximos dependiendo del modelo específico, aunque en nuestro caso no creo que llegue ahí.

Iniciado por el_cobarde

Y las pequeñas, que aguantan 250mW, suelen ser las más precisas.

NO ! la precisión será la misma en una de 1/4W del 1% que en una de 1W 1% !!
Sólo estoy diciendo que las de más potencia no hay tantos modelos y a veces algunos valores no se encuentran !!!

- - - - - - - - - - - - - - - - - - -

Ayer hice algunos cálculos rápidos:
Tenemos 150V entrada max. ( para redondear ) que tenemos que rebajar a 5V ( entrada max. Arduino ),
y por otra parte tenemos un conversor ADC en el dispositivo de 10bits, que son 1024 cuentas ( de 0 a 1023 ),
o sea 150 / 1024 nos da 0,146484375 .. redondeamos a 0,15 con lo que tendremos 1024* 0,15 = 153,6 V
Haciendo cálculos y escogiendo uno de los 2 valores, R3 = 5K ( 1%), R1 + R2 tendría que ser de 148,6K, que lo hacemos con
91K + 57K6, ambos del 1%.
Con este divisor, cada bit del conversor AD nos dará teóricamente 0,15V, o sea obtendremos cuentas de 0 a 153,15 en pasos de 0,15V.

Si no os gusta esta solución, en R1+R2 le ponéis una sola resistencia de 149K, también 1%, pero luego cada bit serían
0.15039..V

Iniciado por oxid

Sólo estoy diciendo que las de más potencia no hay tantos modelos y a veces algunos valores no se encuentran !!!

Por fin te he entendido! Lo que me ha costado!

- - - - - - - - - - - - - - - - - - -

Iniciado por oxid

Ayer hice algunos cálculos rápidos ...

Gracias por los cálculos. Me parecen muy bien.

Iniciado por oxid

Si no os gusta esta solución, en R1+R2 le ponéis una sola resistencia de 149K, también 1%, pero luego cada bit serían 0.15039..V

Las dos opciones me gustan, tanto (91K + 57K6) como 149K. Claro que 0.15V/bit suena muy bien, siendo "número redondo". Pero en la práctica no será tan redondo y, además, al Arduino le da igual.

Iniciado por el_cobarde

.... Pero en la práctica no será tan redondo y, además, al Arduino le da igual.

Es única y exclusivamente para que en el Arduino no tengáis que utilizar variables tipo float que son más lentas de cálculo, en cambio si utilizáis 0,15 -> 15 y 150 -> 15000 ó 5 -> 500 podéis utilizar una variable tipo int o long int, luego para saber el valor le aplicáis el factor proporcional del divisor ( creo que era 30,72 -> 3072) y el resultado lo tenéis directo en 1/100 de voltios.

Iniciado por skolly

vale... la he añadido hoy... veré a ver qué tal se comporta cuando haya excedentes. Aunque lo que me interesa es que la carga sea más lenta, y la descarga más rápida...
Lo del integrador lo veo un lío, si para provocar la descarga voy a tener que aplicarle una tensión negativa... ufff.
arduino es la solución.

qué tal...perdonad que os corte el tema, que voy leyendo y está caliente caliente...
pero hasta hoy no he podido comprobar cómo iba el carlotrón con la R2 que he añadido,,, y ohhhhh.
cambio de comportamiento radical. Ya no oscila, y va clavado.
No obstante, lo iré observando durante varios estados de carga de la batería (recordad que el efecto de oscilación se acentuaba por la tarde cuando las baterías estaban 100% cargadas).
Ahora ya sólo queda derivar con la freq de la red!!

Iniciado por oxid

Es única y exclusivamente para que en el Arduino no tengáis que utilizar variables tipo float ... podéis utilizar una variable tipo int o long int ...

Tienes mucha razón, no había pensado en esto.

- - - - - - - - - - - - - - - - - - -

Iniciado por skolly

qué tal...perdonad que os corte el tema, que voy leyendo y está caliente caliente ...

Vaya si está caliente - el algoritmo ese no me quiere soltar ...

Iniciado por skolly

... el carlotrón con la R2 que he añadido ... cambio de comportamiento radical. Ya no oscila, y va clavado.

Enhorabuena, skolly !

Iniciado por el_cobarde

. U_actual = 0
. I_actual = 0
. Incremento = const (p.e. 50W)
. PWM = 0

Comienza el bucle

. U_actual = Lee U_paneles
. I_actual = Lee I_paneles
. Potencia_actual = U_actual x I_actual

. if PWM = 0
. Potencia_anterior = Potencia_actual - Incremento
. endif

. if (Potencia_actual <> Potencia_anterior)
. PWM = PWM + Incremento
. else
. PWM = PWM - (Incremento * 3)
. endif

. Potencia_anterior = Potencia_actual

vuelvo al bucle


La negación de la condición:
. if (Potencia_actual <> Potencia_anterior)
es muy exigente; puede fallar fácilmente. Mejor sustituir el "if" por:
. if (abs(Potencia_actual - Potencia_anterior) > (0.2 * Incremento)

Con esto se da un margen de +/- 20% para reconocer que la potencia FV ha variado correctamente

.

Hay algo que no me cuadra.
Supongamos que el sistema está estabilizado. Es decir, toda la potencia excedente se está utilizando. En ese momento conecto una carga al inversor. No cambia nada, porque la Potencia_actual seguirá siendo la misma, porque los paneles ya estaban al máximo.

Iniciado por carlos6025

Hay algo que no me cuadra.
Supongamos que el sistema está estabilizado. Es decir, toda la potencia excedente se está utilizando. En ese momento conecto una carga al inversor. No cambia nada, porque la Potencia_actual seguirá siendo la misma, porque los paneles ya estaban al máximo.

Creo que sí funciona, el algoritmo.

Cuando toda la potencia excedente se está utilizando, el Arduino detectará "Potencia_actual = Potencia_anterior" y reducirá PWM en tres incrementos. La Potencia_actual se reduzirá en 3 incrementos y luego subirá 1 incremento - tantas veces hasta encontrar un nuevo equilibrio, a la Potencia_actual más alta o más baja.

En otras palabras: En estado de equilibrio, el Arduino da un paso adelante. Si ve que la potencia FV no le sigue, da tres pasos atrás y otra vez da un paso adelante. Si la potencia FV le sigue, da otro paso adelante. Si no le sigue, da tres pasos atrás. De esta forma 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.

A ver si alguien se anima y me dice su opinión sobre si este algoritmo funciona o no.
Es que carlos6025 dice que no le cuadra (y valoro mucho su juicio) y yo no le veo el fallo.

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_paneles
. I_actual = Lee I_paneles
. 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

Vuelvo al bucle

- - - - - - - - - - - - - - - - - - -

Breve explicación:
Para empezar, el Arduino incrementa la señal PWM un poquito. 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:
- 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 algoritmo me parece eficaz, tanto si la cantidad de excedentes varía por cambiar la irradiación solar, por consumo "normal" adicional o por cualquier otra causa.
Sin embargo, carlos6025 ha hecho el siguiente comentario:

Iniciado por carlos6025

Hay algo que no me cuadra.
Supongamos que el sistema está estabilizado. Es decir, toda la potencia excedente se está utilizando. En ese momento conecto una carga al inversor. No cambia nada, porque la Potencia_actual seguirá siendo la misma, porque los paneles ya estaban al máximo.

Yo no veo este problema. Algún compañero me dice su opinión ?


.

En principio veo que varios datos nos pueden indicar si hay excedentes o no:
- tensión de batería: cuando se pone más consumo y la tensión de batería no disminuye, hay excedentes
- corriente de batería: cuando se pone más consumo y la corriente de carga que entra a la batería no disminuye, hay excedentes
- tensión de panel: si la tensión del panel está fuera del MPP, hay excedentes

Es decir no debería ser complicado crear un algoritmo que a base de estos valores rastree el excedente y que lo derive perfectamente.
Eso funcionará perfectamente en flotación. El problema que sigo viendo es para la fase de absorción, el contador de horas de absorción a lo mejor no sigue cuando se derivan excedentes porque la tensión de batería se mantiene una milésima por debajo del objetivo. Lo ideal sería decirle al regulador que pase a flotación a base de datos que recoge el Arduino (criterio de corriente final de carga), pero entonces se necesita comunicación con el regulador (muchos reguladores facilitan la comunicación a través de RS485, RS232 o similar).
Sin comunicación con el regulador no veo posibilidad de aprovechar bien los excedentes en la fase de absorción, al menos no con todos los reguladores.

Iniciado por Hlebtomane

En principio veo que varios datos nos pueden indicar si hay excedentes o no ...

Esto lo veo igual.

Iniciado por Hlebtomane

El problema que sigo viendo es para la fase de absorción, el contador de horas de absorción a lo mejor no sigue cuando se derivan excedentes porque la tensión de batería se mantiene una milésima por debajo del objetivo.

Sería cuestión de probarlo. Creo que el Arduino es tán rápido, que la tensión de batería no cambia visiblemente. De todas formas, haciendo el incremento en PWM lo suficientemente pequeño, debería funcionar, sin necesidad de comunicar con el regulador.

Además, si realmente hubiese una pequeña bajada de tensión y el contador del tiempo de absorción del regulador dejaría de contar, esto sería para unas milésimas de segundo. En seguida, la tensión volvería a subir y el contador seguiría contando.

Me parece que la derivación de excedentes con Arduino es fácil y puede funcionar bien tanto en flotación como en absorción.

Ojalá será así, pronto lo veremos.
Yo lo estoy dudando porque los reguladores Outback y Midnite trabajan con un margen de tensión para el contador de tiempo de absorción; si ese margen lo reduces a, por ejemplo 0,1 V, ya dejas de aprovechar gran parte de los excedentes (supongo que es por el tiempo de respuesta del regulador, pues a conectar el consumo la tensión de batería cae directamente y el regulador necesita algunos fragmentos de segundo para ajustarse a esa situación y crear el nuevo equilibrio en la tensión que tiene por objetivo).

Iniciado por Hlebtomane

Ojalá será así, pronto lo veremos.

Si hay que esperar a que yo lo realice, tardaré un poco. Tengo que esperar que los componentes me lleguen desde China (pueden tardar dos meses) y tengo que practicar con el Arduino (más meses). Nunca he tenido uno en mano.

Iniciado por Hlebtomane

Yo lo estoy dudando porque los reguladores Outback y Midnite trabajan con un margen de tensión para el contador de tiempo de absorción; si ese margen lo reduces a, por ejemplo 0,1 V, ya dejas de aprovechar gran parte de los excedentes ...

Precisamente este margen de tensión que tiene el contador del tiempo de absorción lo veo como una ventaja. El Arduino no reducirá este margen. Las descargas de batería que provoca el Arduino serán tan mínimas, que el contador del tiempo de absorción no saldrá de su margen. Posiblemente ni se registren cambios de tensión por culpa del Arduino. El incremento de PWM con el que trabaja el Arduino puede ser mínimo. En mi ejemplo he puesto 50W, pero igual puede ser 1W. No creo que la tensión de batería cambie visiblemente, si se aumenta el consumo en 10W, por ejemplo.