#include "Datalogger.h"

void setup ( void ) {
  // put your setup code here, to run once:
  Serial.begin(115200);
  MYRTC.RTC_init ( );
  MSD.MicroSD_init();
  ACT.init_lcd();
  SEN.sensorsInit();
  ACT.init_relay();
  //ACT.mostrar_lcd();
  Serial.println("Hello, ESP32!");
}

void loop ( void ) {
  // put your main code here, to run repeatedly:
  //MYRTC.get_time ();
  //MYRTC.format_date();
  //MYRTC.format_time();
  //MYRTC.show_time ();
  //MSD.SaveFile();
  //MSD.ReadFile();
  TSK.actualizar_tareas();
  //MYJSON.make_json();
  TSK.tarea_MSD();
  //TSK.tarea_LDR();
  //TSK.tarea_relay();
  

}


Datalogger 6B.ino

diagram.json

#ifndef MicroSD_h
#define MicroSD_h
/* Librerías fabricante necesarias para utilizar la MicroSD */
#include <SD.h>
#include <SPI.h>

#define MICROSD_PIN 5    /* Pin de control MicroSD */  
File MicroSD_File;       /* Archivo para escribir  o leer en la MicroSD */
class MicroSD  {
  // VARIABLES
  public:
    uint8_t contador = 0;      /* */
    String filename = "/TestMicroSD.txt";   /* Nombre de archivo que incluye "/" que indica la ubicación en raíz */
  // MÉTODOS
  public:
   void MicroSD_init ( void );
   void SaveFile ( String );
   void ReadFile ( void );
   //void get_file_name(String)
};

void MicroSD::MicroSD_init ( void ){

   while ( !SD.begin ( MICROSD_PIN ) ) {
        Serial.println ( F ( "Falló la inicialización del módulo MicroSD"  ));
        delay(1000);
    }
    Serial.println ( F ( "La librería MicroSD ha inicializado con éxito" ) );
}

void MicroSD :: SaveFile ( String msg ) {
    
    // Abrir o crear en caso de que no exista.
    MYRTC.get_time();
    MYRTC.format_date('_');
    filename ="/";
    filename += MYRTC.format_date('-');
    MicroSD_File = SD.open ( filename, FILE_APPEND );
    if ( MicroSD_File ) {

        // Almacenar JSON en el archivo.
        //serializeJson(*doc, JSON);
        
        MicroSD_File.println ( msg );
        //contador++;
        MicroSD_File.close ( );
      
    } else {
        // if the file didn't open, print an error:
        Serial.print ( F ( "Error opening " ) );
        Serial.println ( filename );
 
       
    }
    Serial.println ( "Verificando si existe el archivo: ");
    if ( SD.exists ( filename ) ) {
    Serial.println ( filename );
    Serial.println( " existe" );
  } else {
        Serial.println ( filename );
    Serial.println( " no existe" );
  }
     // Esperar un segundo entre lecturas
      delay ( 1000 );
}
void MicroSD :: ReadFile ( void ) {

    //String filename = "/TestMicroSD.txt";
    // re-open the file for reading:
  MicroSD_File = SD.open( filename );
  if ( MicroSD_File ) {
    Serial.println( "Archivo:" );

    // read from the file until there's nothing else in it:
    while ( MicroSD_File.available ( ) ) {

      Serial.write ( MicroSD_File.read ( ) );

    }
    // close the file:
    MicroSD_File.close ( );
  } else {
    // if the file didn't open, print an error:
    Serial.println ( "Error abriendo el archivo" );
  }

}

#endif

MicroSD.h

#include <Wire.h>               /* Librería para el uso del protocolo I2C. */

/*RTClib.h, requiere de la instalación de dos librerías:
RTClib: Permite el uso de varios relojes del fabricante Adafruit.
Adafruit BusIO: Es necesaria cargarla para configurar ciertos elementos de los componentes electrónicos de Adafruit.*/

#include "RTClib.h"
  RTC_DS1307 rtc;

class DS1307_RTC {
  
  public:
      uint8_t hora = 0, minuto = 0, segundo = 0, dia = 0, mes = 0;
      uint16_t ano = 0;
  
      
  public:
    void RTC_init ( void );
    void get_time ( void );
    String format_date ( char );
    String format_time ( void );
  

  };

