#include "datalogger_6c.h"
void setup() {
  

  // put your setup code here, to run once:
  Serial.begin(115200);
  myACT.iniciaractuadores();
  myRTC.RTC_init();
  mySD.MicroSD_init();
  SEN.iniciar_sensores();
  myMQTT.setup_WiFi ( );
  myMQTT.set_MQTT_server ( );
  myMQTT.set_MQTT_callback (  );
  Serial.println("Hello, ESP32!");
}

void loop() {
  //myRTC.get_time();
 // myRTC.show_time();
  //mySD.SaveFile();

  /*
  myTSK.tarea_MSD();
  myTSK.tarea_lcd();*/
  myTSK.tarea_relay();
  myTSK.actualizar_tareas();
  //myTSK.tarea_dht();
  // put your main code here, to run repeatedly:
}


6c_datalogger.ino

diagram.json

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

RTClib
ArduinoJson
LiquidCrystal I2C
DHT sensor library for ESPx
PubSubClient


libraries.txt

#ifndef datalogger_6c_h
#define datalogger_6c_h

#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C LCD(0x27,16,2);
#include <ArduinoJson.h>
#include <Wire.h> 
#include "RTClib.h"
#include "DHTesp.h"

bool estado_relay = false;
String fecha_relay_on;
String fecha_relay_off;
String hora_relay_on;
String hora_relay_off;



#include "RTC.h"
DS1307_RTC myRTC;

#include "MicroSD.h"
MicroSD mySD;

#include "sensores.h"
sensores SEN;

#include "JSON.h"
JSON_class myJSON;

#include "actuators.h"
actuadores myACT;

#include "Tasks.h"
millis_tasks myTSK;

#include "MQTT.h"
MQTT myMQTT;


#endif

datalogger_6c.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 ) ;
    //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. */
     
    
    
  }
  Serial.println("Se ha inicializado el reloj correctamente");
  //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;
}

/* Función que muestra en la consola serial la fecha y la hora. */


RTC.h

#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 = "";   /* 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 ) {
    myRTC.get_time ();
    filename = "/";
    filename += myRTC.format_date('_'); 

    // 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);
        
        MicroSD_File.println ( msg );
        MicroSD_File.close ( );
        //Serial.println("se ha guardado el archivo")
        Serial.println(msg);
    } 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 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
#define TIEMPO_MSD 10000               // Constante para indicar 1 segundo (1000 ms).
#define TIEMPO2 2000                 // Constante para indicar 2 segundos (2000 ms).
#define TIEMPO3 3000
#define TIEMPO_LCD 2000
#define TIEMPO_DHT 2000 
#define TIEMPO_RELAY 1000  
#define TIEMPO_MQTT 10000              // 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, // Contador de tiempo que tendrá múltiplos de TIEMPO3.
             tiempo_anterior_lcd = 0,
             tiempo_actual = 0,
             tiempo_anterior_dht=0,
             tiempo_anterior_relay=0,
             tiempo_anterior_mqtt = 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 );            // Función que ejecuta una acción cada tres segundos.
    void actualizar_tareas (void );
    void tarea_MSD (void);  // Función que actualiza el conteo obtenido de la función "millis()".
    void tarea_lcd (void);
    void tarea_dht (void);
    void tarea_relay (void);
    void tarea_MQTT (void);
};

