Per quello che riguarda la porta parallela delle stampanti moderne ... non è un problema se mandano solo impulsi e non una tensione diretta o continua.
Gli metto un relè ciclico e ho risolto il problema.
Il problema sta solo sapere per quanti millisecondi dura l' impulso che da i 5 volt in uscita sul pin della parallela e se la parallela riesce a reggere l' assorbimento della bobina del relè ciclico.

In ogni caso sto scrivendo un codice molto semplice da far girare su scheda arduino con display lcd.
Manca solo che lo provi per correggere gli eventuali errori.

Una spiegazione veloce e molto semplificata.

Dal menu si accede alle pagine dove impostare la soglia di minima e massima tensione della cella con precisione di 0,01 Volt

Se la tensione scende sotto la soglia minima inizia la carica della cella.
Al superamento della soglia di massima carica della cella ci sarà una pausa di 5 secondi e inizia la fase di scarica fino alla soglia minima impostata per poi riprendere il ciclo.

Visto che la cella lavora nel range di tensione delle porte analogiche non servono partitori resistivi.
Se consigliate di metterli dovrò adattare qualche calcolo.....

Per l'inversione di polarità la cosa si complica, si rischia di far fuori l'arduino in quanto i collegamenti risultano invertiti sulle porte di ingresso e alla massa arriverebbero +5V e sul piedino di ingresso si troverebbe a massa

Si deve portare la cella a 0 volt per poi invertire fisicamente i cavetti all'ingresso della porta analogica

CITAZIONE (righetz, 07/05/2017 23:40:00 )

In ogni caso sto scrivendo un codice molto semplice da far girare su scheda arduino con display lcd.
Manca solo che lo provi per correggere gli eventuali errori.

Una spiegazione veloce e molto semplificata.

Dal menu si accede alle pagine dove impostare la soglia di minima e massima tensione della cella con precisione di 0,01 Volt

Se la tensione scende sotto la soglia minima inizia la carica della cella.
Al superamento della soglia di massima carica della cella ci sarà una pausa di 5 secondi e inizia la fase di scarica fino alla soglia minima impostata per poi riprendere il ciclo.

Visto che la cella lavora nel range di tensione delle porte analogiche non servono partitori resistivi.
Se consigliate di metterli dovrò adattare qualche calcolo.....

Per l'inversione di polarità la cosa si complica, si rischia di far fuori l'arduino in quanto i collegamenti risultano invertiti sulle porte di ingresso e alla massa arriverebbero +5V e sul piedino di ingresso si troverebbe a massa

Si deve portare la cella a 0 volt per poi invertire fisicamente i cavetti all'ingresso della porta analogica

CITAZIONE

Ho guardato un po' il tutto ... è fuori dalle mie capacità ... grazie lo stesso.

Ma dai... ci siamo qui noi... basta che acquisti queste tre cose:

arduino uno R3 ebay

scheda lcd con pulsantiera ebay

modulo doppio relè ebay

(stesso venditore)

Poi al resto ci pensiamo noi...

E la scheda elettronica che è da costruire come ho visto nella pagina 3 o 4 che mi è stata linkata chi me la fa ?
Non competenze in merito.
Non ho letto tutta la discussione perché quando vedo che ci sta da costruire schede elettroniche io mi arrendo subito.
Come ho scritto sopra se ci sta assemblare a livello di cavi e collegamenti non ci stanno problemi ... oltretutto Elix avevi anche affermato che far passare il carico sulle piste di Arduino è un rischio perché io lavoro con grossi carichi
Per questo avevo chiesto una cosa specifica ... ma quando dico specifica intendo dire che se applico un carico da 40 o 50 ampere deve reggere la portata.
Arduino deve fare solo una cosa ... dare corrente alla bobina di un relè quando devo caricare la batteria e togliere la corrente alla bobina di questo relè quando devo scaricare la batteria.
Se poi Arduino può pilotare anche un seconda bobina di relè e con una semplice modifica del software di base posso anche invertire in automatico la polarità.
Ho visto le schermate che si vedrebbero sul monitor che registrano cicli, carica, scarica, consolidamento, pausa o riposo che sia ... tutti parametri che non mi servono ... io ho già una telecamera che registra 24 ore su 24 i tester collegati alle celle e per me è più che sufficiente.
Mi ci vorrà almeno un' altro anno e mezzo o due anni di test prima di risolvere l' ultimo problema che mi è rimasto ma ci sto arrivando anche a quello ... ho trovato sicuramente la strada ma non avendo conoscenze in chimica e fisica vado avanti facendo nuovi test per trovare la soluzione giusta.
Per cui un formatore automatico mi serve ma deve fare solo quello che ho scritto io ... niente schermate o cose del genere.
Dal momento che non lo userei per altri scopi perché ho letto che non si può non lo collego al computer, deve essere autonomo con il suo display e il tastierino per mettere i parametri di tensione per la carica e la scarica ... nulla di più.

