Ayuda con programa para terrario

Hola a todos,
Primero de todo me presento, soy delineante industrial, mi sector no tiene nada que ver con la electrónica pero de siempre me ha atraído este mundillo, hay que decir que no tengo ni idea de electrónica y lo que aprendo es a base de leer foros como este.
Gracias a un foro dedicado a las mascotas descubrí el mundo de Arduino, para mi fue un gran descubrimiento y me decidí a empezar un proyecto, en concreto automatizar un ternario tropical.
Las funciones que le quiero dar son las siguientes:
-Encender y apagar luces según horario.
-Encender bomba de riego cada 2 horas durante 30seg.
-Encender bombilla de calor según temperatura.
Todo esto visualizado en una pantalla LCD de 128x64
Mi problema es poder visualizar en la pantalla los reles que están encendidos y poder encender la bomba de riego por un tiempo establecido.
Gracias de antemano por vuestra colaboración.

El código que llevo de momento es este:

/////////////////////////////////////////////////////////////////////////////////
// ARCHIVO: Programa_terrario.ino
// AUTOR: Sergio Sanchez
// PROPOSITO: Manejar y controlar un terrario.
// VERSION: 0.01
// FECHA: 12/2013
////////////////////////////////////////////////////////////////////////////////

#include <Wire.h> //libreria Arduino
#include <EEPROM.h> //libreria para poder escribir y leer en la memoria no volatil de Arduino
#include <DHT.h> //libreria de sensor de humedad y temperatura
#include <RTClib.h> //libreria del reloj
#include <U8glib.h> //libreria de la pantalla LCD

//Pines de los reles
#define TEMPIN 2 //pin donde esta conectado el sensor de temperatura y humedad
#define TEMPTIPO DHT21 // DHT 21 (AM2301) define el sensor montado
#define raptorPin 30 // pin digital de salida para Bonbilla Raptor
#define ceramicaPin 31 // pin digital de salida para Bombilla ceramica
#define infrarojosPin 32 // pin digital de salida para Bombilla de infrarojos
#define lluviaPin 33 // pin digital de salida para Bomba de lluvia
#define bombaPin 34 // pin digital de salida para Bomba inferior
#define vacio1Pin 35 // pin digital de salida vacio
#define vacio2Pin 36 // pin digital de salida vacio
#define vacio3Pin 37 // pin digital de salida vacio

RTC_DS1307 Reloj; // Crea el objeto Reloj
U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
DHT dht(2, DHT21); //tipo de sensor de temperatura y humedad
float t; //define la vafiable flotante temperatura
float h; //define la vafiable flotante humedad

void draw(void) {
u8g.setFont(u8g_font_5x8);
u8g.drawStr( 2, 9, "TEMP");
u8g.drawCircle(46, 4, 1);
u8g.drawStr( 3, 18, "HUM");
u8g.drawCircle(44, 13, 1);
u8g.drawCircle(47, 16, 1);
u8g.drawLine(43,17,48,12);
u8g.drawStr( 101, 9, "RELES");
u8g.drawStr( 100, 20, "lu");
u8g.drawStr( 100, 28, "ce");
u8g.drawStr( 100, 36, "in");
u8g.drawStr( 101, 44, "ag");
u8g.drawStr( 101, 52, "bo");
u8g.drawStr( 100, 60, "va");
u8g.drawFrame(0,0,128,64); //Cuadrado general
u8g.drawLine(0,20,98,20); //Separacion temperatura con diagrama
u8g.drawLine(51,0,51,20); //Separacion temperatura con fecha
u8g.drawLine(98,0,98,63); //Separacion fecha con reles
u8g.drawFrame(74,16,2,2); //Posicion puntos reloj
u8g.drawFrame(74,13,2,2); //Posicion puntos reloj
u8g.drawPixel(64,8); //Posicion puntos fecha
u8g.drawPixel(75,8); //Posicion puntos fecha
}

