Memorizar en EEPROMTemperatura Negativa [SOLUCIONADO]

Hola a todos.

Tengo estoy con un termómetro el cual quiero que deje registrada tanto la temperatura máxima como la mínima. Para ello lo indica en la pantalla y lo memoriza en la Eeprom evitando así que se elimine la información a desconectarse o fallar la alimentación.

El funcionamiento es correcto en todo excepto cuando la temperatura a registrar es Negativa o bajo cero.

Es decir, si la temperatura mínima llega a 0º no hay problema, se queda indicando que ha llegado a 0º o los que correspondan (siempre hasta 0º o superior)

Pero si baja a negativo, ejemplo a -2º, la mínima alcanzada baja hasta los -2º (CORRECTO), pero según va subiendo la temperatura sube a la vez la mínima alcanzada (FALLO), hasta llegar está a 0º, aunque la temperatura siga subiendo.

Lo que indicaría que la temperatura mínima ha sido de 0º cuando realmente ha bajado hasta -2º

El problema es ese, que cuando baja a negativo la minima baja a su vez, pero según va subiendo la temperatura también lo hace la que indica la mínima alcanzada, cosa que no es realmente lo que debe indicar.

Dejo aqui el sketch de como va por ahora. Saludos y gracias.

#include <EEPROM.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd (0x27, 20, 4);
#include "DHT.h"

#define DHTPIN 17         //Conectamos el Sensor al pin 17
#define DHTTYPE DHT22     // Sensor DHT22
DHT dht(DHTPIN, DHTTYPE);

const int reset = 14; //Resetea temperaturas memorizadas
int statoreset = 0;

float MIN;
float MAX;



void setup() {
  Wire.begin();
  lcd.begin(20, 4);
  lcd.clear();
  lcd.backlight();
  dht.begin();




  pinMode(reset, INPUT);
  digitalWrite(14, HIGH);

  //EEPROM
  MIN = EEPROM.read(1);
  MAX = EEPROM.read(2);

}



void loop() {

  float h = dht.readHumidity();
  float t = dht.readTemperature();
 
  // Comprobando el fallo en el sensor.
  if (isnan(h) || isnan(t)) {
    lcd.setCursor (12, 0);
    lcd.print("ERROR"); 
  }
  else {
    lcd.setCursor (12, 0);         
    lcd.print("     ");
  }


  /////////////// TEMPERATURA (POSICIONAR EN EL LCD) \\\\\\\\\\\\\\\\\\\\\\\\\\\
 
  lcd.setCursor (5, 0);           // Posicion cursor 
  lcd.print(t, 1);                // Temperatura con decimal
  lcd.print((char)223);           // Simbolo "º" gradosº
  lcd.print (" ");                // Un espacio




  /////////////// HUMEDAD (POSICIONAR EN EL LCD) \\\\\\\\\\\\\\\\\\\\\\\\\\\

  lcd.setCursor (5, 1);// Posicion cursor 
  lcd.print(h, 1);      // Humedad con decimal
  lcd.print("%");       // Simbolo %
  lcd.print(" ");       // Un espacio



  //Posicionar texto
  lcd.setCursor(0, 0);
  lcd.print ("TEMP");
  lcd.setCursor(0, 1);
  lcd.print ("HUME");
  

/////////////// Temperatura Máxima mínima registrada \\\\\\\\\\\\\\\\

  lcd.setCursor(0, 2);
  lcd.print ("MAX");
  lcd.setCursor(5, 2);
  lcd.print(MAX, 1);
  lcd.print((char)223);           // Simbolo "º" gradosº


  lcd.setCursor(0, 3);
  lcd.print ("MIN");
  lcd.setCursor(5, 3);
  lcd.print(MIN, 1);
  lcd.print((char)223);           // Simbolo "º" gradosº

  


 
  
  /////////////// Borrar temperatura memorizada \\\\\\\\\\\\\\\\
  
  statoreset = digitalRead (reset);
 
  if ( statoreset == HIGH)
  { MIN = t;
    MAX = t;
  }

//////// EEPROM \\\\\
  
  if (t > MAX)
  { MAX = t;
    EEPROM.write(2, t);
  }
  
   if (t < MIN)
  { MIN = t;
    EEPROM.write(1, t);
  }

  delay(100);
}