/* Función que configura lo necesario para que el reloj se inicialice */
void DS1307_RTC::RTC_init ( void ) {

   while ( ! rtc.begin ( ) ) {                  /* Mientras que el reloj no se ha iniciado. */
    Serial.println ( F ( "Hay un error de reconocimiento del RTC, revisa conexiones y alimentación" ) );
    Serial.flush ( );                           /* Espera a que se transmita la información serial correctamente. */
    delay ( 3000 );
    //abort ( );
    
  }
  if ( ! rtc.isrunning ( ) ) {      /* Si el reloj no está ejecutándose*/

    /* Esta instrucción solo debe usarse una sola vez, para que el reloj actualice la hora, una vez hecho esto, se puede comentar y volver a subir el código. */
    Serial.println ( F ( "El reloj se está configurando con la fecha y hora de la computadora" ) );
   // __DATE__ y __TIME__ Son macros que retornan la fecha y hora de la computadora.
    rtc.adjust( DateTime ( F ( __DATE__ ), F ( __TIME__ ) ) );      /* Función que ajusta automáticamente la fecha y hora. */
     
    
    
  }
  //rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));  // año, mes, día, hora, minuto, segundo.                  /* Función que ajusta manualmente la fecha y hora. */
  }

/* Función que configura lo necesario para que el reloj se inicialice */
void DS1307_RTC::get_time ( void ) {

      DateTime now = rtc.now();
      segundo = now.second ( );
      minuto = now.minute ( );
      hora = now.hour ( );
      dia = now.day ( );
      mes = now.month ( );
      ano = now.year ( );
      
  }

/* Función que le da un formato legible a la fecha. */
String DS1307_RTC::format_date ( char caracter ) {

String fecha = "";
    if ( dia < 10 ) fecha += '0';
  fecha += dia;
  fecha += caracter;
    if ( mes < 10 ) fecha += '0';
  fecha += mes;
  fecha += caracter;
  fecha += ano;
return fecha;  
}

/* Función que le da un formato legible al tiempo. */
String DS1307_RTC::format_time ( void ) {

  String tiempo = "";
  if ( hora < 10 ) tiempo += '0';
    tiempo += hora;
    tiempo += ':';
  
  if ( minuto < 10 ) tiempo += '0';
    tiempo += minuto;
    tiempo += ':';

  if ( segundo < 10 ) tiempo += '0';
    tiempo += segundo;
  return tiempo;  
}


RTC.h

#ifndef JSON_h
#define JSON_h
#include <ArduinoJson.h>
class fac_json {
  public:
  String make_json(uint16_t);
  String json_actuador(); 
};
String fac_json:: make_json (uint16_t luminosidad){
  String temp = "";
  MYRTC.get_time();
  DynamicJsonDocument INPUT_JSON ( 1024 );
  INPUT_JSON [ "Fecha" ]   = MYRTC.format_date('/');
  INPUT_JSON [ "Hora" ]   = MYRTC.format_time();
  INPUT_JSON [ "Luminosidad" ]   = luminosidad;
  
  serializeJsonPretty( INPUT_JSON, temp );
  return temp;
}


String fac_json::json_actuador (void){
  String actuador = "";
  DynamicJsonDocument INPUT_JSON ( 1024 );
  INPUT_JSON [ "Fecha_on" ]   = ACT.fecha_on;
  INPUT_JSON [ "Fecha_off" ]   = ACT.fecha_off;
  INPUT_JSON [ "Tiempo_on" ]   = ACT.tiempo_on;
  INPUT_JSON [ "Tiempo_off" ]   = ACT.tiempo_off;
  serializeJsonPretty( INPUT_JSON, actuador );
  return actuador;
}

#endif


JSON.h

#ifndef Tasks_h
#define Tasks_h
/*****************************************************************************************
*      DESCRIPCIÓN DE LA LIBRERÍA: El objetivo de esta librería es generar tiempos de    *
*       espera de ejecución sin la implementación de la función "delay()".               *
******************************************************************************************/

#define TIEMPO1 1000                 // Constante para indicar 1 segundo (1000 ms).
#define TIEMPO2 2000                 // Constante para indicar 2 segundos (2000 ms).
#define TIEMPO3 3000  
#define TIEMPO_MSD 10000 
#define TIEMPO_LCD 2000
#define TIEMPO_LDR 2000
#define TIEMPO_RELAY 1000            // Constante para indicar 3 segundos (3000 ms).
class millis_tasks {