/*
   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_MSD ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_MSD ) >= TIEMPO_MSD ) {
    myRTC.get_time();
    String temp = myJSON.fac_JSON(
    SEN.get_humidity(), 
    SEN.get_temperature(),
    myRTC.format_time(),
    myRTC.format_date('/'));
    mySD.SaveFile(temp);
    mySD.ReadFile();
    //Serial.println ( "2.- Ejecutando tarea 2" );
    tiempo_anterior_MSD = 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_lcd ( void ) {

  if ( ( tiempo_actual - tiempo_anterior_lcd ) >= TIEMPO_LCD ) {
    myRTC.get_time();
    myACT.mostrarpantalla(
    myRTC.format_date('/'),
    myRTC.format_time());
    tiempo_anterior_lcd = tiempo_actual;

  }

}

void millis_tasks :: tarea_dht ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_dht ) >= TIEMPO_DHT ) {
    
    myRTC.get_time();
    String temp = myJSON.fac_JSON(
    SEN.get_humidity(), 
    SEN.get_temperature(),
    myRTC.format_time(),
    myRTC.format_date('/'));
    tiempo_anterior_dht = tiempo_actual;
    Serial.println(temp);
  }

}

void millis_tasks :: tarea_relay ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_relay ) >= TIEMPO_RELAY ) {
      if(SEN.get_temperature()>30){
        //Serial.println("Se ha activado el relay");
        myACT.relay(true);
      }else{
        myACT.relay(false);
        //Serial.println("Se ha desactivado el relay");
      }
    
    tiempo_anterior_relay = tiempo_actual;

  }

}
void millis_tasks :: tarea_MQTT ( void ) {
  if ( ( tiempo_actual - tiempo_anterior_mqtt ) >= TIEMPO_MQTT ) {

    Serial.println ( "2.- Ejecutando tarea MQTT" );
    tiempo_anterior_mqtt = tiempo_actual;

  }

}
#endif

Tasks.h

#ifndef JSON_h
#define JSON_h

class JSON_class{
  public: 
  String data_JSON ="";
  String data_relay_jsoon ="";
  public:
  String fac_JSON(float,float,String,String);
  String json_relay(void);
};

String JSON_class::fac_JSON( float hum, float temp, String hora, String fecha){ 
  
  String tempo = ""; 
  DynamicJsonDocument JSON ( 1024 );
  JSON [ "Humedad"] = hum;
  JSON [ "Temperatura"] = temp;
  JSON [ "Fecha" ] = fecha;             /* Almacena números enteros o flotantes */         
  JSON [ "Hora" ] = hora;    
  serializeJsonPretty( JSON, tempo );  
  return tempo;
}

String JSON_class::json_relay(void){ 
  
  String tempo = ""; 
  DynamicJsonDocument JSON ( 1024 );
  JSON [ "Actuador"] ="Relay";
  JSON [ "Fecha_on" ] = fecha_relay_on;             /* Almacena números enteros o flotantes */         
  JSON [ "Hora_on" ] = hora_relay_on;
  JSON [ "Fecha_off" ] = fecha_relay_off;             /* Almacena números enteros o flotantes */         
  JSON [ "Hora_off" ] = hora_relay_off;


  
  serializeJsonPretty( JSON, tempo );  
  return tempo;
}

#endif

JSON.h

#ifndef actuators_h
#define actuators_h

#define relay_dht 12
#define state_s HIGH
#define state_r LOW

class actuadores {
  public:
    void iniciaractuadores(void);
    void mostrarpantalla(String, String);
    void relay(bool);

};

void actuadores::iniciaractuadores(void) {
  pinMode(relay_dht, OUTPUT);
  LCD.init();
  LCD.backlight ( );
  Serial.println("Se ha iniciado la pantalla");
}

void actuadores::mostrarpantalla(String msg1,String msg2) {
  LCD.clear();
  LCD.setCursor ( 0, 0 );   	        /*~ ( columnas, filas) Ubicamos el cursor en la primera posición(columna:0) de la primera línea(fila:0) ~*/
  LCD.print ( "Fecha: " );
  LCD.print(msg1);
  LCD.setCursor ( 0, 1 );   	        /*~ ( columnas, filas) Ubicamos el cursor en la primera posición(columna:0) de la primera línea(fila:0) ~*/
  LCD.print ( "Hora: " );
  LCD.print(msg2);


}