¿Qué tienes conectado en el pin 14?
Porque sospecho que tu problema está acá

  statoreset = digitalRead (reset);
 
  if ( statoreset == HIGH)
  { MIN = t;
    MAX = t;
  }

para resetear la temperatura cuando se necesite

Yo mas me inclino sobre como guardas los datos en la eeprom
Yo cambiaría esto (lectura)

  //EEPROM
  MIN = EEPROM.read(1);
  MAX = EEPROM.read(2);

// por esto
  //EEPROM
  MIN = EEPROM.read(0);
  MAX = EEPROM.read(0+sizeof(MIN));
El problema que veo es que la longitud de un float (offset) no es 1.
Creo que es 4 pero usando sizeof nunca me ha importado
Y para la escritura sería algo como:
//para MIN
EEPROM.write(0, t); 
//para MAX
EEPROM.write(sizeof(t), t);
En resumen: Has hecho un solape de datos en el mismo punto de la memoria por lo que te pueden salir datos "raros"

Saludos

La EEPROM trabaja a nivel Byte. Cuando haces EEPROM.write(2, t), a pesar que t es un float de 4 Bytes, solo almacenas uno.
Lo mismo cuando haces read, solo lees un Byte. Tienes que utilizar la función EEPROM.put() y EEPROM.get() para almacenar toda la variable, teniendo en cuenta su tamaño en bytes para seleccionar el punto donde empezar a grabar .
Saludos

Bueno @bosoft me ganó aunque mi forma de resolverlo no es con EEPROM.write (y ahora me doy cuenta que no fue el sino tu el que la usó) sino con EEPROM.put y EEPROM.get

EEPROM.write graba de a byte y como bosoft te dijo, un float ocupa 4 bytes.

En cambio EEPROM.put y EEPROM.get lo hacen de acuerdo al tamaño de la variable utilizada, sea cual sea.

#include <EEPROM.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd (0x27, 20, 4);
#include "DHT.h"

#define DHTPIN 17         //Conectamos el Sensor al pin 17
#define DHTTYPE DHT22     // Sensor DHT22
DHT dht(DHTPIN, DHTTYPE);

const int reset = 14; //Resetea temperaturas memorizadas
int statoreset = 0;

float minT;
float maxT;
int eeAddress1 = 0;
int eeAddress2 = sizeof(float);


void setup() {
  Wire.begin();
  lcd.begin(20, 4);
  lcd.clear();
  lcd.backlight();
  dht.begin();

  pinMode(reset, INPUT);
  digitalWrite(14, HIGH);

  //EEPROM
  EEPROM.get(eeAddress1, minT);
  eeAddress = sizeof(float);
  EEPROM.get(eeAddress2, maxT);
}

