CITAZIONE (gieffe, 25/10/2018 10:14:04 )

CITAZIONE (Claudio, 24/10/2018 17:43:30 )

gieffe, perché hai usato LM335 e non LM35 e come ho scritto, bisogna cambiare sensore, passando a un digitale.

Ho utilizzato un LM335 perchè è quello che avevo a disposizione nella cassettiera.

Elix ho modificato lo sketch, in modo sicuramente sbagliato e con presumo tanta roba inutile ma funziona, per poter usare il sensore DHT11 più stabile e meno sensibile alle interferenze, per sua caratteristica non cestisce i decimali, dei quali per lo scopo poco importanti, data la mia scarsa competenza puoi vedere se è possibile far si che alla pressione dei tastini di variazione soglia e variazione isteresi avvenga lo scatto per gradi e non per decimali, ci ho provato in mille modi ma non ci arrivo. so de coccio!!!!

Ciao Claudio, se MarcoSnout non mi avesse avvisato non avrei letto questo messaggio...
In ogni caso ho modificato il codice per provare ad assecondare la tua richiesta.
La modifica l'ho fatta senza testare nulla, quindi sarai tu il mio betatester... fammi sapere se ci sono problemi che li aggiustiamo!

Su una riga del codice ho dubbi, quella che riguarda la lettura della temperatura, con l'LM35 la facevo così:

temperatura letta = (100.0 * vref * (float)analogRead(pin)) / 1024.0

formula costruita sulla base della seguente configurazione:

1) L'LM35 restituisce un valore di 10 mV per °C, il "x 100" serve per "trasformare" i 10 mV in un valore corrispondente ai °C, infatti 0,01 V (per °C) x 100 = 1 V (per °C): in pratica è una conversione per conoscere i gradi centrigati partendo da una tensione;

2) Per aumentare la precisione di lettura (l'LM35 a 100°C restituisce 1,00 Volt in uscita) avevamo detto all'ADC di considerare la tensione massima letta a 1,1 Volt (vref = 1.1): in questo modo si aveva una risoluzione di 0,001 V (1 mV, infatti 1,1 V / 1024 valori = 0,00107421875 V), ovvero 0,1 °C anzichè i classici 5 mV (infatti 5,0 V / 1024 valori = 0,0048828125 V), ovvero circa 0,5 °C con riferimento a 5V;

3) Leggendo i decimi di grado avevamo necessità di lavorare coi float.

Il DHT dovrebbe restituire direttamente un valore convertito in °C, quindi la formula che hai utilizzato:

temperatura letta = (290.0 * vref * (float)dht.readTemperature(DHTPIN)) / 1024.0

secondo me non funziona, l'ho modificata semplicemente in:

temperatura letta = (float)dht.readTemperature(DHTPIN))


Controlla se va bene...

A presto, Elix

/*****************************************************************
                 Termostato differenziale digitale
/*****************************************************************
                                by 
                     www.energialternativa.info


*/



//#include <LiquidCrystal.h>                                    // Per display normale
#include <LiquidCrystal_I2C.h>                                  // Per display I2C
#include <EEPROM.h>                                             // Per memorizzare le soglie nella EPROM di Arduino
#include <math.h>

#include <DHT.h>                                                // Libreria per sensore DHT11

#define DHTPIN 4
                                                                // 8 è il pin di Arduino a cui collego il sensore di temperatura digitale
#define DHTTYPE DHT11
                                                                // dht11 è il tipo di sensore che uso
DHT dht(DHTPIN, DHTTYPE);

#define on 6                                                    // Led Verde o Relay NA
#define off 7                                                   // Led Rosso o Relay NC
#define tempP 9                                                 // Pulsante Temperatura "+"
#define tempM 8                                                 // Pulsante Temperatura "-"
#define isterP 10                                               // Pulsante Isterisi "+"
#define isterM 11                                               // Pulsante Isterisi "-"
//#define pin A0                                                // Piedino centrale sensore temp. LM35 analogico