// void actuadores::relay(bool bandera){
//   if(bandera){
//     digitalWrite(relay_dht, state_s);
//     if(!estado_relay){
//       Serial.println("La bandera se ha activado");
//       myRTC.get_time();
//       fecha_relay_on=myRTC.format_date('/');
//       hora_relay_on=myRTC.format_time();
//       estado_relay= true;
//     }else{
//       Serial.println("La bandera se ha desactivado");
//       myRTC.get_time();
//       fecha_relay_off=myRTC.format_date('/');
//       hora_relay_off=myRTC.format_time();
//       estado_relay= false;
//     }
//   }else{
//     digitalWrite(relay_dht, state_r);
//   }
//}

void actuadores::relay(bool bandera){
  if(bandera != estado_relay){
    String temp= "";
    if(bandera){
      Serial.println("La bandera se ha activado");
      myRTC.get_time();
      digitalWrite(relay_dht,HIGH);
    fecha_relay_on=myRTC.format_date('/');
    hora_relay_on=myRTC.format_time();
    }else{
      Serial.println("La bandera se ha desactivado");
      digitalWrite(relay_dht,LOW);
      myRTC.get_time();
       fecha_relay_off=myRTC.format_date('/');
    hora_relay_off=myRTC.format_time();
      temp = myJSON.json_relay();
        mySD.SaveFile(temp);
        mySD.ReadFile();
    }
  }
  estado_relay=bandera;
}

#endif

actuators.h

#ifndef sensores_h
#define sensores_h
#define DHT 13

DHTesp dhtSensor;
class sensores {
  public:
    void iniciar_sensores(void);
    String leer_sensores(void);
    float get_temperature(void);
    float get_humidity(void);

};

void sensores::iniciar_sensores(void) {
  pinMode(DHT,INPUT);
  dhtSensor.setup(DHT, DHTesp::DHT22);
  Serial.println("Se ha inicializado el sensor DHT22");
}

float sensores::get_temperature(void) {
  TempAndHumidity  data = dhtSensor.getTempAndHumidity();
 return data.temperature;
  
 
}

float sensores::get_humidity(void) {
  TempAndHumidity  data = dhtSensor.getTempAndHumidity();
 return data.humidity;
  
}



#endif

sensores.h

/* Se incluye librería y se crea objeto para la configuración del cliente WiFi */
#include <WiFi.h>
  WiFiClient ESP32_WIFI;

/* Se incluye librería paa utilizar el protocolo de telemetría MQTT, con el objeto correspondiente */
#include "PubSubClient.h"
  PubSubClient client ( ESP32_WIFI );

/* Directivas de configuración de red y parámetros MQTT */
#define HOTSPOT_WIFI  "Wokwi-GUEST"            /* Nombre del punto de acceso a conectarse */
#define HOTSPOT_PWD   ""                       /* Contraseña de la red */
#define MQTT_SERVER   "test.mosquitto.org"     /* Dirección del Broker MQTT */
#define MQTT_PORT     1883                     /* Puerto del Broker MQTT */
#define TXTOPIC       "/TX_ESLI"         /* Nombre del topic de publicación */
#define RXTOPIC       "/RX_ESLI"         /* Nombre del topic de suscripción */
#define RXTOPIC1      "/Esli"        /* Nombre del topic de suscripción */

/* Clase para la gestión de la red WiFi y el protocolo MQTT */
class MQTT {
  