Io posso anche acquistare quei 3 oggetti ... non sono certo 11,36 euro più spese di spedizione che mi mandano in rovina ma vi è da caricare il software, mi servono gli schemi di cablaggio delle 3 schede e le istruzioni per l' uso.
Per questo ho chiesto a chi è competente se mi fa tutto il procedimento ... gli mando i soldi che servono per Postepay o bonifico bancario e mi incarico di altre eventuali spese ... poi mi invia il pacchetto ove io poi faccio tutto il resto.

MODULO SCHEDA 2 RELE': 2,28 + 2,57 S.P. (Posta 1)
Display LCD 16x2: 5,10 + 1,12 (Oggetto Aggiuntivo)
UNO R3 ATmega328: 4,97 + 1,12 (Oggetto Aggiuntivo)

Sommano: 17,16 euro.

Se non è una spesa che ti manda in rovina inizia ad acquistare gli oggetti, poi le cose vengono pian piano...

Sono almeno 1 anno che giochi con le Plantè, non puoi investire qualche ora con Arduino ?
Poi magari non ti piace, non sei capace o proprio non fa per te e hai buttato 20 euro ma almeno ti sei tolto la soddisfazione...

Qualche anno fa, se ti avessi chiesto di costruirmi una batteria Plantè per me, mi avresti sicuramente risposto: non ne sono capace, comprale già belle e fatte; ora non è che le produci per la vendita ma hai una conoscenza totalmente diversa dell'argomento, sai già dirmi costi, pesi, caratteristiche, pregi, difetti, etc. etc.

Con Arduino è la stessa cosa: se non ne hai uno tra le mani chissa cosa sembra, quasi impossibile, ma se poi inizi a giocarci diventa tutto semplicissimo.

Che dici ? L'accendiamo ? Facciamo questo sconsiderato acquisto di 20 euro ???

Elix

Ci penso sopra.

CITAZIONE (BellaEli, 12/05/2017 02:46:16 )

Per Righetz.

Senti ... visto che non abiti molto lontano da casa mia e visto che capito spesso dalle tue parti perché mia moglie è di Eraclea mare e andiamo spesso a trovare sua madre e sua sorella ... io mi procuro tutto il materiale che serve e poi ci troviamo di persona e mettiamo insieme il tutto e lo testiamo.
A me piace vedere di persona come si fanno certe cose di cui non ne ho la minima conoscenza specifica ... poi se ti va ci andiamo a mangiare una pizza a spese mie oppure ti pago il disturbo ... e se non vuoi nulla accetta almeno i miei ringraziamenti.
Fammi sapere.

affare fatto ma la birra la offro io.
Il codice è pronto da caricare nella scheda mi manca il tempo per testarlo.


Anzi posto il codice così qualcuno di più esperto di me lo controlla e credo che male non faccia

// Realizzato da Righetz per ITA815
// e condiviso  http://www.energialternativa.info
//
//
//
//ATTENZIONE:
//
//CC BY-NC-SA 4.0
//Uso non commerciale, modificabile, con obbligo di condivisione-
//http://creativecommons.org/licenses/by-nc-sa/4.0/deed.it
//
//



//**********************************************************
//PREFERENZE DI DEFAULT
//**********************************************************
unsigned long LastCmd;                                                     // valore intervallo pressione pulsanti schield
int inputValue = 0;                                                       // valore letto dai pulsanti sul pin A0 della schield
byte pagina = 1;                                                          // scegli la pagina iniziale del menu
float Soglia_inf = 1.7;                                                   // Voltaggio minimo cella
float Soglia_sup = 2.4;                                                   // Voltaggio massimo cella
float Vcell = 0.00;
float Volt = 0.00;
unsigned long Pausa = 5000;                                               // pausa tra una fase di avvio e un'altra sequenza
unsigned long Prev_Time = 0;
unsigned long Prev_Time1 = 0;
unsigned long Prev_Time2 = 0;
unsigned long Prev_Time3 = 0;






//**************NON MODIFICARE*******************************************


#include <LiquidCrystal.h>//Libreria per gestire LCD
#include <Wire.h>



//**************ASSEGNAZIONE PIN**********************************
//***DA MODIFICARE CON CAUTELA***