int i;                                                          // variabile per cicli for
int nread = 10;                                                 // Numero di letture effettuate dall'ADC
int Posizione = 12, Direzione = 0;                              // Variabili per lampeggio trattino di running del termostato
int rele = 0;                                                   // Variabile di stato dei relè: 0 = OFF, 1 = ON
int byte0, byte1;                                               // Variabili usate per scrivere/leggere nella Eprom
float vref = 1.1;                                               // ADC 1,1V 
int isteresi;                                                   // Isteresi del termostato: lavoro con int (moltiplicati per 10) per evitare errori di arrotondamenti sui float
int tempSoglia;                                                 // Temperatura di Soglia: lavoro con int (moltiplicati per 10) per evitare errori di arrotondamenti sui float
//float tempLetta;
int tempLettaDHT = dht.readTemperature();
//int h = dht.readHumidity();                                   // Lettura umudità
unsigned long T_Ultima_Lettura, T_Attuale;                      // Variabili per le pause senza blocco dei processi
byte PiuMeno[8] = { B00100, B00100, B11111, B00100,             // Carattere personalizzato ±
                    B00100, B00000, B11111, B00000 }; 
//LiquidCrystal lcd(12, 11, 5, 4, 3, 2);                        // LCD LiquidCrystal D2=D7 - D3=D6 - D4=D5 - D5=D4 - D11=E - D12=RS - VDD=+5 - VO=centrale potenziometro - A=+3V K, VSS, RW=massa
LiquidCrystal_I2C lcd(0x27, 20, 4);                             // Per display I2C


void setup()
{
  pinMode(on, OUTPUT);                                          // Inizializzo i Pin
  pinMode(off, OUTPUT);
  pinMode(tempP, INPUT_PULLUP);
  pinMode(tempM, INPUT_PULLUP);
  pinMode(isterP, INPUT_PULLUP);
  pinMode(isterM, INPUT_PULLUP);
  //analogReference(INTERNAL);                                  // Setto il riferimento per l'ADC al valore interno di 1,1V


  // Leggo la Temperatura Impostata nella Eprom
  byte0 = EEPROM.read(0);
  byte1 = EEPROM.read(1);
  tempSoglia = (byte1 << 8) | byte0;                            // Somma logica del valore di Byte1 spostato a sinistra di 8 bit e di Byte0
  if (tempSoglia < 100 || tempSoglia > 900) tempSoglia = 250;


  // Leggo l'Isteresi Impostata nella Eprom (Ho lasciato 2 Byte nel caso si volesse settare un'steresi maggiore di 25,5 °C)
  byte0 = EEPROM.read(2);
  byte1 = EEPROM.read(3);
  isteresi = (byte1 << 8) | byte0;                              // Somma logica del valore di Byte1 spostato a sinistra di 8 bit e di Byte0
  if (isteresi < 1 || isteresi > 250) isteresi = 3;


  // Per display LCD 20 Colonne, 4 Righe, I2C
  lcd.init();
  lcd.begin(20, 4);
  lcd.backlight();
  lcd.clear();
  lcd.createChar(0, PiuMeno); 


  // Per display LCD 20 Colonne, 4 Righe, normale
  // lcd.begin(20, 4);

  
  // Schermata di avvio del termostato
  lcd.setCursor(5, 1);
  lcd.print("Termostato");
  //lcd.setCursor(2, 1);
  //lcd.print("Digitale");
  lcd.setCursor(4, 2);
  lcd.print("Differenziale");
  lcd.setCursor(1, 0);
  lcd.print("Energialternativa");
  lcd.setCursor(0, 3);
  lcd.print("Start");
  delay(2000);
  for (i = 0; i < 8; i++)
  {
    lcd.print(".");
    delay(200);
  }

// Setto le scritte statiche
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("T.Letta");
  readTemp();
  LCD(0);
  lcd.setCursor(10,0);
  lcd.print((char)223);
  lcd.print("C");
  //lcd.setCursor(14,0);
  //lcd.print("RH");
  
  lcd.setCursor(0,1);
  lcd.print("Rele':       -------");
  
  lcd.setCursor(0,2);
  lcd.print("T. Impost.:");
  LCD(1);
  lcd.setCursor(18,2);
  lcd.print((char)223);
  lcd.print("C");

  lcd.setCursor(0,3);
  lcd.print("Isteresi ");
  lcd.write(byte(0));
  lcd.print(":");
  LCD(2);
  lcd.setCursor(18,3);
  lcd.print((char)223);
  lcd.print("C");
  
}