  public:
    uint64_t tiempo_anterior1 = 0,   // Contador de tiempo que tendrá múltiplos de TIEMPO1.
             tiempo_anterior2 = 0,   // Contador de tiempo que tendrá múltiplos de TIEMPO2.
             tiempo_anterior3 = 0,
             tiempo_anterior_MSD = 0,
             tiempo_anterior_LCD = 0, 
             tiempo_anterior_LDR = 0,
             tiempo_anterior_relay =0,  // Contador de tiempo que tendrá múltiplos de TIEMPO3.
             tiempo_actual = 0;      // Contador de tiempo que tendrá múltiplos de TIEMPO.
    
  public:

    void tarea1 ( void );            // Función que ejecuta una acción cada segundo.
    void tarea2 ( void );            // Función que ejecuta una acción cada dos segundos.
    void tarea3 ( void ); 
    void tarea_MSD (void); 
    void tarea_LCD (void); 
    void tarea_LDR (void);
    void tarea_relay (void);         // Función que ejecuta una acción cada tres segundos.
    void actualizar_tareas (void );  // Función que actualiza el conteo obtenido de la función "millis()".
 
};

/*~~~~~~~~~~~~~~~~~~~~~~~~ tarea2 - Función que se ejecuta cada TIEMPO2 ( 2 SEGUNDOS ) ~~~~~~~~~~~~~~~~~~~~~~~~ */
void millis_tasks :: tarea_MSD ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_MSD ) >= TIEMPO_MSD ){
    MSD.SaveFile(MYJSON.make_json(SEN.getLumens()));
    MSD.ReadFile();
  

     Serial.println ( "2.- Ejecutando tarea_MSD" );
     tiempo_anterior_MSD = tiempo_actual;

  }
 
}

/*
   Al arranque del sistema la variable "tiempo_anterior1" tendrá el valor de 0, 
   cuando "tiempo_actual" sea igual a "TIEMPO1" es decir cuando hayan pasado
   1000 ms, "tiempo_anterior" tomará el valor de "tiempo_actual", para que la
   diferencia entre ellos siempre se cumpla cuando pase el tiempo asignado en "TIEMPO1".
*/


/*~~~~~~~~~~~~~~~~~~~~~~~~ tarea1 - Función que se ejecuta cada TIEMPO1( 1 SEGUNDO) ~~~~~~~~~~~~~~~~~~~~~~~~ */
void millis_tasks :: tarea1 ( void ) {

  /*
      _____________________________________________
      | tiempo_actual | tiempo_anterior1 | TIEMPO1 |
      ----------------------------------------------
      |       0       |       0          |  1000   |
      ----------------------------------------------
      |       1       |       0          |  1000   |
      ----------------------------------------------
      |       2       |       0          |  1000   |
      ----------------------------------------------
      ----------------------------------------------
      |       3       |       0          |  1000   |
      ----------------------------------------------
      ----------------------------------------------
      | . . 1000      |       0          |  1000   |   Se cumple la condicional 1000 - 0 = 1000.
      ----------------------------------------------
      ----------------------------------------------
      |    10001      |       1000       |  1000   |
      ----------------------------------------------

  */

  if ( ( tiempo_actual - tiempo_anterior1 ) >= TIEMPO1 ){
    
    Serial.println ( "1.- Ejecutando tarea 1" );
    tiempo_anterior1 = tiempo_actual;

  }

}

/*~~~~~~~~~~~~~~~~~~~~~~~~ tarea2 - Función que se ejecuta cada TIEMPO2 ( 2 SEGUNDOS ) ~~~~~~~~~~~~~~~~~~~~~~~~ */
void millis_tasks :: tarea2 ( void ) {
  if ( ( tiempo_actual - tiempo_anterior2 ) >= TIEMPO2 ){

     Serial.println ( "2.- Ejecutando tarea 2" );
     tiempo_anterior2 = tiempo_actual;

  }
 
}