void setup () {
Serial.begin(57600);
Wire.begin();
dht.begin();
// Reloj.begin(); // Inicia la comunicación con el RTC
// Reloj.adjust(DateTime(DATE, TIME)); // Establece la fecha y hora del PC

pinMode(raptorPin, OUTPUT); //Define el Pin como salida
pinMode(ceramicaPin, OUTPUT); //Define el Pin como salida
pinMode(infrarojosPin, OUTPUT); //Define el Pin como salida
pinMode(lluviaPin, OUTPUT); //Define el Pin como salida
// pinMode(bombaPin, OUTPUT); //Define el Pin como salida
// pinMode(vacio1Pin, OUTPUT); //Define el Pin como salida
// pinMode(vacio2Pin, OUTPUT); //Define el Pin como salida
// pinMode(vacio3Pin, OUTPUT); //Define el Pin como salida
}

void loop() {
Serial.begin(9600);
float h = dht.readHumidity(); //Obtiene la humedad
float t = dht.readTemperature(); //Obtiene la temperatura
DateTime now = Reloj.now(); //Obtiene la fecha y hora del RTC

u8g.firstPage();
do {
draw();
u8g.setPrintPos(24, 9);
u8g.print(t, 1);
u8g.setPrintPos(22, 18);
u8g.print(h, 1);
u8g.setPrintPos(54, 9);
u8g.print(now.day(), DEC);
u8g.setPrintPos(65, 9);
u8g.print(now.month(), DEC);
u8g.setPrintPos(77, 9);
u8g.print(now.year(), DEC);
u8g.setPrintPos(62, 18);
u8g.print(now.hour(), DEC);
u8g.setPrintPos(79, 18);
u8g.print(now.minute(), DEC);
// u8g.drawBox(119,31,7,5); //infrarojos
// u8g.drawFrame(111,31,7,5); //infrarojos
// u8g.drawBox(119,39,7,5); //lluvia
// u8g.drawFrame(111,39,7,5); //lluvia
// u8g.drawBox(119,47,7,5); //bomba
// u8g.drawFrame(111,47,7,5); //bomba
// u8g.drawBox(119,55,7,5); //vacio1
// u8g.drawFrame(111,55,7,5); //vacio1
}
while( u8g.nextPage() );

//La luz se enciende de 9 a 21
if ( 9 >= now.hour() && now.hour() <= 20 ) {
digitalWrite(raptorPin, HIGH); // luces on
} else {
digitalWrite(raptorPin, LOW); // luces off
}

//La ceramica se enciende de 22 a 8
if ( 21 >= now.hour() && now.hour() <= 8 ) {
digitalWrite(ceramicaPin, HIGH); // ceramica on
} else {
digitalWrite(ceramicaPin, LOW); // ceramica off
}

//Activar infrarojos segun la temperatura minima de 25º y maxima de 32º
if (t > 32)
{digitalWrite (infrarojosPin, LOW);}
if (t < 25)
{digitalWrite (infrarojosPin, HIGH);}

delay (3000);
}

Programa_terrario.ino (5.07 KB)

Hola, Gladieitor. Veo que tienes bastante código escrito, así que los problemas que mencionas están un poco "diluidos" entre tanta línea. Centrándome en los dos problemas que refieres, el de representar el estado de los pines de los diferentes relés creo que no debería revestir complicación. Bien almacenas el estado actual cuando lo cambies en una variable, y a la hora de pintarlo consultas dicha variable como encendido o apagado, o bien (no estoy seguro del todo, pero casi) puedes hacer digitalread del pin, aunque sea de salida, y te devuelve el estado actual.
Respecto del segundo problema (el del programar encendidos y apagados), no es la primera (ni será la última ;))vez que se trata en el foro. Entiendo que lo difícil a veces es encontrarlo. En este hilo, por ejemplo, tratamos un problema similar y desarrollé la solución que tomé en su día para mí. Tal vez te sirva.
Saludos.

Gracias por contestar noter, estoy intentando crear el código con las indicaciones que me has dado pero de momento estoy en la fase de copia y pega y el crear se me hace muy costoso. Espero que con tus indicaciones y una revisión mas afondo del foro logre llevar a cabo mi pequeño proyecto.
Saludos y muchas gracias por la colaboración.
Sergio