void loop() {

  float h = dht.readHumidity();
  float t = dht.readTemperature();
 
  // Comprobando el fallo en el sensor.
  if (isnan(h) || isnan(t)) {
    lcd.setCursor (12, 0);
    lcd.print("ERROR");
  }
  else {
    lcd.setCursor (12, 0);         
    lcd.print("     ");
  }

  /////////////// TEMPERATURA (POSICIONAR EN EL LCD) \\\\\\\\\\\\\\\\\\\\\\\\\\\
  lcd.setCursor (5, 0);           // Posicion cursor
  lcd.print(t, 1);                // Temperatura con decimal
  lcd.print((char)223);           // Simbolo "º" gradosº
  lcd.print (" ");                // Un espacio

  /////////////// HUMEDAD (POSICIONAR EN EL LCD) \\\\\\\\\\\\\\\\\\\\\\\\\\\
  lcd.setCursor (5, 1);// Posicion cursor
  lcd.print(h, 1);      // Humedad con decimal
  lcd.print("%");       // Simbolo %
  lcd.print(" ");       // Un espacio

  //Posicionar texto
  lcd.setCursor(0, 0);
  lcd.print ("TEMP");
  lcd.setCursor(0, 1);
  lcd.print ("HUME");
 
  /////////////// Temperatura Máxima mínima registrada \\\\\\\\\\\\\\\\
  lcd.setCursor(0, 2);
  lcd.print ("maxT");
  lcd.setCursor(5, 2);
  lcd.print(maxT, 1);
  lcd.print((char)223);           // Simbolo "º" gradosº


  lcd.setCursor(0, 3);
  lcd.print ("minT");
  lcd.setCursor(5, 3);
  lcd.print(minT, 1);
  lcd.print((char)223);           // Simbolo "º" gradosº

  /////////////// Borrar temperatura memorizada \\\\\\\\\\\\\\\\
 
  statoreset = digitalRead (reset);
 
  if ( statoreset == HIGH)  { 
      minT = t;
      maxT = t;
  }

  //////// EEPROM \\\\\
 
  if (t > maxT) { 
      maxT = t;
      EEPROM.put(eeAddress2, maxT);
  }
 
  if (t < minT)  { 
      minT = t;
      EEPROM.write(eeAddress1, minT);
  }

  delay(100);
}

Si cambias la dirección inicial de eeAdrress1 la eeAdrress2 se ajusta sola.

Rectifico la informacion (no se si abrir un hilo nuevo y borrar este)
surbyte, PeterKantTropus, bosoft gracias por las respuestas.

La cosa es que solamente lo hace con datos negativos.

La situación está asi.:

Todo funciona correctamente excepto lo de dejar memorizado datos negativos. PERO,

  • Trabaja correctamente,
  • Baja la temperatura a la que sea la minima registrada,
  • Si se deja asi, o sea no se desenchufa, se queda memorizada en pantalla la minima alcanzada (correcto)
  • Si se desconecta y se vuelve a conectar,
  • En caso de que la temperatura actual aún sea menor de 0º marca esa temperatura menor a 0º
  • En caso que sea igual o mayor a 0º (aunque sean 25º), marca 0º (y queda memorizado en la eeprom)

Resumen es que si es menor de 0º no se queda guardado, pero si es igual o mayor de 0º si que se guardada.
Y la máxima se guarda siempre.

bosoft probé pero no me funciona, incluso me marca temperaturas raras de 255, como si estuviera desconectado el sensor.

PeterKantTropus algo de esto debe ser, pero sigo sin dar en el clavo.

surbyte hay un fallo al compilar en
//EEPROM
EEPROM.get(eeAddress1, minT);
eeAddress = sizeof(float); Me dice que no está indicado.
EEPROM.get(eeAddress2, maxT);

Yo le puse eeAddress1 sin saber si es correcto, y me monta los numeros que no se puede ver nada de nada en pantalla, incluido un nanº de estos de como si el sensor está desconectado.

Si, exácto, te estás olvidando de cómo se almacenan los número binarios negativos, que es el origen del problema. Necesitas todas esas posiciones de memoria, como te han indicado, para que el binario negativo funcione (recuerda que en informática no existe el int ni el float ni el chat, es todo binario).
Estás perdiendo esa información, dale espacio en memoria es tdodo lo que necesita

Upsss. Perdón. Me limité a copiar sin pensar.
Me refería a EEPROM.put y EEPROM.get

Saludos

Tienes que hacer un "click" y pensar en Bytes, Si quieres almacenar un Float debes "reservar" 4 Bytes de memoria EEprom y utilizar EEPROM.put(0,t) desde la posición cero se escriben 4 bytes, entonces el próximo dato a guardar tiene que estar desplazado 4 Bytes EEPROM.put(4,t) . Y para leerlos EEPROM.get(0) yEEPROM.get(4)

De echo te recomiendo, además de lo que dice @PeterKantTropus, que si no vas justo de memoria, siempre dejes espacio libre, al menos un byte, ayuda mucho cuando el micro tiene que hacer acarreos, a programación a bajo nivel (lo hace el C++ por ti), yo me he llevado sorpresas en el pasado por que el micro se tomaba "libertades" para hacer acarreos, y para números negativos, en ensamblador, los acarreos son más que constantes.