/*~~~~~~~~~~~~~~~~~~~~~~~~ tarea3 - Función que se ejecuta cada TIEMPO3 ( 3 SEGUNDOS ) ~~~~~~~~~~~~~~~~~~~~~~~~ */
void millis_tasks :: tarea3 ( void ) {

  if ( ( tiempo_actual - tiempo_anterior3 ) >= TIEMPO3 ){

     Serial.println ( "3.- Ejecutando tarea 3" );
     tiempo_anterior3 = tiempo_actual;

  }
  
}
void millis_tasks :: tarea_LCD ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_LCD ) >= TIEMPO_LCD ){
    MYRTC.get_time();
    ACT.mostrar_lcd(MYRTC.format_date('/'), MYRTC.format_time());

     Serial.println ( "Ejecutando tarea_LCD" );
     tiempo_anterior_LCD = tiempo_actual;

  }
 
}
void millis_tasks :: tarea_LDR ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_LDR ) >= TIEMPO_LDR ){
    String temp = MYJSON.make_json(
      SEN.getLumens()
    );
     Serial.println ( SEN.getLumens(),DEC );
     tiempo_anterior_LDR = tiempo_actual;

  }
 
}

/*~~~~~~~~~~~~~~~~~~~~~~~~ actualizar_tareas - Función que actualiza el contador de "millis()" ~~~~~~~~~~~~~~~~~~~~~~~~ */
void millis_tasks :: actualizar_tareas ( void ) {

  tiempo_actual = millis( );

}

void millis_tasks :: tarea_relay ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_relay ) >= TIEMPO_RELAY ){
    
ACT.activate_relay();
tiempo_anterior_relay = tiempo_actual;
  
  
  }
 
}


#endif

Tasks.h

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

RTClib
ArduinoJson
LiquidCrystal I2C


libraries.txt

#ifndef Datalogger_h
#define Datalogger_h
#include <LiquidCrystal_I2C.h> 
LiquidCrystal_I2C lcd ( 0x27, 16, 2 );  /*~ Instancia de la clase para el manejo de la pantalla ( Dirección I2C, cantidad de columnas, cantidad de filas ) ~*/


#include "RTC.h"
  DS1307_RTC MYRTC;

#include "MicroSD.h"
  MicroSD MSD;

#include "Sensors.h"
  Sensores SEN;

#include "Actuators.h"
  actuadores ACT;
  
#include "JSON.h"
  fac_json MYJSON;








#include "Tasks.h"
  millis_tasks TSK;

#endif

Datalogger.h

#ifndef Actuators_h
#define Actuators_h
#define relay 15
class actuadores {
  public:
  String tiempo_off = "",
          tiempo_on = "",
          fecha_off = "",
          fecha_on = "";
  void init_relay (void);
  void init_lcd (void);
  void mostrar_lcd (String, String);
  void activate_relay(void);
  bool estado_off = true,
        estado_on = false;

};

void actuadores :: init_lcd (void){
  lcd.init ( );

}
void actuadores :: mostrar_lcd (String fila1, String fila2){
  lcd.clear();
  lcd.backlight ( );
  lcd.setCursor ( 0, 0 );
  lcd.print ( fila1 );
  lcd.setCursor ( 0, 1 );
  lcd.print ( fila2 );


}
void actuadores :: init_relay (void){
  pinMode(relay, OUTPUT);
}

void actuadores::activate_relay(void){
  Serial.println(SEN.getLumens() );
  if (SEN.getLumens()<=60){
    digitalWrite(relay, HIGH);
    if (estado_on == false){
    Serial.println("relay activado");
    fecha_on = MYRTC.format_date('/');
    tiempo_on =MYRTC.format_time();
    estado_on = true;
    estado_off = false;
    }
    }
    else{
      if (estado_off == false){
        digitalWrite(relay, LOW);
        Serial.println ( "Relay desactivado" );
        fecha_off = MYRTC.format_date('/');
        tiempo_off = MYRTC.format_time();
        estado_off = true;
        estado_on = false;
        //MYJSON.json_actuador();
      }
}
}
#endif

Actuators.h

#ifndef Sensors_h
#define Sensors_h

#define PIN_LDR 4

class Sensores {
  public:
    void sensorsInit(void); 
    uint16_t getLumens(void);
};

void Sensores::sensorsInit() {
  pinMode(PIN_LDR, INPUT);
}

uint16_t Sensores::getLumens() {
  return map(analogRead(PIN_LDR), 32, 4063, 100, 0);
 // Serial.println(analogRead(PIN_LDR));
}

#endif