Ok.
Si tienes alguna duda no dudes en preguntar.
Saludos

Tema pantalla solucionado, gracias por el aporte, había dejado esa orden de lado porque no era capaz de hacerla funcionar, os dejo parte del código que he puesto.

if(digitalRead(raptorPin) == HIGH)
{
u8g.drawBox(119,15,7,5); //raptor
}
else
{
u8g.drawFrame(111,15,7,5); //raptor
}
Saludos

Buenas de nuevo,
Noter al final te tengo que pedir ayuda, he estado mirando el código que me comentaste del otro post y he intentado insertarlo en el mio, de momento no he podido compilarlo, me da un error a la hora de decirle al programa la hora que tiene que utilizar para el myTimer, quizás me dejo algo evidente pero mi experiencia, como te dije, es nula en programación, te dejo el trozo de código donde se queja.

  myTimer::setHora(now.hour,now.minute,now.second);

El error este:

Programa_terrario.ino: In function 'void loop()':
Programa_terrario:139: error: no matching function for call to 'myTimer::setHora(, , )'
Programa_terrario.ino:47: note: candidates are: static void myTimer::setHora(unsigned int, unsigned int, unsigned int)

Saludos y gracias.

No estaría de más que especificaras el código que tienes hasta ahora y qué error te está dando el compilador. No creo que sea muy complicado de solventar, pero primero he de saber qué problema hay.
Saludos.

El error que me da es este:

Programa_terrario.ino: In function 'void loop()':
Programa_terrario:139: error: no matching function for call to 'myTimer::setHora(, , )'
Programa_terrario.ino:47: note: candidates are: static void myTimer::setHora(unsigned int, unsigned int, unsigned int)

Y el código que tengo ahora mismo es este, te lo separo en dos zonas que no me deja cargarlo todo:

///////////////////////////////////////////////////////////////////////////////// 
//   ARCHIVO: Programa_terrario.ino
//     AUTOR: Sergio Sanchez
// PROPOSITO: Manejar y controlar un terrario.
//   VERSION: 0.01
//     FECHA: 12/2013
////////////////////////////////////////////////////////////////////////////////

#include "Wire.h"    //libreria Arduino
#include "EEPROM.h"  //libreria para poder escribir y leer en la memoria no volatil de Arduino
#include "DHT.h"     //libreria de sensor de humedad y temperatura
#include "RTClib.h"  //libreria del reloj
#include "U8glib.h"  //libreria de la pantalla LCD
         
//Pines de los reles
#define TEMPIN 2            //pin donde esta conectado el sensor de temperatura y humedad
#define TEMPTIPO DHT21      // DHT 21 (AM2301) define el sensor montado
#define raptorPin       30  // pin digital de salida para Bonbilla Raptor
#define ceramicaPin     31  // pin digital de salida para Bombilla ceramica
#define infrarojosPin   32  // pin digital de salida para Bombilla de infrarojos
#define lluviaPin       33  // pin digital de salida para Bomba de lluvia
#define bombaPin        34  // pin digital de salida para Bomba inferior
#define vacio1Pin       35  // pin digital de salida vacio
#define vacio2Pin       36  // pin digital de salida vacio
#define vacio3Pin       37  // pin digital de salida vacio

RTC_DS1307 Reloj;                        // Crea el objeto Reloj
U8GLIB_ST7920_128X64_4X u8g(18, 16, 17); // SPI Com: SCK = en = 18, MOSI = rw = 16, CS = di = 17
DHT dht(2, DHT21);                       //tipo de sensor de temperatura y humedad
float t;                                 //define la vafiable flotante temperatura
float h;                                 //define la vafiable flotante humedad 

