#include "DataLogger.h"



void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  Serial.println("Hello, ESP32!");
  Myrtc.RTC_init();
  MSD.MicroSD_init();

  ACT.init_LCD();
  //ACT.show_LCD();
  SEN.sensors_init();
}

void loop() {
  /*Myrtc.get_time();
  // put your main code here, to run repeatedly:
  Myrtc.show_time();

  MSD.SaveFile();
  MSD.ReadFile();*/
  //Json.FAC_Json();
  //Serial.println(Json.FAC_Json("Hola", "Test"));
  /*Myrtc.get_time();
  MSD.SaveFile(Json.FAC_Json(Myrtc.format_time(), Myrtc.format_date()));
  MSD.ReadFile();*/
  Tasks.actualizar_tareas();
  //Tasks.tarea_RTC();
  //Tasks.tarea_MSD();
  Tasks.tarea_LCD();
  Tasks.tarea_SENS();
 // delay(4000); // this speeds up the simulation

}


sketch.ino

diagram.json

#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;
      String fecha = " ", tiempo = " ";
      
  public:
    void RTC_init ( void );
    void get_time ( void );
    String format_date (void );
    String format_time ( void ) ;
    void show_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 ( void ) {

  fecha = "";
    if ( dia < 10 ) fecha += '0';
  fecha += dia;
  fecha += '/';
    if ( mes < 10 ) fecha += '0';
  fecha += mes;
  fecha += '/';
  fecha += ano;
  
  return fecha;

}

/* Función que le da un formato legible al tiempo. */
String DS1307_RTC::format_time ( void ) {

  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;
}

/* Función que muestra en la consola serial la fecha y la hora. */
void DS1307_RTC :: show_time ( void ) {
  
  format_time ( );                    /* Dar formato al tiempo */
  Serial.print ( F ( "Hora: " ) );
  Serial.println ( tiempo );
  format_date ( );
  Serial.print ( F ( "Fecha: " ) );
  delay(200);
  Serial.println ( fecha );          /* Dar formato a la fecha */

}

RTC.h

#ifndef DataLogger_h
#define DataLogger_h
#include <ArduinoJson.h>
  /*~ Instancia de la clase para el manejo de la pantalla ( Dirección I2C, columnas, filas ) ~*/

#include "RTC.h"
DS1307_RTC Myrtc;
#include "MicroSD.h"
MicroSD MSD;
#include "Json.h"
JsonClass Json;
#include "Sensors.h"
Sensores SEN;
#include "Actuators.h"
Actuators ACT;
#include "Tasks.h"
millis_tasks Tasks;






#endif

DataLogger.h

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

RTClib
ArduinoJson
LiquidCrystal I2C


libraries.txt

#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 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.
    MicroSD_File = SD.open ( filename, FILE_APPEND );
    if ( MicroSD_File ) {

        // Almacenar JSON en el archivo.
        //serializeJson(*doc, JSON);
        Serial.println ( F ( "Si funciono: " ) );
        MicroSD_File.println ( msg );
  
        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

#ifndef Json_h
#define Json_h

class JsonClass {
  public:
  String FAC_Json(String, String);
};
String JsonClass::FAC_Json(String msg1, String msg2){
  String temp = "";
   DynamicJsonDocument JSON ( 1024 );         /* Objeto donde se alamcenará el JSON */
  JSON [ "Hora" ] = msg1;             /* Almacena números enteros o flotantes */         
  JSON [ "Fecha" ] = msg2;
    serializeJsonPretty( JSON, temp );                /* Transformar json a string */
  return temp;
}
#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_RTC 1000 
#define TIEMPO_MSD 10000      
#define TIEMPO_LCD 2000         // Constante para indicar 3 segundos (3000 ms).
#define TIEMPO_SENS 2000 
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_RTC = 0,
             tiempo_anterior_MSD = 0,
             tiempo_anterior_LCD = 0,
             tiempo_anterior_SENS = 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_RTC (void); 
    void tarea_MSD (void);
    void tarea_LCD (void);
    void tarea_SENS (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()".
 
};

/*
   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;

  }
 
}

void millis_tasks :: tarea_RTC ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_RTC ) >= TIEMPO_RTC ){

     Serial.println ( "2.- Ejecutando tarea 2" );
     tiempo_anterior_RTC = tiempo_actual;

  }
 
}

void millis_tasks :: tarea_MSD ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_MSD ) >= TIEMPO_MSD ){
    Myrtc.get_time();
    MSD.SaveFile(Json.FAC_Json(Myrtc.format_time(), Myrtc.format_date()));
    MSD.ReadFile();
    
     tiempo_anterior_MSD = tiempo_actual;

  }
 
}

void millis_tasks :: tarea_LCD ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_LCD ) >= TIEMPO_LCD ){

     Myrtc.get_time();
     ACT.show_LCD(Myrtc.format_date(), Myrtc.format_time());
     tiempo_anterior_LCD = 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;

  }
  
}

/*~~~~~~~~~~~~~~~~~~~~~~~~ actualizar_tareas - Función que actualiza el contador de "millis()" ~~~~~~~~~~~~~~~~~~~~~~~~ */
void millis_tasks :: actualizar_tareas ( void ) {

  tiempo_actual = millis( );

}

void millis_tasks :: tarea_SENS ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_SENS ) >= TIEMPO_SENS ){

     Serial.println (SEN.LDR_read());
     tiempo_anterior_SENS = tiempo_actual;

  }
 
}

#endif

Tasks.h

#ifndef Actuators_h
#define Actuators_h
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd ( 0x27, 16, 2 );
class Actuators {
public:
void init_LCD (void);
void show_LCD (String, String);
};

void Actuators :: init_LCD (void){
  lcd.init ( );
    lcd.backlight ( );     		/*~ Encender la luz de fondo. ~*/

}

void Actuators :: show_LCD (String msg1, String msg2){
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print(msg1);
  lcd.setCursor(0,1);
  lcd.print(msg2);
}





#endif

Actuators.h

#ifndef Sensors_h
#define Sensors_h
#define LDR 34
class Sensores{
public:

void sensors_init(void);
uint16_t LDR_read(void);

};

void Sensores :: sensors_init(void){
  pinMode(LDR, INPUT);
}

uint16_t Sensores :: LDR_read (void){
  return analogRead(LDR); 

}




#endif