Tester batterie universale

[lcdsun]

Buon giorno , il titolo pomposo vuole essere miele per orsi , conscio dei rischi connessi.
Scherzi a parte, tempo addietro avevo scritto la prima versione di questo codice con la finalità di testare la capacità di una generica batteria basandomi sulla legge di ohm (non ho le conoscenze elettroniche per andare oltre); ed in realtà non è che debba testare chissà quali e quante batterie , nessuna , per la verità ; ma fatico a "giocare" con l'uno a l'altro componente senza avere un "traguardo" d'insieme.
Con questo progetto ho potuto giocare con diverse situazioni , ora , alla luce di nuove (per me) nozioni apprese mi permetto di postare il codice nella speranza di non infastidire nessuno ed al contempo di risultare comprensibile e , perché nascondersi ? anche nella speranza di consigli e graffiate (restando in tema orsi) .
Grazie.

//TESTER BATTERIE FUNZIONANTE (bug permettendo)\\

/*A BORDO 5 PULSANTI [START] [SELEZIONE] [ + ] [ - ] [RESET]
          2 SELETTORI  [CARICO INTERNO ON/OFF]  [CARICO ESTERNO ON/OFF]
          5 LED [BLU CICLO IN CORSO] [VERDE CICLO TERMINATO BATTERIA OK] [ROSSO CICLO TERMINATO BATTERIA K.O]
            [GIALLO STATO CARICO INTERNO ON/OFF] [GIALLO STATO CARICO ESTERNO ON/OFF] NOTA: COLLEGAMENTO HARDWARE
          1 DISPLAY LCD 16,2 I2c
*/

#include <JC_Button.h>                 //libreria gestione pulsanti in ingresso
#include <Wire.h>                      //libreria porte I2c
#include <PCF8574_HD44780_I2C.h>       //libreria display I2c
PCF8574_HD44780_I2C lcd(0x27, 16, 2);  //creo oggetto display

//definisco ingressi-uscite

#define START 2               //avvio ciclo automatico di test
#define SELEZIONE 3           //selezione possibilità
#define INCREMENTO 4          //pulsante incremento
#define DECREMENTO 5          //pulsante decremento
#define CARICO_INTERNO 6      //rele di carico interno
#define CARICO_ESTERNO 7      //rele di carico esterno
#define LED_BLU 8             //led blu di scarica in corso (sarebbe bello se lampeggiasse)
#define LED_VERDE 9           //led rosso di fine scarica con esito negativo
#define LED_ROSSO 10          //led verde di fine scarica con esito positivo

//definizione case

int stato_scelto = 0;         //stati case
#define HOME 0                //visualizzo schermata iniziale
#define TIPO_1 1              //batteria pre_impostata modello 1
#define TIPO_2 2              //batteria pre_impostata modello 2
#define TENSIONE_NOMINALE 3   //imposto valore tensione nominale batteria
#define TENSIONE_MINIMA 4     //imposto valore tensione minima batteria
#define CAPACITA_NOMINALE 5   //imposto valore capacità nominale batteria
#define TEMPO_PRESUNTO 6      //imposto valore tempo previsto,in funzione al carico applicato
#define TESTER_LIVE 7         //a riposo è un voltmetro , a seguito dello start avvia il test

unsigned long T_RIFERIMENTO ;   //tengo traccia del tempo dall'accensione

//gestione pulsanti ingresso da libreria

Button start(START);            //creo oggetto pulsante start/avvio
Button selezione(SELEZIONE);    //creo oggetto pulsante selezione/scegli

// variabili globali

bool avvio;                     //avvio/accetta ciclo automatico
bool scegli;                    //scegli stato (case)
bool aumenta;                   //modifica valore aumentando
bool diminuisci;                //modifica valore diminuendo

float voltmetro ;              //qui assegno la tensione rilevata sul pin A0
float amperometro ;            //qui assegno la corrente rilevata sul pin A1
float V_nominale;              //dati targa batteria da impostare
float V_minima;                //soglia di interruzione ciclo preimpostato o da impostare
float A_nominale;              //capacità di targa o presunta preimpostata o da impostare
float A_carico;                //potenza applicata dal carico preimpostata se interna da impostare se esterna
float T_scarica;               //tempo scarica presunto preimpostato o da impostare

float contatore = 0.00;        //variabile per impostare valori da assegnare con decimali
int contatore_tempo = 0;       //variabile per impostare valore temporale con moltiplicatore preimpostato

int ciclo = 0 ;                //varibile (superflua?) per conoscere provenienza del case attuale