class myTimer{

private:
  static long segActual;    // Variable en la que se guarda en forma de segundos la hora actual para comparar con los objetos timer.
  long segEncendido;        // segundo del día en el que se enciende el timer. Las 00:00:00 == 0; las 00:01:00==60, las 23:59:59==86399.
  long segDuracion;         // segundos que durará encendido el relé correspondiente.

public:
  void setInicio(unsigned int hora, unsigned int minuto=0, unsigned int segundo=0){
    segEncendido=hora*3600+minuto*60+segundo;
  };
  void setDuracion(unsigned horas, unsigned minutos=0, unsigned segundos=0){
    segEncendido=horas*3600+minutos*60+segundos;
  };
  static void setHora(unsigned hora, unsigned minuto, unsigned segundo){
    segActual=hora*3600 + minuto*60 + segundo;
  };
  bool getActivado(void){
    long segDesdeEncendido = segActual-segEncendido;   //restamos el segundo del día de encendido
    if (segDesdeEncendido<0) segDesdeEncendido+=86400; // Si los segundos transcurridos son negativos sumamos un día, con lo que obtenemos los transcurridos desde el teórico encendido de ayer, que ya serán positivos.
    // Ya sólo queda comprobar que los segundos transcurridos sean menores a la duración de encendido del timer
    return (segDesdeEncendido<segDuracion);
  };
};
long myTimer::segActual=0;

////////////////////////////////////////////////////
//Control de los valores estaticos de la pantalla//
////////////////////////////////////////////////////
void draw(void) {
  u8g.setFont(u8g_font_5x8);
  u8g.drawStr( 2, 9, "TEMP");  
  u8g.drawCircle(46, 4, 1);
  u8g.drawStr( 3, 18, "HUM");
  u8g.drawCircle(44, 13, 1);
  u8g.drawCircle(47, 16, 1);
  u8g.drawLine(43,17,48,12);
  u8g.drawStr( 101, 9, "RELES");
  u8g.drawStr( 100, 20, "lu");  
  u8g.drawStr( 100, 28, "ce");
  u8g.drawStr( 100, 36, "in");
  u8g.drawStr( 101, 44, "ag");
  u8g.drawStr( 101, 52, "bo");
  u8g.drawStr( 100, 60, "va");
  u8g.drawFrame(0,0,128,64);    //Cuadrado general
  u8g.drawLine(0,20,98,20);     //Separacion temperatura con diagrama
  u8g.drawLine(51,0,51,20);     //Separacion temperatura con fecha
  u8g.drawLine(98,0,98,63);     //Separacion fecha con reles
  u8g.drawFrame(74,16,2,2);     //Posicion puntos reloj
  u8g.drawFrame(74,13,2,2);     //Posicion puntos reloj
  u8g.drawPixel(64,8);          //Posicion puntos fecha
  u8g.drawPixel(75,8);          //Posicion puntos fecha
}

Aquí esta el setup y el loop:

void setup () {
  Serial.begin(57600);
  Wire.begin();
  dht.begin();
  //    Reloj.begin(); // Inicia la comunicación con el RTC
  //    Reloj.adjust(DateTime(__DATE__, __TIME__)); // Establece la fecha y hora del PC

  pinMode(raptorPin, OUTPUT);      //Define el Pin como salida 
  pinMode(ceramicaPin, OUTPUT);    //Define el Pin como salida 
  pinMode(infrarojosPin, OUTPUT);  //Define el Pin como salida
  pinMode(lluviaPin, OUTPUT);      //Define el Pin como salida
  pinMode(bombaPin, OUTPUT);       //Define el Pin como salida
  pinMode(vacio1Pin, OUTPUT);      //Define el Pin como salida
  //    pinMode(vacio2Pin, OUTPUT);      //Define el Pin como salida
  //    pinMode(vacio3Pin, OUTPUT);      //Define el Pin como salida

  digitalWrite(raptorPin, LOW);
  digitalWrite(ceramicaPin, LOW);
  digitalWrite(infrarojosPin, LOW);
  digitalWrite(lluviaPin, LOW);
  digitalWrite(bombaPin, LOW);
  digitalWrite(vacio1Pin, LOW);
  digitalWrite(vacio2Pin, LOW);
  digitalWrite(vacio3Pin, LOW);

  ////////////////////
  //Control de riego//
  ////////////////////
  myTimer tRiego1,tRiego2,tRiego3,tRiego4,tRiego5,tRiego6; 

  tRiego1.setInicio(10);           //inicio a las 10:00:00
  tRiego1.setDuracion(0,0,20);     //Duración 20 segundos
  tRiego2.setInicio(12);           //inicio a las 12:00:00
  tRiego2.setDuracion(0,0,20);     //Duración 20 segundos
  tRiego3.setInicio(14);           //inicio a las 14:00:00
  tRiego3.setDuracion(0,0,20);     //Duración 20 segundos
  tRiego4.setInicio(16);           //inicio a las 16:00:00
  tRiego4.setDuracion(0,0,20);     //Duración 20 segundos
  tRiego5.setInicio(18,10);           //inicio a las 18:00:00
  tRiego5.setDuracion(0,0,20);     //Duración 20 segundos
  tRiego6.setInicio(20);           //inicio a las 20:00:00
  tRiego6.setDuracion(0,0,20);     //Duración 20 segundos

}  