  public:
  /* MÉTODOS */
  public:
    void subscribe_MQTT ( void );            /* Conecta al usuario como un suscriptor MQTT */
    void publish_MQTT ( void );              /* Conecta al usuario como un pulicador MQTT */
    void reconnect_MQTT ( void );            /* Realiza la reconexión al servidor MQTT */
    void setup_WiFi ( void );                /* Configura lo necesario para conectarse a una red WiFi */ 
    void set_MQTT_server ( void );           /* Establece la dirección del Broker MQTT a utilizar */
    void set_MQTT_callback ( void );         /* Se configura la obtención de la información como suscriptor */
    static void callback ( char* , byte* , unsigned int ); /* Método que obtiene la trama realizada en las suscripciones */

  };

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ set_MQTT_server ( void ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*                      Función que configura el puerto y la dirección del Broker MQTT a utilizar.                     *
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

void MQTT :: set_MQTT_server ( void ) {

  client.setServer ( MQTT_SERVER, MQTT_PORT );            /* Función librería PubsubClient */
  
}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ set_MQTT_callback ( void ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*                      Función que configura la función que recibirá la trama proveniente de los datos              *
*                      mostrados en la suscripción .                                                                *
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

void MQTT :: set_MQTT_callback ( void ) {

  client.setCallback (this -> callback);                 /* Función librería PubsubClient */

}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ subscribe_MQTT ( void ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*                      Función que se suscribe a un topic MQTT, puede tener múltiples suscripciones.                *
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

void MQTT :: subscribe_MQTT ( void ) {

  client.subscribe( RXTOPIC );                           /* Función librería PubsubClient */
  //client.subscribe( RXTOPIC1 );                          /* Función librería PubsubClient */
  
}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ publish_MQTT ( void ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*                      Función que publica información hacia a un topic MQTT.                                       *
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

void MQTT :: publish_MQTT ( void ) {

  String hola = "Es más dura la verdura";
  Serial.println ( F ( "Publicando información" ) );
  client.publish( TXTOPIC, "Siiiuuuuu");                 /* Función librería PubsubClient */
  //client.publish( TXTOPIC, hola.c_str ( ) );
   
}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ reconnect_MQTT ( void ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*                      Función que se reeconecta al servidor MQTT como cliente, tanto para publicar como suscribirse*
*                      a un topic.                                                                                  *
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

void MQTT :: reconnect_MQTT ( void ) {

  if ( ! client.connected ( ) ) {                         /* ¿Está el cliente desconectado? */

    while ( ! client.connected ( ) ) {                    /* Mientras que está desconectado */
      
      Serial.print ( F ( "Conectando nuevamente al servidor" ) );

      if ( client.connect ( "Client_test" ) ) {             /* Si el cliente se conecta, el cliente puede tener autentificación */
        
        Serial.println ( F ( "Cliente conectado" ) );
        
        subscribe_MQTT ( );                                 /* Suscribirse al topic */
        
      } else {    
                                                  /* Si el cliente no se conecta */
        Serial.print ( F ( "Falló al conectarse, tipo de error: " ) );
        Serial.print ( client.state ( ) );                  /* Mostrar el estado o error, e intentarlo nuevamente */
        Serial.println ( F ( "Intentando nuevamente en 5 segundos" ) );
          delay ( 5000 );

        }
    }
  }
  client.loop ( );
  
}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ setup_WiFi ( void ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*                      Función que se configura y se conecta a una red WiFi                                         *
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

void MQTT :: setup_WiFi ( void ) {

  delay ( 10 );
  Serial.println ( F ( "Configurando WiFi: " ) );
  WiFi.begin ( HOTSPOT_WIFI, HOTSPOT_PWD );               /* Iniciar intentos de conexión hacia la red WiFi */
  
  
  while ( WiFi.status ( ) != WL_CONNECTED ) {            /* Mientras que no se haya conectado a la red especificada */
    
    delay ( 500 );
    Serial.print ( F ( "." ) );                                /* Mostrar un mensaje de espera */ 
    
  }
  //Serial.println ( "WiFi configurado con la IP: " );
  
}

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ callback ( char* topic, byte* message, unsigned int length ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*                      Función que obtiene los mensajes mandados hacia el topic al cual se está suscrito                                                      *
*                      NOTA: Los paráetros de está función están de acuerdo con los que vienen en la librería Pubsubclient                                    *
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

void MQTT :: callback(char* topic, byte* message, unsigned int length) {

  Serial.print ( F ( "Ha llegado un mensaje de: " ) );
  Serial.println ( topic );                             /* Topic al cual se está suscrito */
  
  String messageTemp;
  
  for ( int i = 0; i < length; i++ ) {
    //Serial.print((char)message[i]);
    messageTemp += (char)message[i];                    /* El mensaje proviene en bytes por lo que es necesario concatenarlo */
  }

  Serial.println( messageTemp );


  }