El Double son 8 en DUE y ESP32, podrías trabajar pensando que vas a usar doubles por si luego quieres cambiar algo, teniendo presente que sólo quieres guardar pocos datos, yo nos apretaría, así hasta puedes cambiar de arduino a ESP32 o cualquier otra cosa y no te colisiona nada, aunque claro, en DUE (que no tiene) y ESP32 (que hay que agragársela) grabar en eprom es otra cosa.

http://robots-argentina.com.ar/didactica/uso-de-la-eeprom-de-arduino/

Te pongo un ejemplo que yo he usado en el pasado (aunque para controladores numéricos no en Arduino que no me ha hecho falta):

  • Empiezo en posición 0
  • La siguiente en posición 10 (+10)
  • La siguiente en posición 10 (+10 +10)

De echo, mis variables se llamaban (si no recuerdo mal) MEM0, MEM10, MEM20. No tuve que usar más.
Simplifica mucho el código para leerlo después y no tienes que estar haciendo sumas constantes para ver donde estás, pero como te digo, si te sobra memoria.

Para grabar 4 datos, te sobra espacio, no apretes las cosas, date margen siempre que puedas

me corrijo

#include <EEPROM.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd (0x27, 20, 4);
#include "DHT.h"

#define DHTPIN 17         //Conectamos el Sensor al pin 17
#define DHTTYPE DHT22     // Sensor DHT22
DHT dht(DHTPIN, DHTTYPE);

const int reset = 14; //Resetea temperaturas memorizadas
int statoreset = 0;

float minT;
float maxT;
int eeAddress1 = 0;
int eeAddress2 = 0;


void setup() {
  Wire.begin();
  lcd.begin(20, 4);
  lcd.clear();
  lcd.backlight();
  dht.begin();

  pinMode(reset, INPUT);
  digitalWrite(14, HIGH);

  //EEPROM
  EEPROM.get(eeAddress1, minT);
  eeAddress2 = eeAddress1 + sizeof(float);
  EEPROM.get(eeAddress2, maxT);
}

void loop() {

  float h = dht.readHumidity();
  float t = dht.readTemperature();
 
  // Comprobando el fallo en el sensor.
  if (isnan(h) || isnan(t)) {
    lcd.setCursor (12, 0);
    lcd.print("ERROR");
  }
  else {
    lcd.setCursor (12, 0);        
    lcd.print("     ");
  }

  /////////////// TEMPERATURA (POSICIONAR EN EL LCD) \\\\\\\\\\\\\\\\\\\\\\\\\\\
  lcd.setCursor (5, 0);           // Posicion cursor
  lcd.print(t, 1);                // Temperatura con decimal
  lcd.print((char)223);           // Simbolo "º" gradosº
  lcd.print (" ");                // Un espacio

  /////////////// HUMEDAD (POSICIONAR EN EL LCD) \\\\\\\\\\\\\\\\\\\\\\\\\\\
  lcd.setCursor (5, 1);// Posicion cursor
  lcd.print(h, 1);      // Humedad con decimal
  lcd.print("%");       // Simbolo %
  lcd.print(" ");       // Un espacio

  //Posicionar texto
  lcd.setCursor(0, 0);
  lcd.print ("TEMP");
  lcd.setCursor(0, 1);
  lcd.print ("HUME");
 
  /////////////// Temperatura Máxima mínima registrada \\\\\\\\\\\\\\\\
  lcd.setCursor(0, 2);
  lcd.print ("maxT");
  lcd.setCursor(5, 2);
  lcd.print(maxT, 1);
  lcd.print((char)223);           // Simbolo "º" gradosº


  lcd.setCursor(0, 3);
  lcd.print ("minT");
  lcd.setCursor(5, 3);
  lcd.print(minT, 1);
  lcd.print((char)223);           // Simbolo "º" gradosº

  /////////////// Borrar temperatura memorizada \\\\\\\\\\\\\\\\
 
  statoreset = digitalRead (reset);
 
  if ( statoreset == HIGH)  {
      minT = t;
      maxT = t;
  }

  //////// EEPROM \\\\\
 
  if (t > maxT) {
      maxT = t;
      EEPROM.put(eeAddress2, maxT);
  }
 
  if (t < minT)  {
      minT = t;
      EEPROM.write(eeAddress1, minT);
  }

  delay(100);
}