void loop() {
  Serial.begin(9600);
  float h = dht.readHumidity();      //Obtiene la humedad
  float t = dht.readTemperature();   //Obtiene la temperatura
  DateTime now = Reloj.now();        //Obtiene la fecha y hora del RTC

  myTimer::setHora(now.hour,now.minute,now.second); // Aquí le enviaríamos la hora obtenida de nuestro reloj.

  ////////////////////////////////////////////////////
  //Control de lols valores dinamicos de la pantalla//
  ////////////////////////////////////////////////////
  u8g.firstPage();  
  do {
    draw();
    u8g.setPrintPos(24, 9);
    u8g.print(t, 1);
    u8g.setPrintPos(22, 18);
    u8g.print(h, 1);
    u8g.setPrintPos(54, 9);
    u8g.print(now.day(), DEC);
    u8g.setPrintPos(65, 9);
    u8g.print(now.month(), DEC);
    u8g.setPrintPos(77, 9);
    u8g.print(now.year(), DEC);
    u8g.setPrintPos(62, 18);
    u8g.print(now.hour(), DEC);
    u8g.setPrintPos(79, 18);
    u8g.print(now.minute(), DEC);
    if(digitalRead(raptorPin) == HIGH) 
    { 
      u8g.drawBox(119,15,7,5);           //raptor
    } 
    else 
    { 
      u8g.drawFrame(111,15,7,5);         //raptor 
    } 
    //    u8g.drawBox(119,15,7,5);           //raptor
    //    u8g.drawFrame(111,15,7,5);         //raptor
    if(digitalRead(ceramicaPin) == HIGH) 
    { 
      u8g.drawBox(119,23,7,5);           //ceramica
    } 
    else 
    { 
      u8g.drawFrame(111,23,7,5);         //ceramica 
    } 
    //    u8g.drawBox(119,23,7,5);           //ceramica
    //    u8g.drawFrame(111,23,7,5);         //ceramica
    if(digitalRead(infrarojosPin) == HIGH) 
    { 
      u8g.drawBox(119,31,7,5);           //infrarojos
    } 
    else 
    { 
      u8g.drawFrame(111,31,7,5);         //infrarojos 
    } 
    //    u8g.drawBox(119,31,7,5);           //infrarojos
    //    u8g.drawFrame(111,31,7,5);         //infrarojos
    if(digitalRead(lluviaPin) == HIGH) 
    { 
      u8g.drawBox(119,39,7,5);           //lluvia
    } 
    else 
    { 
      u8g.drawFrame(111,39,7,5);         //lluvia 
    } 
    //    u8g.drawBox(119,39,7,5);           //lluvia
    //    u8g.drawFrame(111,39,7,5);         //lluvia
    if(digitalRead(bombaPin) == HIGH) 
    { 
      u8g.drawBox(119,47,7,5);           //bomba
    } 
    else 
    { 
      u8g.drawFrame(111,47,7,5);         //bomba 
    } 
    //    u8g.drawBox(119,47,7,5);           //bomba
    //    u8g.drawFrame(111,47,7,5);         //bomba
    if(digitalRead(vacio1Pin) == HIGH) 
    { 
      u8g.drawBox(119,55,7,5);           //vacio1
    } 
    else 
    { 
      u8g.drawFrame(111,55,7,5);         //vacio1 
    }
    //    u8g.drawBox(119,55,7,5);           //vacio1
    //    u8g.drawFrame(111,55,7,5);         //vacio1
  }
  while( u8g.nextPage() );

  /////////////////////////////////////////////////////
  //Control de la Raptor, a luz se enciende de 9 a 21//
  /////////////////////////////////////////////////////
  if ( now.hour() >= 9 && now.hour() <= 20 ) {
    digitalWrite(raptorPin, HIGH); // luces on
  } 
  else {
    digitalWrite(raptorPin, LOW);  // luces off
  }

  //////////////////////////////////////////////////////////
  //Control de la bombilla ceramica, se enciende de 21 a 8//
  //////////////////////////////////////////////////////////
  if ( now.hour() >= 21 && now.hour() <= 8 ) {
    digitalWrite(ceramicaPin, HIGH); // ceramica on
  } 
  else {
    digitalWrite(ceramicaPin, LOW);  // ceramica off
  }

  //////////////////////////////////////////////////////////////////////////////////////
  //Control de la bombilla de infrarojos, la temperatura minima de 25º y maxima de 32º//
  //////////////////////////////////////////////////////////////////////////////////////
  if (t > 32)
  {
    digitalWrite (infrarojosPin, LOW);
  }
  if (t < 25)
  {
    digitalWrite (infrarojosPin, HIGH);
  }

  delay (1000);
}