void loop()
{
  T_Attuale = millis();
  if (T_Attuale - T_Ultima_Lettura > 500)                       // Attendo 0,5 secondi
  {
    readTemp();                                                 // Leggo la temperatura
    attivaRele();                                               // Setto i relè
    LCD(0);                                                     // Aggiorno i valori sull'LCD
    T_Ultima_Lettura = T_Attuale;
  }

  // Modifica Temperatura Centro Soglia da 10 a 90 °C
  if(digitalRead(tempM) == LOW && tempSoglia > 10)
  {
    tempSoglia--;
    LCD(1);                                                     // Scrivo sull'LCD
    
    // Salvo il valore nella Eprom
    byte0 = tempSoglia & 255;                                   // Con un prodotto logico per 255 ottengo gli 8 bit meno significativi
    byte1 = (tempSoglia >> 8) & 255;                            // Con uno spostamento a sinistra ed il prodotto logico ottengo gli 8 bit più significativi
    EEPROM.write(0, byte0);
    EEPROM.write(1, byte1);

    delay(150);
  }
  if(digitalRead(tempP) == LOW && tempSoglia < 90)
  {
    tempSoglia++;
    LCD(1);                                                     // Scrivo sull'LCD
    
    // Salvo il valore nella Eprom
    byte0 = tempSoglia & 255;                                   // Con un prodotto logico per 255 ottengo gli 8 bit meno significativi
    byte1 = (tempSoglia >> 8) & 255;                            // Con uno spostamento a sinistra ed il prodotto logico ottengo gli 8 bit più significativi
    EEPROM.write(0, byte0);
    EEPROM.write(1, byte1);

    delay(150);
  }

  // Modifica Isteresi (da +/- 1 a +/- 25 °C)
  if(digitalRead(isterM) == LOW && isteresi > 1)
  {
    isteresi--;
    LCD(2);                                                     // Scrivo sull'LCD
    
    // Salvo il valore nella Eprom
    byte0 = isteresi & 255;                                     // Con un prodotto logico per 255 ottengo gli 8 bit meno significativi
    byte1 = (isteresi >> 8) & 255;                              // Con uno spostamento a sinistra ed il prodotto logico ottengo gli 8 bit più significativi
    EEPROM.write(2, byte0);
    EEPROM.write(3, byte1);

    delay(150);
  }
  
  if(digitalRead(isterP) == LOW && isteresi < 25)
  {
    isteresi++;
    LCD(2);                                                     // Scrivo sull'LCD
    
    // Salvo il valore nella Eprom
    byte0 = isteresi & 255;                                     // Con un prodotto logico per 255 ottengo gli 8 bit meno significativi
    byte1 = (isteresi >> 8) & 255;                              // Con uno spostamento a sinistra ed il prodotto logico ottengo gli 8 bit più significativi
    EEPROM.write(2, byte0);
    EEPROM.write(3, byte1);

    delay(150);
  }

}



void readTemp()                                                 // Leggo la temperatura facendo la media di 10 letture
{
  float somma = 0.0;
 
  for (i = 0; i < nread; i++)
  {
    // somma += (100.0 * vref * (float)analogRead(pin)) / 1024.0;           // Per LM35
    
    // somma += (290.0 * vref * (float)dht.readTemperature(DHTPIN)) / 1024.0;                   // *** Secondo me questa riga non va bene, l'ho modificata come sotto:
    somma += (float)dht.readTemperature(DHTPIN));
    delay(10);
  }
  // tempLetta = somma / (float)nread;                                     // per LM35
  tempLettaDHT = (int)(somma / (float)nread);
}



void LCD(int valore)                                            // Scrivo i valori sull'LCD: 0 = Temperatura Letta + Animazione, 1 = Temperatura Impostata, 2 = Isteresi Impostata, 3 = Stato Relè
{
  switch (valore) {
    case 1:                                                     // Temperatura Impostata
      lcd.setCursor(13, 2);
      lcd.print(tempSoglia);
      break;

    case 2:                                                     // Isteresi Impostata
      lcd.setCursor(13, 3);
      if (isteresi < 100) lcd.print(" ");
      lcd.print(isteresi);
    break;

    case 3:                                                     // Stato Relè
      lcd.setCursor(7, 1);
      if (rele == 0) lcd.print("OFF");
      else lcd.print("ON ");
    break;

    default:                                                    // Temperatura Letta
      lcd.setCursor(7, 0);
      if (tempLettaDHT < 10) lcd.print("  ");
      else if (tempLettaDHT < 100) lcd.print(" ");
      //lcd.print(tempLetta, 1);                                // Per LM35
      lcd.print(tempLettaDHT);
      
      if (Direzione == 0)                                       // Animazione "Supercar"
      {
        lcd.setCursor(Posizione, 1);
        lcd.print("- ");
        Posizione++;
        if (Posizione == 18) Direzione = 1;
      }
      if (Direzione == 1)
      {
        lcd.setCursor(Posizione, 1);
        lcd.print(" -");
        if (Posizione == 14) Direzione = 0;
        else Posizione--;
      }
    break;
  }
}