Va por buen camino, como dijisteis todos el problema estaba en esa parte. Gracias como siempre surbyte ahora así creo que si funciona. La eeprom aún no la entiendo muy bien pero esto me ayudará a entenderla un poco más.
Ya parece que funciona pero se me monta el texto, no me obedece en las lineas de lcd, lo desordena y por mucho que intento decirle coloca esto en esta linea y fila, hay dos partes que es imposible, da igual lo que haga que no se mueve.
Sigo con ello a ver porque hace esto …

Bien ahora te explico como manejarse con el texto en un LCD.
Lo primero es no asustarse con lo que te voy a sugerir.
Son una serie de elementos que permiten imprimir siempre del mismo modo.
Si algo sale mal con corregir el formato se corrige todo.

#include <EEPROM.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd (0x27, 20, 4);
#include "DHT.h"

#define DHTPIN 17         //Conectamos el Sensor al pin 17
#define DHTTYPE DHT22     // Sensor DHT22
DHT dht(DHTPIN, DHTTYPE);

const int reset = 14; //Resetea temperaturas memorizadas
int statoreset = 0;

float minT;
float maxT;
int eeAddress1 = 0;
int eeAddress2 = 0;
bool imprimirError = false;

void setup() {
  Wire.begin();
  lcd.begin(20, 4);
  lcd.clear();
  lcd.backlight();
  dht.begin();

  pinMode(reset, INPUT);
  digitalWrite(14, HIGH);

  //EEPROM
  EEPROM.get(eeAddress1, minT);
  eeAddress2 = eeAddress1 + sizeof(float);
  EEPROM.get(eeAddress2, maxT);
}

void loop() {
  char* buffn="";  //Cadena donde almacenaremos el número convertido
  char buffer[20]=" "; //Buffer de la cadena donde se devuelve todo, número formateado y cadena concatenada
  //                01234567890123456789
  char *formatoT = "%4s %4s%c %s"; //Cadena con la mascara a convertir Temperatura
  char *formatoH = "%4s %4s%  %s"; //Cadena con la mascara a convertir Humedad
  
  
    
  float h = dht.readHumidity();
  float t = dht.readTemperature();
 
  // Comprobando el fallo en el sensor.
  if (isnan(h) || isnan(t)) 
      imprimirError = true;
  else 
      imprimirError = false;
  

  /////////////// TEMPERATURA (POSICIONAR EN EL LCD) \\\\\\\\\\\\\\\\\\\\\\\\\\\
  lcd.setCursor (5, 0);             // Posicion cursor
  dtostrf(t,4,2,buffn); //Llamada a la función
  sprintf(buffer, formatoT, "TEMP", buffn, (char) 223,imprimirError?"ERROR":"     ");
  lcd.print(buffer);                // Un espacio

  /////////////// HUMEDAD (POSICIONAR EN EL LCD) \\\\\\\\\\\\\\\\\\\\\\\\\\\
  lcd.setCursor (5, 1);             // Posicion cursor
  dtostrf(h,4,2,buffn); //Llamada a la función
  sprintf(buffer, formatoH, "HUME", buffn, imprimirError?"ERROR":"     ");  // Humedad con decimal
  lcd.print(buffer);                // Un espa
  
  /////////////// Temperatura Máxima mínima registrada \\\\\\\\\\\\\\\\
  lcd.setCursor(0, 2);
  dtostrf(maxT,4,2,buffn); //Llamada a la función
  sprintf(buffer, formatoT, "maxT", buffn, (char) 223,"     ");
  lcd.print(buffer);                // Un espacio


  lcd.setCursor(0, 3);
  dtostrf(minT,4,2,buffn); //Llamada a la función
  sprintf(buffer, formatoT, "maxT", buffn, (char) 223,"     ");
  lcd.print(buffer);                // Un espacio
  /////////////// Borrar temperatura memorizada \\\\\\\\\\\\\\\\
 
  statoreset = digitalRead (reset);
 
  if ( statoreset == HIGH)  {
      minT = t;
      maxT = t;
  }

  //////// EEPROM \\\\\
 
  if (t > maxT) {
      maxT = t;
      EEPROM.put(eeAddress2, maxT);
  }
 
  if (t < minT)  {
      minT = t;
      EEPROM.write(eeAddress1, minT);
  }

  delay(100);
}