Gracias por tu tiempo para ayudarme.

Saludos

Hola.
No sé exactamente qué librería RTC estás utilizando, así que no sé qué tipo de datos contiene now. Prueba de momento a hacer cast en la llamada:
myTimer::setHora((unsigned)now.hour,(unsigned)now.minute,(unsigned)now.second);
A ver si con esto cambia en algo la cosa.
Si no fuera así, envíame la librería o bien un link a la librería RTClib.h que estás usando.
saludos.

EDITO DE NUEVO:
Veo que antes has puesto paréntesis a now, osea que es una función. Ponlos también en
myTimer::setHora(now.hour(), now.minute(), now.second());

Perfecto!!!
Ya lo compila, pero me parece que le falta algo al código, ahora le tengo que decir que cuando este activado el riego encienda un rele donde esta la bomba.

He probado algo así pero no funciona:

  if ((tlluvia1.getActivado()?"On")) {
    digitalWrite(lluviaPin, HIGH); // lluvia on
  } 
  else {
    digitalWrite(lluviaPin, LOW);  // lluvia off
  }

Quizás estoy poniendo una burrada, perdón de antemano....

Creo que no escogí ejemplos adecuados :slight_smile: prueba lo siguiente:
if (tlluvia1.getActivado()) {
digitalWrite(lluviaPin, HIGH); // lluvia on
}
else {
digitalWrite(lluviaPin, LOW); // lluvia off
}

Lo he colocado en el void setup, no lo tenia claro, no ha dado error en la compilación, el problema es que cuando lo cargo en el Arduino no actúa el rele. :cold_sweat:

Bueno. Esta minilibrería no hace nada del otro mundo. Explico en el ejemplo cómo funciona. No obstante, para que entiendas mejor, su uso en tu programa sería el siguiente:

Antes del setup define los timers que desees, en el setup estableces las horas de encendido/duración de los timers, y en el loop primero cargas la hora actual en myTimer::setHora(hora,minuto,segundo) y luego puedes poner los if para establecer el relé correspondiente a cada timer:

myTimer tRiego1,tRiego2,tRiego3,tRiego4,tRiego5,tRiego6; 
void setup(){
  tRiego1.setInicio(10);           //inicio a las 10:00:00
  tRiego1.setDuracion(0,0,20);     //Duración 20 segundos
  tRiego2.setInicio(12);           //inicio a las 12:00:00
  tRiego2.setDuracion(0,0,20);     //Duración 20 segundos
  tRiego3.setInicio(14);           //inicio a las 14:00:00
  tRiego3.setDuracion(0,0,20);     //Duración 20 segundos
  tRiego4.setInicio(16);           //inicio a las 16:00:00
  tRiego4.setDuracion(0,0,20);     //Duración 20 segundos
  tRiego5.setInicio(18,10);           //inicio a las 18:00:00
  tRiego5.setDuracion(0,0,20);     //Duración 20 segundos
  tRiego6.setInicio(20);           //inicio a las 20:00:00
  tRiego6.setDuracion(0,0,20);     //Duración 20 segundos
}