void setup() {

  Serial.begin(9600);
  pinMode (SELEZIONE, INPUT);
  pinMode (START, INPUT);
  pinMode (INCREMENTO, INPUT);
  pinMode (DECREMENTO, INPUT);
  pinMode (CARICO_INTERNO, OUTPUT);
  pinMode (CARICO_ESTERNO, OUTPUT);
  pinMode (LED_BLU, OUTPUT);
  pinMode (LED_VERDE, OUTPUT);
  pinMode (LED_ROSSO, OUTPUT);

  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print(" BATTERY TESTER");
  lcd.setCursor(0, 1);
  lcd.print(" VERSIONE V 1");   //VERSIONE 7 mia

  delay(2000);
}

void loop() {

  voltmetro = digitalRead (A0);
  amperometro = digitalRead (A1);
  start.read();
  avvio = start.wasReleased();
  selezione.read();
  scegli = selezione.wasReleased();
  aumenta = (digitalRead(INCREMENTO) == true);
  diminuisci = (digitalRead(DECREMENTO) == true);


  if (scegli) {                        //ad ogni pressione incremento il valore
    stato_scelto ++;
    if (stato_scelto > TESTER_LIVE) {  //se arrivo a 8
      stato_scelto = HOME;             //torno a 0
    }
  }

  if (aumenta) {
    contatore = contatore + 0.10;
    contatore_tempo++;
  }

  if (diminuisci) {
    contatore = contatore - 0.10;
    contatore_tempo--;
  }
  //amperometro live

  float Acslettura = 0.0, campioni = 0.0, media = 0.0;
  for (int a = 0; a < 20; a++) {             //ricavo 20 valori
    Acslettura = amperometro ;               //leggo valore ritorno acs712 c.to 1
    campioni = campioni + Acslettura;        //sommo i valori per calcolare la media
    delay (10);
  }
  media = (campioni / 20);                   //calcolo la media dei valori
  amperometro = (2.5 - (media * (5.0 / 1024.0)) ) / 0.0315; //formula per ottenere il valore definitivo
  if (amperometro < 0.10) {
    amperometro = 0.00;
  }
  // voltmetro live

  voltmetro = ((5.0 / 1024.0) * voltmetro) * ((30 + 7.5) / 7.5);


  switch (stato_scelto) {

    case HOME:

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(" BATTERY TESTER");
      lcd.setCursor(0, 1);
      lcd.print(" SCEGLI OPZIONE");

      break;

    case TIPO_1: //BATTERIA Li-ION Vnominale 3,6 A 1,9

      V_nominale = 3.6;
      V_minima = 2.9;
      A_nominale = 1.9;
      T_scarica = 7200000;   //2h 17minuti [impostato a 2h]
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Li-ION 1900mA");
      lcd.setCursor(0, 1);
      lcd.print("SCARICO ?");
      if (avvio) {
        stato_scelto = TESTER_LIVE;
      }
      break;

    case TIPO_2 :  //BATTERIA Li-ION Vnominale 3,6 A 2,2

      V_nominale = 3.6;
      V_minima = 2.9;
      A_nominale = 2.2;
      T_scarica = 8400000;       //2h 39' [impostato a 2h20']
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Li-ION 2200mA");
      lcd.setCursor(0, 1);
      lcd.print("SCARICO ?");
      if ((avvio)) {
        stato_scelto = 7;
      }
      break;

    case TENSIONE_NOMINALE :  //IMPOSTA TENSIONE NOMINALE
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("IMPOSTA DATI");
      lcd.setCursor(0, 1);
      lcd.print("Vnom=");
      lcd.setCursor(7, 1);
      lcd.print(contatore);
      delay(100);
      if ((contatore != 0.00) && (avvio)) {
        lcd.setCursor(14, 0);
        lcd.print("OK");
        delay(50);
        V_nominale = contatore;
      }
      break;

    case TENSIONE_MINIMA :  //IMPOSTA TENSIONE MINIMA
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("IMPOSTA DATI");
      lcd.setCursor(0, 1);
      lcd.print("Vmin=");
      lcd.setCursor(7, 1);
      lcd.print(contatore);
      delay(100);
      if ((contatore != 0.00) && (avvio)) {
        lcd.setCursor(14, 0);
        lcd.print("OK");
        delay(50);
        V_minima = contatore;
      }
      break;

    case CAPACITA_NOMINALE:  //IMPOSTA CAPACITA NOMINALE
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("IMPOSTA DATI");
      lcd.setCursor(0, 1);
      lcd.print("Anom=");
      lcd.setCursor(7, 1);
      lcd.print(contatore);
      delay(100);
      if ((contatore != 0.00) && (avvio)) {
        lcd.setCursor(14, 0);
        lcd.print("OK");
        delay(50);
        A_nominale = contatore;
      }
      break;

    case TEMPO_PRESUNTO:  //IMPOSTA TEMPO SCARICA
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("IMPOSTA DATI");
      lcd.setCursor(0, 1);
      lcd.print("Tempo=");
      lcd.setCursor(6, 1);
      lcd.print(contatore_tempo);
      lcd.setCursor(10, 1);
      lcd.print("x00000");
      delay(100);
      if ((contatore_tempo != 0.00) && (avvio)) {
        lcd.setCursor(14, 0);
        lcd.print("OK");
        delay(50);
        T_scarica = (contatore_tempo * 100000);

      }
      break;

    case TESTER_LIVE :  // TESTER LIVE + CICLO

      if ((ciclo == 0) && (voltmetro >= 0.8)) {

        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("TENSIONE ");
        lcd.setCursor(0, 1);
        lcd.print("V= ");
        lcd.setCursor(4, 1);
        lcd.print(voltmetro);
        delay(250);
      } else {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("INSERIRE ");
        lcd.setCursor(0, 1);
        lcd.print("BATTERIA");
        delay(250);
      }

      if ((avvio) && (voltmetro >= V_minima)) {

        digitalWrite(CARICO_INTERNO, HIGH);
        digitalWrite(CARICO_ESTERNO, HIGH);
        digitalWrite(LED_BLU, HIGH);
        ciclo = 1;
      }

      if (((voltmetro <= V_minima) && ((millis() - T_RIFERIMENTO) <= T_scarica)) && (ciclo == 1)) {
        ciclo = 2;                         //mi serve per impedire l'accavallamento dei due fine ciclo.
        T_RIFERIMENTO = millis();          //aggirno millis
        digitalWrite(CARICO_INTERNO, LOW);
        digitalWrite(CARICO_ESTERNO, LOW);
        digitalWrite(LED_BLU, LOW);
        digitalWrite(LED_ROSSO, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("BATTERIA DA ");
        lcd.setCursor(0, 1);
        lcd.print("BUTTARE   ");
        delay(250);
      }

      if (((voltmetro <= V_minima) && ((millis() - T_RIFERIMENTO) >= T_scarica)) && (ciclo == 1)) {
        ciclo = 3;                           //mi serve per impedire l'accavallamento dei due fine ciclo.
        T_RIFERIMENTO = millis();          //aggirno millis
        digitalWrite(CARICO_INTERNO, LOW);
        digitalWrite(CARICO_ESTERNO, LOW);
        digitalWrite(LED_BLU, LOW);
        digitalWrite(LED_VERDE, HIGH);
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("BATTERIA DA ");
        lcd.setCursor(0, 1);
        lcd.print("UTILIZZARE ");
        delay(250);
      }

      if ((voltmetro >= V_minima) && (ciclo == 1)) {
        lcd.clear();
        lcd.setCursor(4, 0);
        lcd.print("SCARICA ");
        lcd.setCursor(0, 1);
        lcd.print("V= ");
        lcd.setCursor(3, 1);
        lcd.print(voltmetro);
        lcd.setCursor(8, 1);
        lcd.print("A= ");
        lcd.print(amperometro);
        delay(250);
      }
      break;
  }
}

[ilguargua]

Ottimo! Sto giusto costruendo un qualcosa del genere, una carico fittizio programmabile, ma ho ancora parecchio lavoro da fare. Se interessa, quando sarò pronto pubblicherò lo schema ed il resto.

Ciao, Ale.

[lcdsun]

Spettacolo! Ma me interessa, così accantono le "resistenze cementate volanti" .

[lcdsun]

Mi sono accorto che avevo postato una versione del codice in lavorazione , non l'ultima.
Chiedo scusa.

//TESTER BATTERIE FUNZIONANTE (bug permettendo)\\

/*A BORDO 5 PULSANTI [START] [SELEZIONE] [ + ] [ - ] [RESET]
          2 SELETTORI  [CARICO INTERNO ON/OFF]  [CARICO ESTERNO ON/OFF]
          5 LED [BLU CICLO IN CORSO] [VERDE CICLO TERMINATO BATTERIA OK] [ROSSO CICLO TERMINATO BATTERIA K.O]
            [GIALLO STATO CARICO INTERNO ON/OFF] [GIALLO STATO CARICO ESTERNO ON/OFF] NOTA: COLLEGAMENTO HARDWARE
          1 DISPLAY LCD 16,2 I2c
          1 MODULO RTC DS3231


  OPZIONALI SE SI VUOLE COMANDARE LA SALDAPUNTI
          1 POTENZIOMETRO 10K
          1 RELE PER COMANDARE LA SALDATRICE
          1 PULSANTE VOLANTE PER COMANDARE LA SCARICA
*/

//SEMBRA FUNZIONARE CORRETTAMENTE
//AGGIORNATO A MARTEDI 22/08.
//TARARE VALORI PREIMPOSTATI E VERIFICARE ASSORBIMENTO CARICO INTERNO
//AGGIUNGO SALDAPUNTI
//VERIFICARE ALIMENTAZIONI E CONNESSIONI
//TARARE LETTURE ANALOGICHE IN CAMPO A SECONDA DELL'ALIMENTAZIONE

#include <DS3232RTC.h>                 //libreria per gestione RTC
#include <JC_Button.h>                 //libreria gestione pulsanti in ingresso
#include <Wire.h>                      //libreria porte I2c
#include <PCF8574_HD44780_I2C.h>       //libreria display I2c

PCF8574_HD44780_I2C lcd(0x26, 16, 2);  //creo oggetto display indirizzo x26 (ponte A0 sul modulo)
DS3232RTC myRTC;                       //creo oggetto RTC indirizzo default

//definisco ingressi-uscite

#define START 2               //avvio ciclo automatico di test
#define SELEZIONE 3           //selezione possibilità
#define INCREMENTO 4          //pulsante incremento
#define DECREMENTO 5          //pulsante decremento
#define CARICO_INTERNO 6      //rele di carico interno
#define CARICO_ESTERNO 7      //rele di carico esterno
#define LED_BLU 8             //led blu di scarica in corso (sarebbe bello se lampeggiasse)
#define LED_VERDE 9           //led rosso di fine scarica con esito negativo
#define LED_ROSSO 10          //led verde di fine scarica con esito positivo
#define PULS_SALD 11          //pulsante per temporizzatore saldatrice
#define RELE_SALD 12          //rele per temporizzatore saldatrice
#define POT_SALD 13           //potenziometro per temporizzatore saldatrice

//definizione case

int stato_scelto = 0;         //stati case
#define HOME 0                //visualizzo schermata iniziale
#define TIPO_1 1              //batteria pre_impostata modello 1
#define TIPO_2 2              //batteria pre_impostata modello 2
#define TENSIONE_NOMINALE 3   //imposto valore tensione nominale batteria
#define TENSIONE_MINIMA 4     //imposto valore tensione minima batteria
#define CAPACITA_NOMINALE 5   //imposto valore capacità nominale batteria
#define IMPOSTA_ORE 6         //imposto valore tempo previsto,in funzione al carico applicato
#define IMPOSTA_MINUTI 7      //imposto valore tempo previsto,in funzione al carico applicato
#define TESTER_LIVE 8         //a riposo è un voltmetro , a seguito dello start avvia il test
#define DATI_INSERITI 9       //espone i dati inseriti al termine dei case di acquisizione

//gestione pulsanti ingresso da libreria
Button start(START);            //creo oggetto pulsante start/avvio
Button selezione(SELEZIONE);    //creo oggetto pulsante selezione/scegli
Button puls_sald(PULS_SALD);    //creo oggetto pulsante selezione/scegli

// variabili ingressi gestiti da utente
bool avvio;                     //avvio/accetta ciclo automatico
bool scegli;                    //scegli stato (case)
bool aumenta;                   //modifica valore scelto aumentandolo
bool diminuisci;                //modifica valore scelto diminuendolo

bool salda;                     //avvia saldatrice


// variabili di tensinoe e corrente batteria da testare
float voltmetro ;              //qui assegno la tensione rilevata sul pin A0
float amperometro ;            //qui assegno la corrente rilevata sul pin A1
float V_nominale;              //dati targa batteria da impostare
float V_minima;                //soglia di interruzione ciclo preimpostato o da impostare
float A_nominale;              //capacità di targa o presunta preimpostata o da impostare
float A_carico;                //potenza applicata dal carico preimpostata se interna da impostare se esterna

// variabili per gestioni e verifiche temporali
unsigned long T_RIFERIMENTO ;  //tengo traccia del tempo
int ora_corrente;              //memorizzo cifra ora corrente
int minuti_correnti;         //memorizzo cifra minuto corrente
int secondi_correnti;          //memorizzo cifra secondo corrente
int ora_fine;                  //inserisco cifra ora fine
int minuti_fine;               //inserisco cifra minuto fine
int secondi_fine;               //inserisco cifra secondi fine
bool raffronto_ore;            //confronto tra ore impostate e ore correnti
bool raffronto_minuti;         //confronto tra minuti impostati e minuti correnti
bool raffronto_secondi;        //confronto tra secondi impostati e secondi correnti
bool raffronto_completo;       //confronto tra tutti i valori impostati

//variabili per gestioni e verifiche tensione e corrente
float contatore = 0.00;        //variabile per impostare valori di tensione da assegnare con decimali
int contatore_ore;
int contatore_minuti;
int ciclo = 0 ;                //varibile (superflua?) per conoscere provenienza del case attuale

//variabili per gestione RTC e temperatura
float temperatura;             //variabile di memorizzazione della temperatura fornito da DS3231
float temp1;                   //variabile di memorizzazione della temperatura in gradi celsius
int digits;                    //variabile dei minuti e dei secondi da esporre sul display lcd

void setup() {

  Serial.begin(9600);         //abilito seriale
  //inizializzo pulsanto "sotto" libreria
  start.begin();
  selezione.begin();
  puls_sald.begin();

  //inizializzo modulo RTC
  temperatura = myRTC.temperature();  // rileva per la prima volta la temperatura
  myRTC.begin();
  setSyncProvider(myRTC.get);   // the function to get the time from the RTC
  if (timeStatus() != timeSet) {
    Serial.println("RTC NON SINCRONIZZATO");
  } else {
    Serial.println("RTC SINCRONIZZATO");
  }

  //inizializzo display LCD
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print(" BATTERY TESTER");
  lcd.setCursor(0, 1);
  lcd.print(" VERSIONE V 1");   //VERSIONE ULTIMA CON SALDAPUNTI
  delay(2000);           //pausa totale di 2 secondi

  //definisco pin scheda
  pinMode (SELEZIONE, INPUT);
  pinMode (START, INPUT);
  pinMode (INCREMENTO, INPUT);
  pinMode (DECREMENTO, INPUT);
  pinMode (CARICO_INTERNO, OUTPUT);
  pinMode (CARICO_ESTERNO, OUTPUT);
  pinMode (LED_BLU, OUTPUT);
  pinMode (LED_VERDE, OUTPUT);
  pinMode (LED_ROSSO, OUTPUT);
  pinMode(PULS_SALD, INPUT);
  pinMode(RELE_SALD, OUTPUT);
  pinMode(POT_SALD, INPUT);

  //aggiorno le variabili temporali
  ora_corrente = hour();
  minuti_correnti = minute();
  secondi_correnti = second();

}
//routine di stampa dati RTC su seriale
void serialeRTC() {
  Serial.print(hour());
  printDigits(minute());
  printDigits(second());
  Serial.print(' ');
  Serial.print(day());
  Serial.print(' ');
  Serial.print(month());
  Serial.print(' ');
  Serial.print(year());
  Serial.println();
}
//routine di stampa cifre mobili su seriale
void printDigits(int digits) {
  Serial.print(':');
  if (digits < 10)
    Serial.print('0');
  Serial.print(digits);
}
//routine di scrittura dati RTC su diplay LCD
void lcdRTC()
{
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("START=");
  lcd.setCursor(8, 0);
  lcd.print(hour());
  digits = (minute());
  lcdDigits();                         // routine esposizione zeri non significativi
  digits = (second());
  lcdDigits();                         // routine esposizione zeri non significativi
  //lcd.print ("  t:");
  //lcd.print (temp1);
}
//routine di scrittura cifre mobili su diplay LCD
void lcdDigits() {
  lcd.print(':');
  if (digits < 10)
    lcd.print('0');
  lcd.print(digits);
}
//routine di scrittura HOME su diplay LCD
void casa() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(" BATTERY TESTER");
  lcd.setCursor(0, 1);
  lcd.print(" SCEGLI OPZIONE");
}
//routine di scrittura esito negativo su diplay LCD
void batteria_ko() {
  digitalWrite(CARICO_INTERNO, LOW);
  digitalWrite(CARICO_ESTERNO, LOW);
  digitalWrite(LED_BLU, LOW);
  digitalWrite(LED_ROSSO, HIGH);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("BATTERIA DA ");
  lcd.setCursor(0, 1);
  lcd.print("BUTTARE   ");
  delay(250);
}
//routine di scrittura esito positivo su diplay LCD
void batteria_ok() {
  digitalWrite(CARICO_INTERNO, LOW);
  digitalWrite(CARICO_ESTERNO, LOW);
  digitalWrite(LED_BLU, LOW);
  digitalWrite(LED_VERDE, HIGH);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("BATTERIA DA ");
  lcd.setCursor(0, 1);
  lcd.print("UTILIZZARE ");
  delay(250);
}
//routine di scrittura test in corso su diplay LCD
void in_scarica() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("SCARICA IN CORSO");
  lcd.setCursor(0, 1);
  lcd.print("V= ");
  lcd.setCursor(3, 1);
  lcd.print(voltmetro);
  lcd.setCursor(8, 1);
  lcd.print("A= ");
  lcd.print(amperometro);
  delay(250);
}
//routine di esposizione dei dati inseriti manualmente
void dati_inseriti() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Vn=");
  lcd.setCursor(3, 0);
  lcd.print(V_nominale);
  lcd.setCursor(8, 0);
  lcd.print("Vm=");
  lcd.setCursor(11, 0);
  lcd.print(V_minima);
  lcd.setCursor(0, 1);
  lcd.print("An=");
  lcd.setCursor(3, 1);
  lcd.print(A_nominale);
  lcd.setCursor(8, 1);
  lcd.print("h");
  lcd.setCursor(9, 1);
  lcd.print(ora_fine);
  lcd.setCursor(11, 1);
  lcd.print("m");
  lcd.setCursor(12, 1);
  lcd.print(minuti_fine);
  delay(250);
}