Se requieren algunas variables de uso local

 char* buffn="";

como en arduino no se puede imprimir flotantes existe una función llamada dtostr que convierte un flotante a string o cadena de caracteres.
Para hacerlo hay que indicar la variable float, los digitos totales, los digitos decimales que en tu caso sera solo 1, y el alojamiento del string o sea el nombre de la variable que almacene ese float convertido en string, que en nuestro caso ser+a buffn.
Tus float seran t de temperatura, h de humedad, maxT y minT de max y min temperatura almacenados en la EEPROM.
EL LCD tiene en tu caso 20 caracteres de columna y 4 filas. Entonces defino otra variable con los 20 caracteres.

  char buffer[20]=" ";

ahora vamos a usar otra función que en lo personal me gusta mucho, que es sprintf()
Esta función permite luego presentar algo del modo que yo quiero y de forma estricta.
Para ello existen toda una manera de imprimir cosas
Las cadenas o string se imprimen con %s
Los enteros con %d
Un caracteres se presenta con %c o sea el caso de tu ° (simbolo del grado Celcius).
Los float con %f pero en Arduino esto no funciona y deja un vacio asi que queda reservado para micros mas grandes, sorpresa un ESP8266 si lo permite pero un DUE que tiene espacio no.
Cuando armo mi formato de presentación me gusta poner una linea con los números de 0 al 20 y no uso la decena sino que siempre uso unidades. Observa que ubico las cosas de 0 a 19 o sea 20 caracteres que es el largo de tu LCD

// 01234567890123456789
char *formatoT = “%4s %4s%c %s”; //Cadena con la mascara a convertir Temperatura
char *formatoH = “%4s %4s% %s”; //Cadena con la mascara a convertir Humedad

Tu presentas “TEMP” o “HUME” por eso comienzo dejando 4 espacios al comienzo
Luego va el float convertido a string
Luego va ° para temp o % para humedad, y luego depende haya o no error se muestra la leyenda ERROR
Para ello uso una variable imprimirError que se pone en true cuando es verdadero y false cuando es Falsa obviamente.
Pero aprovechando que con su valor logico puedo presentar uno u otro valor uso esto

imprimirError?"ERROR":"        ";

entonces si imprimirError es true mostrará ERROR de lo contrario saldrá vacío.

No lo he probado en un LCD asi que es posible que se haya deslizado algun pequeño error, me avisas si es el caso.

Interesante eso que me comentas surbyte, la verdad no tenia ni idea, siempre lo he colocado todo de forma manual asignando linea y fila donde quiero colocarlo, aún me queda muchisimo que aprender pues desconozco tantas cosas.

Tendré que mirar y practicar esa forma. Aquí lo curioso es que la temperatura normal me la dejaba en dos lineas, la maxima montaba ese texto (max) con parte de la temperatura medida, y la minima si la colocaba bien. Por mucho que le decia quiero esto aqui, no hacía absolutamente nada, siempre lo dejaba igual.

la solución fue eliminar todo lo de pantalla de temperatura maxima, y volver a escribirlo pero a continuación de la minima, ordenandolo posteriormente, pero así ya si me lo situó. No sé que le pasó pero es como si eso lo hubiera bloqueado.