void attivaRele()                                               // Imposto i relè
{
  // if(tempLetta < (float)tempSoglia/10 - (float)isteresi/10)  // Per LM35
  if(tempLettaDHT < tempSoglia - isteresi)                      // Soglia Inferiore -
  {
    digitalWrite(on, HIGH);
    digitalWrite(off, LOW);
    rele = 0;
    LCD(3);
  }
  // if(tempLetta > (float)tempSoglia/10 + (float)isteresi/10  // Per LM35
  if(tempLettaDHT > tempSoglia + isteresi)                     // Soglia Superiore +
  {
    digitalWrite(on, LOW);
    digitalWrite(off, HIGH);
    rele = 1;
    LCD(3);
  }
}

Confermo che la lettura del DHT si fa come detto da BellaEli

Non avevo dubbi di aver scritto ca**te

Provo subito.
Grazie

Provato, con il mio legge bene la temperatura 23° ma ha i decimali, il tuo non ha i decimali, legge 75° e la T impostata parte da 241° e non va sotto i 100°, mentre isteresi OK

mi chiedo se vi è un motivo particolare per non usare la libreria disponibile per arduino.

Quale??

Ultima versione perfettamente funzionante, anche con igrometro, resta solo da togliere i decimali, per chi è capace, io no.

Scusa, come non detto. Ho letto il listato, la libreria è stata usata, mi hanno tratto in inganno i punti 1 e 2 dell'ultimo messaggio di elix.

Il programma é scritto nel modo di chi ha studiato programmazione e non come l'avrei fatto io da semplice autodidatta.

Riguardo i decimali, quale é il tuo desiderio, eliminarli completamente o lasciarne solo uno?

Nel primo caso prova a sostituire t = dht.readTemperature() con t = round(dht.readTemperature()); ma ricordati di aggiungere nelle dichiarazioni iniziali anche

 #include <math.h>  

CITAZIONE (calcola, 10/11/2018 07:00:15 )

CITAZIONE (calcola, 10/11/2018 07:00:15 )

Nulla di fatto purtroppo!!!

Capito il problema, vorresti vedere il valore della temperatura senza decimali sull'LCD

/*****************************************************************
                 Termostato differenziale digitale
/*****************************************************************
                                by 
                     www.energialternativa.info
*/
#include <LiquidCrystal_I2C.h>                                  // Per display I2C
#include <EEPROM.h>                                             // Per memorizzare le soglie nella EPROM di Arduino
#include <math.h>
#include <DHT.h>                                                // Libreria per sensore DHT11

#define DHTPIN 2                                                // E' il pin di Arduino a cui collego il sensore di temperatura digitale
#define DHTTYPE DHT11                                           // dht11 è il tipo di sensore che uso

#define on 6                                                    // Led Verde o Relay NA
#define off 7                                                   // Led Rosso o Relay NC
#define tempP 9                                                 // Pulsante Temperatura "+"
#define tempM 8                                                 // Pulsante Temperatura "-"
#define isterP 10                                               // Pulsante Isterisi "+"
#define isterM 11                                               // Pulsante Isterisi "-"

DHT dht(DHTPIN, DHTTYPE);

int i;                                                          // variabile per cicli for
int Posizione = 12, Direzione = 0;                              // Variabili per lampeggio trattino di running del termostato

int rele = 0;                                                   // Variabile di stato dei relè: 0 = OFF, 1 = ON
int byte0, byte1;                                               // Variabili usate per scrivere/leggere nella Eprom