void loop (){
  myTimer::setHora(now.hour,now.minute,now.second); // Aquí le enviaríamos la hora obtenida de nuestro reloj.
   if (tRiego1.getActivado){
        digitalWrite(lluviaPin, HIGH);
   else {
        digitalWrite(lluviaPin,Low);
    }
  if (tRiego2.getActivado){
  }
/// y así sucesivamente
   }

}

Como ves, el funcionamiento es muy básico, pero podrías ampliar funcionalidades facilmente, por ejemplo colocando en un timer diario un control de fecha, y así modificar el resto de los timers (por ejemplo, adelantar o retrasar el encendido de la iluminación...).

No hay suerte...
El código me daba un error para compilar y le puse paréntesis a getActivado() y me lo ha compilado bien, lo he cargado y no me activa el rele. Te dejo el código por si ves algo raro.

#include "Wire.h"    //libreria Arduino
#include "RTClib.h"  //libreria del reloj
         
#define lluviaPin       33  // pin digital de salida para Bomba de lluvia

class myTimer{

private:
  static long segActual;    // Variable en la que se guarda en forma de segundos la hora actual para comparar con los objetos timer.
  long segEncendido;        // segundo del día en el que se enciende el timer. Las 00:00:00 == 0; las 00:01:00==60, las 23:59:59==86399.
  long segDuracion;         // segundos que durará encendido el relé correspondiente.

public:
  void setInicio(unsigned int hora, unsigned int minuto=0, unsigned int segundo=0){
    segEncendido=hora*3600+minuto*60+segundo;
  };
  void setDuracion(unsigned horas, unsigned minutos=0, unsigned segundos=0){
    segEncendido=horas*3600+minutos*60+segundos;
  };
  static void setHora(unsigned hora, unsigned minuto, unsigned segundo){
    segActual=hora*3600 + minuto*60 + segundo;
  };
  bool getActivado(void){
    long segDesdeEncendido = segActual-segEncendido;   //restamos el segundo del día de encendido
    if (segDesdeEncendido<0) segDesdeEncendido+=86400; // Si los segundos transcurridos son negativos sumamos un día, con lo que obtenemos los transcurridos desde el teórico encendido de ayer, que ya serán positivos.
    // Ya sólo queda comprobar que los segundos transcurridos sean menores a la duración de encendido del timer
    return (segDesdeEncendido<segDuracion);
  };
};
long myTimer::segActual=0;

myTimer tlluvia1,tlluvia2,tlluvia3,tlluvia4,tlluvia5,tlluvia6; 

void setup () {
  Serial.begin(57600);
  Wire.begin();

  pinMode(lluviaPin, OUTPUT);      //Define el Pin como salida

  tlluvia1.setInicio(10);           //inicio a las 10:00:00
  tlluvia1.setDuracion(0,0,20);     //Duración 20 segundos
  tlluvia2.setInicio(12);           //inicio a las 12:00:00
  tlluvia2.setDuracion(0,0,20);     //Duración 20 segundos
  tlluvia3.setInicio(14);           //inicio a las 14:00:00
  tlluvia3.setDuracion(0,0,20);     //Duración 20 segundos
  tlluvia4.setInicio(16);           //inicio a las 16:00:00
  tlluvia4.setDuracion(0,0,20);     //Duración 20 segundos
  tlluvia5.setInicio(18);           //inicio a las 18:00:00
  tlluvia5.setDuracion(0,0,20);     //Duración 20 segundos
  tlluvia6.setInicio(21,30);        //inicio a las 20:00:00
  tlluvia6.setDuracion(0,0,20);     //Duración 20 segundos
}  

