Es mi primera vez. Supongo que se notará.
Pretendo hacer un contador de horas para unas máquinas. Es muy simple. Un contacto da una señal de que está en marcha y el Arduino debe contar las horas que está en marcha cada una de ellas. El tema está en que pueden estar varias horas, incluso días.
He leído mucho al respecto y he descartado la función millis() por el tema del desbordamiento.
Al final me he decantado por lo más simple, el delay. Pero ocurre un problema, y es que, cuando lleva varias horas en marcha, se pone a contar hacia atrás, con signo negativo. Lo veo a través de un display i2c.
Adjunto el código de los contadores para si me podéis echar una mano, si es que el problema reside en él.
Agradezco cualquier sugerencia, pues mi nivel es "subterráneo".
Saludos desde la Costa Blanca.
//Pantalla 20x4
//Librerias necesarias
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,20,4);
//Asignamos variables globales
int contador1;
int contador2;
int contador3;
int contador4;
int minutos1;
float minutos2;
int minutos3;
int minutos4;
float horas1;
float horas2;
float horas3;
float horas4;
void setup()
{
//Iniciamos retroiluminación
lcd.backlight();
//Iniciamos la pantalla
lcd.init();
}
void loop()
{
lcd.clear();//Limpiamos LCD
lcd.print("B1 Tanque ");
contador1++;
minutos1 = contador1/60.00;
horas1 = minutos1/60.00;
lcd.print(horas1);
lcd.setCursor(0,1);
lcd.print("B2 Tanque ");
contador2++;
minutos2 = contador2/60.00;
horas2 = minutos2/60.00;
lcd.print(minutos2++);
lcd.setCursor(0,2);
lcd.print("B1 ByPass ");
lcd.print(contador3++);
lcd.setCursor(0,3);
lcd.print("B2 Bypass ");
lcd.print(contador4++);
//Esperamos un segundo para que reinicie el ciclo
delay(1000);
}
Una variable int tiene un valor de -32,768 a 32,767 por lo que incrementandola cada segundo ,tienes 3600 segundos por hora ,con lo que la parte positiva se desborda en 32767/3600= 9 horas y pico y pasa a la parte negativa.tienes el tipo unsigned long que te daria un rango de 0 a 4,294,967,295 lo que te daria para unos cuantos dias...
Galiana, la verdad que tu código merece varias correcciones.
No se para que usas float en el medio de cuentas que no lo requieren.
Como bien has dicho, solo necesitas millis() pero millis() trae otro problema que es que se puede cortar la energía y se va a poner a 0 y perderás la cuenta.
Yo lo que haría en tu caso sería usar un RTC DS3231 y trabajar con variables de tiempo.
Arranca tomo la hora, se detiene calculo las horas en marcha y salvo en la misma NVRAM del DS3231 y asi sucesivamente.
No hago cuentas raras, no trabajo con enteros largos o millis().
Te cuesta un módulo RTC nada mas.
Todo lo demás tedrá muchos trucos de software (grabar en EEPROM) o backup de baterías para evitar que se quede sin energía o bien controlar el rebalsamiento de millis().
Buscándote una solución fácil encontré esto CountUPDOWNTimer trabaja bajo el concepto que buscas, pero requiere arduino funcionando siempre, asi que si la máquina pasa dias detenida, debes tomar algun criterio para no perder la información.
Yo consideraría guardar los datos en EEPROM. Tienes 100k de grabaciones disponibles. Antes que superes eso seguramente tiraran tu contador o reemplazarán la máquina.
Muchas gracias por el apoyo. Como he dicho, soy muy novato en esto. Voy a seguir probando con todas las opciones que me dais. Espero encontrar una que funcione al 100%. Os agradezco las molestias.
Respecto al float, lo uso para que me de las horas con decimales. Supongo que esa es la manera correcta.
Seguro que se podrá corregir bastante.
Hola de nuevo. Ya tengo hecho el contador. También le he puesto una sonda de temperatura. Ahora me viene el problema de almacenar los datos flloat de los contadores en una eeprom i2c que he comprado. He leído que se puede comparar el valor y escribirlo solo si ha cambiado.
Hay alguien que me pueda indicar?
bueno esa tarea es fácil.
tu valor es A en float de modo que cada vez que A <> B haces el cambio y además guardas el elemento a comparar B con el valor de A. Asi
// cuando defines B lo inicas a 0.0
float A, B = 0.0;
// supongamos que A es temperatura
if (A != B) { // Edite <> que no se aplica en Arduino
B = A; // Almacenas B con el valor de A de manera que al siguiente paso no guarda nada.
}
El problema es que A puede variar decimas de grado y eso será un valor distinto e intentará guardarlo.
Debes entonces tener un criterio de cuanto debe cambiar A respecto de B.
digamos entonces que si A varia +-1 grado, entonces si lo grabo en la EEPROM.
Entonces la cosa cambia.
Ahora haces la diferencia entre A y B
// cuando defines B lo inicas a 0.0
float A, B = 0.0;
float TOL = 1.0; // supongo toleracia +-1 grado para guardar en eeprom
// supongamos que A es temperatura
if (abs(A-B) > TOL) {
B = A; // Almacenas B con el valor de A de manera que al siguiente paso no guarda nada.
}
creo que esa version ya incorpora los nuevos metodos para la eeprom .get() y .put() que permiten grabar y leer cualquier tipo de variable: https://www.arduino.cc/en/Reference/EEPROM