int isteresi;                                                   // Isteresi del termostato: lavoro con int (moltiplicati per 10) per evitare errori di arrotondamenti sui float
int tempSoglia;                                                 // Temperatura di Soglia: lavoro con int (moltiplicati per 10) per evitare errori di arrotondamenti sui float

int t = dht.readTemperature();                                  // Lettura temperatura
int h = dht.readHumidity();                                     // Lettura umudità

unsigned long T_Ultima_Lettura, T_Attuale;                      // Variabili per le pause senza blocco dei processi
byte PiuMeno[8] = { B00100, B00100, B11111, B00100,             // Carattere personalizzato ±
                    B00100, B00000, B11111, B00000 }; 
LiquidCrystal_I2C lcd(0x27, 20, 4);                             // Per display I2C


void setup()
{
  pinMode(on, OUTPUT);                                          // Inizializzo i Pin
  pinMode(off, OUTPUT);
  pinMode(tempP, INPUT_PULLUP);
  pinMode(tempM, INPUT_PULLUP);
  pinMode(isterP, INPUT_PULLUP);
  pinMode(isterM, INPUT_PULLUP);
  
  // Leggo la Temperatura Impostata nella Eprom
  byte0 = EEPROM.read(0);
  byte1 = EEPROM.read(1);
  tempSoglia = (byte1<<8) | byte0;                              // Somma logica del valore di Byte1 spostato a sinistra di 8 bit e di Byte0
  if (tempSoglia < 10 || tempSoglia > 900) tempSoglia = 25;


  // Leggo l'Isteresi Impostata nella Eprom (Ho lasciato 2 Byte nel caso si volesse settare un'steresi maggiore di 25,5 °C)
  byte0 = EEPROM.read(2);
  byte1 = EEPROM.read(3);
  isteresi = (byte1<<8) | byte0;                                // Somma logica del valore di Byte1 spostato a sinistra di 8 bit e di Byte0
  if (isteresi < 1 || isteresi > 250) isteresi = 3;


  // Per display LCD 20 Colonne, 4 Righe, I2C
  lcd.init();
  lcd.begin(20, 4);
  lcd.backlight();
  lcd.clear();
  lcd.createChar(0, PiuMeno); 

  
  // Schermata di avvio del termostato
  lcd.setCursor(5, 1);
  lcd.print("Termostato");
  //lcd.setCursor(2, 1);
  //lcd.print("Digitale");
  lcd.setCursor(4, 2);
  lcd.print("Differenziale");
  lcd.setCursor(1, 0);
  lcd.print("Energialternativa");
  lcd.setCursor(0, 3);
  lcd.print("Start");
  delay(1000);
  for (i = 0; i < 8; i++)
  {
    lcd.print(".");
    delay(200);
  }

// Setto le scritte statiche
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("T.Letta");
  readTemp();
  LCD(0);
  lcd.setCursor(10,0);
  lcd.print((char)223);
  lcd.print("C");
  
  lcd.setCursor(14,0);
  lcd.print("RH");
  
  lcd.setCursor(0,1);
  lcd.print("Relay       -------");
  
  lcd.setCursor(0,2);
  lcd.print("T. Impost.:");
  LCD(1);
  lcd.setCursor(18,2);
  lcd.print((char)223);
  lcd.print("C");

    lcd.setCursor(0,3);
  lcd.print("Isteresi ");
  lcd.write(byte(0));
  lcd.print(":");
  LCD(2);
  lcd.setCursor(18,3);
  lcd.print((char)223);
  lcd.print("C");
  
}