Dejo tal como lo probé que funcionaba correctamente, tanto temperaturas positivas, como negativas, memorizando todo el la Eeprom, y borrando todo cuando se necesite, ya que más adelante la intención es sumarle unos leds, y un reloj, de ahí la pantalla 20x04.

Lo que ya no sé si consumirá mucha Eeprom (escritura y borrado), que supongo y entiendo que no, y que solamente lo hará en cada borrado o en cada vez que llegue a máximo y mínimo que creará un registro.

Muchas gracias a todos los que me habéis ayudado.

#include <EEPROM.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd (0x3f, 20, 4);
#include "DHT.h"

#define DHTPIN 5         //Conectamos el Sensor al pin 5
#define DHTTYPE DHT22     // Sensor DHT22
DHT dht(DHTPIN, DHTTYPE);

const int reset = 4; //Resetea temperaturas memorizadas
int statoreset = 0;

float MIN;
float MAX;
int eeAddress1 = 0;
int eeAddress2 = 0;


void setup() {
  Wire.begin();
  lcd.begin(20, 4);
  lcd.clear();
  lcd.backlight();
  dht.begin();


  pinMode(reset, INPUT); //
  digitalWrite(4, HIGH); // Boton de borrado de temperatura

  //EEPROM
  EEPROM.get(eeAddress1, MIN);
  eeAddress2 = eeAddress1 + sizeof(float);
  EEPROM.get(eeAddress2, MAX);
}

void loop() {

  float t = dht.readTemperature();
 
 
  /////////////// TEMPERATURA (POSICIONAR EN EL LCD) \\\\\\\\\\\\\\\\\\\\\\\\\\\
    //Posicionar texto y temperatura actual
  lcd.setCursor(0, 0);
  lcd.print ("TEMP");
 lcd.print ("");                // Un espacio

  lcd.print(t, 1);                // Temperatura con decimal
  lcd.print((char)223);           // Simbolo "º" gradosº
  lcd.print (" ");                // Un espacio

/////////////// Temperatura Máxima registrada \\\\\\\\\\\\\\\\
 
  lcd.setCursor(0, 1);
  lcd.print ("MAX");
  lcd.print (" ");                // Un espacio

  lcd.print(MAX, 1);
  lcd.print((char)223);  
  lcd.print (" ");                // Un espacio

 
/////////////// Temperatura Mínima registrada \\\\\\\\\\\\\\\\
   
  lcd.setCursor(8, 1);
  lcd.print ("MIN");
  lcd.print (" ");                // Un espacio

  lcd.print(MIN, 1);
  lcd.print((char)223);           // Simbolo "º" gradosº
  lcd.print ("  ");                // Dos espacios para borrar siempre º grados

 
  


  /////////////// Borrar temperatura memorizada \\\\\\\\\\\\\\\\
 
  statoreset = digitalRead (reset);
 
  if ( statoreset == HIGH)  // Si pulso "Resetear"
  {
      MIN = t; // Minima ahora es la actual
      MAX = t; // Máxima ahora es la actual
      
     EEPROM.put(eeAddress1,t);  // Ahora guarda la actual minima en la EEPROM
     EEPROM.put(eeAddress2, t); // Ahora guarda la actual máxima en la EEPROM
  }
  }

  //////// EEPROM \\\\\
 
  if (t > MAX) {
      MAX = t;
      EEPROM.put(eeAddress2, t); // Memoriza la máxima
  }
 
  if (t < MIN)  {
      MIN = t;
      EEPROM.put(eeAddress1,t);  // Memoriza la minima
  }

  delay(100);
}

Puedes reescribir la eprom hasta que te aburras la verdad, por aquí hay gente que ha comentado que lo ha hecho hasta 1.000.000 de veces, pero si tienes problemas, cambias el inicio de la memoria que usas y continuas grabando en otro lado (por eso yo hacía de 10 en 10), hasta que te la comas toda por uso puede pasar una década casi seguro

Otra cosa que he aprendido entonces, ya que pensaba que si se gastaba por utilizarla mucho ya no se podía utilizar más. Muchas gracias TonyDiana

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.