void loop() {
  Serial.begin(9600);
  DateTime now = Reloj.now();        //Obtiene la fecha y hora del RTC

  myTimer::setHora(now.hour(),now.minute(),now.second()); // Aquí le enviaríamos la hora obtenida de nuestro reloj.

 if (tlluvia1.getActivado()) {
    digitalWrite(lluviaPin, HIGH); // lluvia on
  } 
  else {
    digitalWrite(lluviaPin, LOW);  // lluvia off
  }
 if (tlluvia2.getActivado()) {
    digitalWrite(lluviaPin, HIGH); // lluvia on
  } 
  else {
    digitalWrite(lluviaPin, LOW);  // lluvia off
  }
   if (tlluvia3.getActivado()) {
    digitalWrite(lluviaPin, HIGH); // lluvia on
  } 
  else {
    digitalWrite(lluviaPin, LOW);  // lluvia off
  }
   if (tlluvia4.getActivado()) {
    digitalWrite(lluviaPin, HIGH); // lluvia on
  } 
  else {
    digitalWrite(lluviaPin, LOW);  // lluvia off
  }
   if (tlluvia5.getActivado()) {
    digitalWrite(lluviaPin, HIGH); // lluvia on
  } 
  else {
    digitalWrite(lluviaPin, LOW);  // lluvia off
  }
   if (tlluvia6.getActivado()) {
    digitalWrite(lluviaPin, HIGH); // lluvia on
  } 
  else {
    digitalWrite(lluviaPin, LOW);  // lluvia off
  }
  delay (1000);
}

Lo he recortado un poco para que no moleste el resto del código que no afecta.
Saludos y gracias.

Efectivamente iba con paréntesis. Perdona por la equivocación, derivada de las prisas.
Pues ahora mismo me pillas sin el arduino. Mañana puedo comprobarlo, pero aunque lo he escrito de memorieta, estoy casi convencido de que es idéntico al que he utilizado en el Arduino con éxito. De momento, si puedes, añade a la función de getActivado un par de Serial.print a ver qué valores nos dice que contienen los registros de cada timer:

  bool getActivado(void){
    long segDesdeEncendido = segActual-segEncendido;   //restamos el segundo del día de encendido
    Serial.print("Segundo actual: ");
    Serial.print(segActual);
    Serial.print(". Segundo de encendido: ");
    Serial.println(segEncendido); 
    if (segDesdeEncendido<0) segDesdeEncendido+=86400; // Si los segundos transcurridos son negativos sumamos un día, con lo que obtenemos los transcurridos desde el teórico encendido de ayer, que ya serán positivos.
    // Ya sólo queda comprobar que los segundos transcurridos sean menores a la duración de encendido del timer
    return (segDesdeEncendido<segDuracion);
  };

Para ver al menos si los timers están establecidos, y la hora del reloj pasa correctamente a éstos.

Localizado el fallo. Lo siento, amigo. Craso error mío en el código por escribirlo sin probar. Sustituye
void setDuracion(unsigned horas, unsigned minutos=0, unsigned segundos=0){
segEncendido=horas3600+minutos60+segundos;
};
Por
void setDuracion(unsigned horas, unsigned minutos=0, unsigned segundos=0){
segDuracion=horas3600+minutos60+segundos;
};

Y después sustituye todos los unsigned/unsigned int de la clase por long (para evitar errores de desbordamiento en los cálculos)

Funciona!!!! XD XD

Muchas gracias por toda la colaboración Noter.

Saludos

De nada. Menos mal; estaba empezando a perder la fe en mí mismo :grin:
Como te dije y puedes ver, es una clase muy sencillita; pero tiene todas las ventajas de los objetos. Por ejemplo el último código tuyo metí todos los triego en un array myTimer triego[6] para luego poder recorrer todos con un for.
Si saco un ratillo, tal vez le agregaré un poco más de funcionalidad, como asignar a cada timer un par de funciones (al activarse/al desactivarse), y que se puedan autogestionar todos los timers agregados con un solo comando. Si puedo realizarlo en breve, te posteo aquí las mejoras por si te fueran de utilidad.
Saludos.

Me pierdo un poco con el código pero todas las mejoras serán bien recibidas, maestro.