void loop()
{
  int h = dht.readHumidity();                                   // Dato umudità
  lcd.setCursor(17, 0);
  lcd.print(h);
  
  T_Attuale = millis();
  if (T_Attuale - T_Ultima_Lettura > 500)                       // Attendo 0,5 secondi
  {
    readTemp();                                                 // Leggo la temperatura
    attivaRele();                                               // Setto i relè
    LCD(0);                                                     // Aggiorno i valori sull'LCD
    T_Ultima_Lettura = T_Attuale;
  }
    // Modifica Temperatura Centro Soglia da 10 a 90 °C
  if(digitalRead(tempM) == LOW && tempSoglia > 100)
  {
    tempSoglia--;
    LCD(1);                                                     // Scrivo sull'LCD
    
    // Salvo il valore nella Eprom
    byte0 = tempSoglia & 255;                                   // Con un prodotto logico per 255 ottengo gli 8 bit meno significativi
    byte1 = (tempSoglia >> 8) & 255;                            // Con uno spostamento a sinistra ed il prodotto logico ottengo gli 8 bit più significativi
    EEPROM.write(0, byte0);
    EEPROM.write(1, byte1);

    delay(150);
  }
  if(digitalRead(tempP) == LOW && tempSoglia < 900)
  {
    tempSoglia++;
    LCD(1);                                                     // Scrivo sull'LCD
    
    // Salvo il valore nella Eprom
    byte0 = tempSoglia & 255;                                   // Con un prodotto logico per 255 ottengo gli 8 bit meno significativi
    byte1 = (tempSoglia >> 8) & 255;                            // Con uno spostamento a sinistra ed il prodotto logico ottengo gli 8 bit più significativi
    EEPROM.write(0, byte0);
    EEPROM.write(1, byte1);

    delay(150);
  }

  // Modifica Isteresi (da +/- 0,1 a +/- 25 °C)
  if(digitalRead(isterM) == LOW && isteresi > 1)
  {
    isteresi--;
    LCD(2);                                                     // Scrivo sull'LCD
    
    // Salvo il valore nella Eprom
    byte0 = isteresi & 255;                                     // Con un prodotto logico per 255 ottengo gli 8 bit meno significativi
    byte1 = (isteresi >> 8) & 255;                              // Con uno spostamento a sinistra ed il prodotto logico ottengo gli 8 bit più significativi
    EEPROM.write(2, byte0);
    EEPROM.write(3, byte1);

    delay(150);
  }
  
  if(digitalRead(isterP) == LOW && isteresi < 250)
  {
    isteresi++;
    LCD(2);                                                     // Scrivo sull'LCD
    
    // Salvo il valore nella Eprom
    byte0 = isteresi & 255;                                     // Con un prodotto logico per 255 ottengo gli 8 bit meno significativi
    byte1 = (isteresi >> 8) & 255;                              // Con uno spostamento a sinistra ed il prodotto logico ottengo gli 8 bit più significativi
    EEPROM.write(2, byte0);
    EEPROM.write(3, byte1);

    delay(150);
  
  }

}

void readTemp()                                                 // Leggo la temperatura
{
  float (dht.readTemperature());
  t = dht.readTemperature();
}


void LCD(int valore)                                            // Scrivo i valori sull'LCD: 0 = Temperatura Letta + Animazione, 1 = Temperatura Impostata, 2 = Isteresi Impostata, 3 = Stato Relè
{
  switch (valore) {
    case 1:                                                     // Temperatura Impostata
      lcd.setCursor(13,2);
      lcd.print((float)tempSoglia/10, 1);
      break;

    case 2:                                                     // Isteresi Impostata
      lcd.setCursor(13,3);
      if (isteresi < 100) lcd.print(" ");
      lcd.print((float)isteresi/10, 1);
    break;

    case 3:                                                     // Stato Relè
      lcd.setCursor(7,1);
      if (rele == 0) lcd.print("OFF");
      else lcd.print("ON ");
    break;

    default:                                                    // Temperatura Letta
      lcd.setCursor(7,0);
      if (t < 10.0) lcd.print("  ");
      else if (t < 100.0) lcd.print(" ");
      lcd.print(round(t));
      

      
      if (Direzione == 0)                                       // Animazione "Supercar"
      
      
      {
        lcd.setCursor(Posizione, 1);
        lcd.print("- ");
        Posizione++;
        if (Posizione == 18) Direzione = 1;
      }
      if (Direzione == 1)
      {
        lcd.setCursor(Posizione, 1);
        lcd.print(" -");
        if (Posizione == 14) Direzione = 0;
        else Posizione--;
      }
    break;
  }
}


void attivaRele()                                                // Imposto i relè
{
    if(t < (float)tempSoglia/10 - (float)isteresi/10)            // Soglia Inferiore -
  {
    digitalWrite(on, HIGH);
    digitalWrite(off, LOW);
    rele = 0;
    LCD(3);
  }
    if(t > (float)tempSoglia/10 + (float)isteresi/10)            // Soglia Superiore +
  {
    digitalWrite(on, LOW);
    digitalWrite(off, HIGH);
    rele = 1;
    LCD(3);
  }
}