int inputPin = A0;                      // pin assegnato agli array dei pulsanti della schield
#define ReleCarica 10                         //Assegna il pin 10 come uscita attivazione rele
#define ReleScarica 9                          //Assegna il pin 9 come uscita attivazione rele
LiquidCrystal lcd(7, 6, 5, 4, 3, 2);    //ASSEGNAZIONE PIN  LCD Righets www.microbot.it

//*****************************************************************



void setup() {
  Serial.begin(57600);                                   //inizializzazione seriale
  pinMode(ReleCarica, OUTPUT);                               //dichiarazione Rele di carica come uscita
  digitalWrite(ReleCarica, LOW);                             //dichiarazione Rele di carica non attivato
  pinMode(ReleScarica, OUTPUT);                              //dichiarazione Rele di scarica come uscita
  digitalWrite(ReleScarica, LOW);                           //dichiarazione Rele di scarica non attivato

  lcd.begin(16, 2);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Formatore EA");
  delay(2000);
  lcd.clear();
}


void loop()

{ unsigned long curr_Time = millis();                   // tempo tra una fase di start
  if (curr_Time - Prev_Time > Pausa) {                  // e quella successiva
    Prev_Time = curr_Time;                                // impostata a 5 sec.

    scarica();
  }                                     // esegue la funzione della scarica della cella


  carica();
  Tastiera_LCD();                                 //Interpreta i comandi e visualizza risultati su LCD
  getkey();


}


void  Tastiera_LCD() {                            //Interpreta i comandi e visualizza risultati su LCD
  if (millis() > LastCmd + 250) {
    LastCmd = millis();
    if (pagina < 4 && inputValue == 3) pagina++;            //
    if (pagina > 0 && inputValue == 4) pagina--;            //
    if (pagina == 0 && inputValue == 1) Soglia_inf += 0.01; //
    if (pagina == 0 && inputValue == 2) Soglia_inf -= 0.01;
    if (pagina == 1 && inputValue == 1) Soglia_sup += 0.01;
    if (pagina == 1 && inputValue == 2) Soglia_sup -= 0.01; //
    if (pagina == 2 && inputValue == 3) Vcell ;              //
   

    switch (pagina) {
      case 0 :
        lcd.setCursor(0, 0);
        lcd.clear();
        lcd.print("-  Soglia inf  +      ");
        lcd.setCursor(5, 1);
        lcd.print(Soglia_inf);
        lcd.print(" V                  ");
        break;
      case 1 :
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.clear();
        lcd.print("-  Soglia sup  +     ");
        lcd.setCursor(5, 1);
        lcd.print(Soglia_sup);
        lcd.print(" V                     ");
        break;
      case 2 :
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Tensione Cella");
        lcd.setCursor(0, 1);
        lcd.print("Volt=          ");
        break;
    }
  }
}

void leggivalore() {
  Volt = analogRead(A1);
  float Vcell = (Volt * (5.0 / 1023));
}

void getkey() {
  inputValue = analogRead(inputPin);
  if (inputValue < 100 && inputValue >= 0) inputValue = 1;        //sx
  else if (inputValue < 250 && inputValue > 150) inputValue = 2;  //dx
  else if (inputValue < 470 && inputValue > 370) inputValue = 3;  //su
  else if (inputValue < 670 && inputValue > 570) inputValue = 4;  //giù
  else if (inputValue < 870 && inputValue > 770) inputValue = 5;  //seleziona
  else if (inputValue <= 1023 && inputValue > 950) inputValue = 0; //niente

}


void carica() {

  if (Vcell <= Soglia_inf && Vcell <= Soglia_sup) {
    digitalWrite(ReleCarica, HIGH); // attivazione del relè con soglia tensione nel range
  }
  else {
    digitalWrite(ReleCarica, LOW); // se non ci sono le condizioni relè spento
  }

}

void scarica() {

  if (Vcell == Soglia_sup ) {
    digitalWrite(ReleScarica, LOW); // se la soglia sup uguale valore stabilito relè spento
  }
  else {
    digitalWrite(ReleScarica, LOW); // relè spento
  }

}

Edit: corretto errore nel codice, te pareva se poteva non mancare

Ok, perfetto ... quando hai tempo da dedicarmi per il progetto me lo dici sulla mia pagina di discussione che riguarda le celle Plantè che così compro tutto quello che serve e poi ci mettiamo al lavoro.
Mi manderai i link delle pagine dove acquistare la merce ... oppure se i link che mi ha mandato Elix vanno bene acquisto quel materiale ... ok ?

Carino il circuito.
riesci a fare funzioni logiche di controllo di dati precedenti ... sempre se il software è in grado di memorizzare i dati precedenti naturalmente.