//routine di scrittura dati mancanti su diplay LCD
void dati_mancanti() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("DATI INCOMPLETI");
  lcd.setCursor(0, 1);
  lcd.print("VERICARE O RESET");
  delay(250);
}

void loop() {

  temperatura = myRTC.temperature();  //rileva la temperatura
  temp1 = temperatura / 4.0;          //trasforma il valore rilevato in gradi celsius
  serialeRTC();                       //lancio stampa su seriale
  voltmetro = analogRead(A0);         //leggo volt
  amperometro = analogRead(A1);       //leggo ampere
  start.read();                       //come da libreria, ad ogno inizio loop leggo
  avvio = start.wasReleased();        //assegno nuovo nome se premuto tasto
  selezione.read();                   //come da libreria, ad ogno inizio loop leggo
  scegli = selezione.wasReleased();   //assegno nuovo nome se premuto tasto
  aumenta = (digitalRead(INCREMENTO) == true); //leggo ingresso stato pulsante classico
  diminuisci = (digitalRead(DECREMENTO) == true); //leggo ingresso stato pulsante classico

  if (scegli) {                        //se cambia variabile su ingresso
    stato_scelto ++;                   //ad ogni pressione e ciclo di loop incremento il valore
    if (stato_scelto > TESTER_LIVE) {  //se arrivo a 8
      stato_scelto = HOME;             //torno a 0
    }
  }
  if (aumenta) {                       //se cambia variabile su ingresso
    contatore = contatore + 0.10;      //ad ogni pressione ,anche prolungata ,incremento il valore
  }
  if ((aumenta) && (stato_scelto == IMPOSTA_ORE))  {  //se cambia variabile su ingresso e sono in questo case
    contatore_ore ++;                                 //aumento valore di 1
    if (contatore_ore >= 24) {                        //se arrivo a 24
      contatore_ore = 0;                              //torno a zero
    }
  }
  if ((aumenta) && (stato_scelto == IMPOSTA_MINUTI)) { //se cambia variabile su ingresso e sono in questo case
    contatore_minuti ++;                               //aumento valore di 1
    if (contatore_minuti >= 60) {                      //se arrivo a 60
      contatore_minuti = 0;                            //torno a zero
    }
  }
  if (diminuisci) {                                    //se cambia variabile su ingresso
    contatore = contatore - 0.10;                      //ad ogni pressione ,anche prolungata ,decremento il valore
  }
  if ((diminuisci) && (stato_scelto == IMPOSTA_ORE))  {//se cambia variabile su ingresso e sono in questo case
    contatore_ore --;                                  //diminuisco valore di 1
    if (contatore_ore <= 0) {                          //se scendo sotto lo zero
      contatore_ore = 24;                              //torno a 24
    }
  }
  if ((diminuisci) && (stato_scelto == IMPOSTA_MINUTI))  {//se cambia variabile su ingresso e sono in questo case
    contatore_minuti --;                                  //diminuisco valore di 1
    if (contatore_minuti <= 0) {                          //se scendo sotto lo zero
      contatore_minuti = 60;                              //torno a 60
    }
  }
  if ((ora_corrente + ora_fine) == hour()) {              //se coincidono ora impostata con ora attuale
    raffronto_ore = true;
  } else {
    raffronto_ore = false;
  }

  if ((minuti_correnti + minuti_fine) == minute()) {       //se coincidono minuti impostati coi minuti attuali
    raffronto_minuti = true;
  } else {
    raffronto_minuti = false;
  }

  if ((secondi_correnti + secondi_fine) == second()) {  //se coincidono secondi impostati coi secondi attuali
    raffronto_secondi = true;
  } else {
    raffronto_secondi = false;
  }

  if ((raffronto_ore == true) && (raffronto_minuti == true)) {
    raffronto_completo = true;
  } else {
    raffronto_completo = false;
  }

  //amperometro live
  float Acslettura = 0.0, campioni = 0.0, media = 0.0; //variabili locali
  for (int a = 0; a < 20; a++) {                       //ricavo 20 valori
    Acslettura = amperometro ;                         //leggo valore ritorno acs712
    campioni = campioni + Acslettura;                  //sommo i valori per calcolare la media
    delay (10);
  }
  media = (campioni / 20);                             //calcolo la media dei valori
  amperometro = (2.5 - (media * (5.0 / 1024.0)) ) / 0.104; //formula per ottenere il valore definitivo
  if (amperometro < 0.10) {                            //se inferiore a 100mA
    amperometro = 0.00;                                //dichiaro 0.00
  }

  // voltmetro live
  float Vlettura = 0.0, Vcampioni = 0.0, Vmedia = 0.0; //variabili locali
  for (int v = 0; v < 20; v++) {                       //ricavo 20 valori
    Vlettura = voltmetro;                              //leggo valore ritorno partitore di tensione
    Vcampioni = Vcampioni + voltmetro;                 //sommo i valori per calcolare la media
    delay (10);
  }
  Vmedia = Vcampioni / 20;                             //calcolo la media dei valori
  voltmetro = ((5.0 / 1024.0) * Vmedia) * ((30 + 7.5) / 7.5);//formula per ottenere il valore definitivo

  //funzioni per saldatrice a punti
  puls_sald.read();
  salda = puls_sald .wasReleased();

  if (salda)
  {
    digitalWrite(RELE_SALD, HIGH);
    delay(map(POT_SALD, 0, 1023, 50, 700)); //tempo ritardo stabilito dal potenziometro
    digitalWrite(RELE_SALD, LOW);
  }
  //fine funzioni per saldatrice a punti

  switch (stato_scelto) {

    case HOME: //schermata iniziale
      casa();
      break;

    case TIPO_1: //BATTERIA Li-ION Vnominale 3,6 A 1,9

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Li-ION 1900mA");
      lcd.setCursor(0, 1);
      lcd.print("SCARICO ?");
      if (avvio) {
        V_nominale = 3.6;
        V_minima = 2.9;
        A_nominale = 1.9;
        A_carico = 0.800;
        ora_fine = 0;   //2h 17minuti [impostato a 2h]
        minuti_fine = 2;
        stato_scelto = TESTER_LIVE;
      }
      break;

    case TIPO_2 :  //BATTERIA Li-ION Vnominale 3,6 A 2,2

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Li-ION 2200mA");
      lcd.setCursor(0, 1);
      lcd.print("SCARICO ?");
      if ((avvio)) {
        V_nominale = 3.6;
        V_minima = 2.9;
        A_nominale = 2.2;
        A_carico = 0.800;
        ora_fine = 0;   //2h 17minuti [impostato a 2h]
        minuti_fine = 5;
        stato_scelto = TESTER_LIVE;
      }
      break;

    case TENSIONE_NOMINALE :  //IMPOSTA TENSIONE NOMINALE

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("IMPOSTA DATI");
      lcd.setCursor(0, 1);
      lcd.print("Vnom=");
      lcd.setCursor(7, 1);
      lcd.print(contatore);
      delay(100);
      if ((contatore != 0.00) && (avvio)) {
        lcd.setCursor(14, 0);
        lcd.print("OK");
        delay(50);
        V_nominale = contatore;
        // contatore = 0.00;
        stato_scelto = TENSIONE_MINIMA;
      }
      break;

    case TENSIONE_MINIMA :  //IMPOSTA TENSIONE MINIMA
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("IMPOSTA DATI");
      lcd.setCursor(0, 1);
      lcd.print("Vmin=");
      lcd.setCursor(7, 1);
      lcd.print(contatore);
      delay(100);
      if ((contatore != 0.00) && (avvio)) {
        lcd.setCursor(14, 0);
        lcd.print("OK");
        delay(50);
        V_minima = contatore;
        //contatore = 0.00;
        stato_scelto = CAPACITA_NOMINALE;
      }
      break;

    case CAPACITA_NOMINALE:  //IMPOSTA CAPACITA NOMINALE
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("IMPOSTA DATI");
      lcd.setCursor(0, 1);
      lcd.print("Anom=");
      lcd.setCursor(7, 1);
      lcd.print(contatore);
      delay(100);
      if ((contatore != 0.00) && (avvio)) {
        lcd.setCursor(14, 0);
        lcd.print("OK");
        delay(50);
        A_nominale = contatore;
        // contatore = 0.00;
        stato_scelto = IMPOSTA_ORE;
      }
      break;

    case IMPOSTA_ORE:  //IMPOSTA TEMPO SCARICA
      //lcdRTC();
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("STOP TRA");
      lcd.setCursor(9, 0);
      lcd.print(contatore_ore);
      lcd.setCursor(11, 0);
      lcd.print("ore");
      if (avvio) {
        ora_fine = contatore_ore;
        lcd.setCursor(14, 0);
        lcd.print("OK");
        delay(50);
        stato_scelto = IMPOSTA_MINUTI;
      }
      break;

    case IMPOSTA_MINUTI:  //IMPOSTA TEMPO SCARICA
      //lcdRTC();
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("STOP TRA");
      lcd.setCursor(9, 0);
      lcd.print(contatore_ore);
      lcd.setCursor(11, 0);
      lcd.print("ore");
      lcd.setCursor(0, 1);
      lcd.print("STOP TRA");
      lcd.setCursor(9, 1);
      lcd.print(contatore_minuti);
      lcd.setCursor(11, 1);
      lcd.print("min");
      if (avvio) {
        minuti_fine = contatore_minuti;
        lcd.setCursor(14, 1);
        lcd.print("OK");
        delay(50);
        stato_scelto = DATI_INSERITI;
      }
      break;

    case TESTER_LIVE :  // TESTER LIVE + CICLO
      //se la tensione letta in campo è maggiore del limite nell'istruzione
      if ((ciclo == 0) && (voltmetro >= 0.8)) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("TENSIONE ");
        lcd.setCursor(0, 1);
        lcd.print("V= ");
        lcd.setCursor(4, 1);
        lcd.print(voltmetro);
        delay(250);
      }
      //se la tensione letta in campo è minore del limite nell'istruzione
      if ((ciclo == 0) && (voltmetro <= 0.8)) {
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("INSERIRE ");
        lcd.setCursor(0, 1);
        lcd.print("BATTERIA");
        delay(250);
      }
      //se la tensione letta in campo è maggiore della minima impostata e comunque diversa da zero premo avvio
      if ((avvio) && (voltmetro >= V_minima) && (ciclo != 4)) {
        digitalWrite(CARICO_INTERNO, HIGH);
        digitalWrite(CARICO_ESTERNO, HIGH);
        digitalWrite(LED_BLU, HIGH);
        ciclo = 1;
      }
      //se nel ciclo di scarica la tensione letta in campo è maggiore della minima impostata
      if ((ciclo == 1) && (voltmetro >= V_minima)) {
        in_scarica();
      }
      //se nel ciclo di scarica il tempo non è trascorso e la tensione minima è stata raggiunta
      if ((ciclo == 1) && (voltmetro <= V_minima) && (raffronto_completo == false)) {
        ciclo = 2;                         //mi serve per impedire l'accavallamento dei due fine ciclo.
        batteria_ko();
      }
      //se nel ciclo di scarica il tempo è trascorso e la tensione minima non è stata raggiunta
      if ((ciclo == 1) && (voltmetro >= V_minima) && (raffronto_completo == true)) {
        ciclo = 3;                           //mi serve per impedire l'accavallamento dei due fine ciclo.
        batteria_ok();
      }
      //se nel ciclo di scarica il tempo è trascorso e la tensione minima è stata raggiunta
      if ((ciclo == 1) && (voltmetro <= V_minima) && (raffronto_completo == true)) {
        ciclo = 3;                           //mi serve per impedire l'accavallamento dei due fine ciclo.
        batteria_ok();
      }
      break;

    case DATI_INSERITI:
      dati_inseriti();
      if (avvio) {
        stato_scelto = TESTER_LIVE;
      }
      break;
  }
}