Registro de datos ESP32 con DHT22 y marcas de tiempo NTP

¿Te gustaría crear un proyecto que no solo pueda medir la temperatura y la humedad, sino que además registre esos datos a lo largo del tiempo? Con el ESP32 y unos pocos componentes, es totalmente posible. En este tutorial, te guiaremos a través de los pasos necesarios para construir un registrador de datos que usa el sensor DHT22 para medir condiciones ambientales y almacena esta información en una tarjeta microSD con marcas de tiempo precisas. ¡Vamos a comenzar!

Descripción del proyecto

En este proyecto, vamos a construir un registrador de datos utilizando el ESP32, un dispositivo versátil y potente que nos permitirá realizar lecturas de temperatura y humedad de manera continua.

El ESP32 verificará el sensor DHT22 cada 2 segundos, obteniendo medidas de temperatura y humedad. Además, cada lectura incluirá un timestamp (marca de tiempo) obtenido de un servidor de Protocolo de Tiempo de Red (NTP), asegurando que cada dato esté correctamente etiquetado con la fecha y hora en un formato legible: “YYYY-MM-DD HH:MM:SS”.

Los datos se guardarán en un archivo llamado “log.txt” en la tarjeta microSD. Cada nueva medición se añadirá como una nueva línea en el archivo, mostrando el timestamp, la temperatura en grados Celsius y la humedad en porcentaje, separados por comas.

Lectura recomendada

Antes de adentrarte en este proyecto, es recomendable que revises algunas guías previas. Estos tutoriales te ayudarán a comprender los fundamentos sobre cómo utilizar una tarjeta microSD con el ESP32 y cómo obtener la hora desde Internet mediante un servidor NTP.

Preparación de la tarjeta microSD

Antes de utilizar tu tarjeta microSD en un proyecto, es crucial asegurarte de que esté correctamente formateada con un sistema de archivos adecuado, ya sea FAT16 o FAT32. Esto garantiza que el ESP32 pueda leer y escribir archivos sin inconvenientes.

Si estás usando una tarjeta nueva, puede que ya esté formateada con un sistema FAT, pero es recomendable formatearla de nuevo para evitar posibles problemas. Para una tarjeta más antigua, el formateo es esencial.

Existen dos métodos para formatear tu tarjeta microSD:

Método 1: Formato básico

Inserta tu tarjeta microSD en la computadora. Luego, localiza la unidad de la tarjeta, haz clic derecho sobre ella y selecciona “Formato”. En la ventana emergente, elige FAT32 como sistema de archivos y presiona “Iniciar” para comenzar el proceso. Sigue las instrucciones en pantalla hasta que finalice.

Método 2: Utilidad de formato oficial

Para mejores resultados, se recomienda utilizar la utilidad de formateo oficial de la Asociación SD. Esta herramienta es más confiable que el formateador básico de tu computadora y puede evitar problemas comunes asociados con formatos defectuosos o incompletos.

Conexión del sensor DHT22 y del módulo de tarjeta microSD al ESP32

Ahora es el momento de conectar el sensor DHT22 y el módulo de tarjeta microSD al ESP32.

Conexiones del módulo de tarjeta microSD

• Conecta el pin 3V3 del módulo de tarjeta microSD al pin de alimentación de 3.3V del ESP32.
• Conecta el pin GND del módulo a uno de los pines GND del ESP32.
• Configura los pines para la comunicación SPI, que son cruciales para una transferencia de datos rápida. Los pines SPI por defecto en el ESP32 son:

Conexiones del sensor DHT22

• Conecta el pin VCC del sensor DHT22 al pin de 3.3V del ESP32.
• Conecta el pin GND del sensor a GND del ESP32.
• Conecta el pin de datos del DHT22 al pin D4 del ESP32. Es recomendable añadir una resistencia de pull-up de 10K entre el pin de datos y el pin VCC para asegurar una señal clara. Si usas una placa de expansión, generalmente esta resistencia ya estará incluida.

Configuración del entorno de desarrollo Arduino (IDE)

Usaremos el Arduino IDE para programar el ESP32, así que asegúrate de tener instalado el complemento para el ESP32 antes de continuar.

Instalación de bibliotecas necesarias

Los sensores DHT utilizan un protocolo único de comunicación de un solo hilo para transmitir datos de temperatura y humedad. Aunque este protocolo no es estándar, es similar al protocolo Dallas 1-Wire y depende de un temporizador muy preciso para funcionar correctamente.

No te preocupes por manejar toda la codificación de bajo nivel relacionada con el tiempo. Existe una biblioteca útil llamada DHT sensor library que simplifica prácticamente todos los aspectos de esta tarea.

Para instalar la biblioteca, sigue estos pasos:

1. Abre tu programa de Arduino IDE y haz clic en el ícono de Gestor de Bibliotecas en la barra lateral izquierda.
2. Escribe “DHT sensor” en el cuadro de búsqueda para filtrar los resultados.
3. Busca la biblioteca “DHT sensor library” creada por Adafruit.
4. Haz clic en el botón Instalar para agregarla a tu IDE de Arduino.

Además, dado que la biblioteca del sensor DHT depende de otras bibliotecas, se te pedirá que instales sus dependencias, que incluyen la Adafruit Unified Sensor Library. Cuando aparezca este mensaje, simplemente haz clic en INSTALAR TODO para asegurarte de que todo esté configurado correctamente.

Código de ejemplo para el registro de datos

Copia el siguiente código en tu Arduino IDE, pero antes de subirlo al ESP32, hay algunas modificaciones importantes que debes realizar para que funcione correctamente en tu configuración:

1. Actualiza las siguientes dos variables con tus credenciales de red para que el ESP32 pueda conectarse a tu red:

   // Reemplaza con tus credenciales de red
   const char* ssid = "REPLACE_WITH_YOUR_SSID";
   const char* password = "REPLACE_WITH_YOUR_PASSWORD";

2. Configura el desfase UTC correcto para tu zona horaria. UTC (Tiempo Universal Coordinado) es un estándar de tiempo utilizado a nivel mundial. Tu zona horaria es un número determinado de horas por delante o detrás de UTC. Consulta la lista de desfases UTC.

   El desfase debe escribirse en segundos. Por ejemplo, si estás en una zona horaria que está 5 horas detrás de UTC (como el horario estándar del este en EE. UU.), tu desfase sería -5 * 60 * 60, lo que equivale a -18000 segundos. Si estás en horario de Europa Central, que es UTC +1, tu desfase sería 1 * 60 * 60, o 3600 segundos. Aquí hay algunos ejemplos:

   • Para UTC -5.00 : -5 * 60 * 60 : -18000
   • Para UTC +1.00 : 1 * 60 * 60 : 3600
   • Para UTC +0.00 : 0 * 60 * 60 : 0

   const long gmtOffset_sec = -18000;

3. También necesitas establecer el desfase por horario de verano (en segundos). Si tu país o región observa horario de verano, entonces establece el desfase diurno en 3600 segundos (lo que equivale a 1 hora). De lo contrario, simplemente configúralo en 0.

   const int daylightOffset_sec = 3600;

Después de realizar estos cambios, puedes subir el código al ESP32.

// Librerías para SD card
#include "FS.h"
#include "SD.h"
#include <SPI.h>

// Librería para sensor DHTxx
#include "DHT.h"

// Librerías para obtener la hora desde el servidor NTP
#include <WiFi.h>
#include "time.h"

// Reemplaza con tus credenciales de red
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Variables del temporizador
unsigned long lastTime = 0;
unsigned long timerDelay = 2000;  // Registrar datos cada 2 segundos

// Configuración del sensor DHT
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);  // Inicializar sensor DHT

// Configuración del servidor NTP
const char* ntpServer = "pool.ntp.org";
const long gmtOffset_sec = -18000;
const int daylightOffset_sec = 3600;

// Función que obtiene la fecha y hora formateadas en formato YYYY-MM-DD HH:MM:SS
String getFormattedDateTime() {
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    Serial.println("Error al obtener la hora");
    return "";
  }
  char timeStringBuff[20];  // Buffer para la cadena de tiempo formateada
  strftime(timeStringBuff, sizeof(timeStringBuff), "%Y-%m-%d %H:%M:%S", &timeinfo);
  return String(timeStringBuff);
}

// Función que escribe en la tarjeta SD
void writeFile(fs::FS& fs, const char* path, const char* message) {
  Serial.printf("Escribiendo archivo: %sn", path);
  File file = fs.open(path, FILE_WRITE);
  if (!file) {
    Serial.println("Error al abrir el archivo para escribir");
    return;
  }
  if (file.print(message)) {
    Serial.println("Archivo escrito");
  } else {
    Serial.println("Error al escribir");
  }
  file.close();
}

// Función que añade datos a la tarjeta SD
void appendFile(fs::FS& fs, const char* path, const char* message) {
  Serial.printf("Añadiendo al archivo: %sn", path);
  File file = fs.open(path, FILE_APPEND);
  if (!file) {
    Serial.println("Error al abrir el archivo para añadir");
    return;
  }
  if (file.print(message)) {
    Serial.println("Mensaje añadido");
  } else {
    Serial.println("Error al añadir");
  }
  file.close();
}

void setup() {
  Serial.begin(115200);

  // Inicializar sensor DHT
  dht.begin();
  Serial.println("Sensor DHT inicializado");

  // Conectar a WiFi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Conectando a WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println("");
  Serial.print("Conectado a WiFi. Dirección IP: ");
  Serial.println(WiFi.localIP());

  // Inicializar tarjeta SD
  if (!SD.begin()) {
    Serial.println("Error al montar la tarjeta");
    return;
  }
  Serial.println("Tarjeta SD inicializada");

  // Configurar hora con el servidor NTP
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  Serial.println("Hora NTP configurada");

  // Verificar si el archivo de registro existe, crear si no existe
  File file = SD.open("/log.txt");
  if (!file) {
    Serial.println("El archivo de registro no existe");
    Serial.println("Creando archivo de registro...");
    writeFile(SD, "/log.txt", "Timestamp,Temperatura (°C),Humedad (%)rn");
  } else {
    Serial.println("El archivo de registro ya existe");
  }
  file.close();

  Serial.println("Configuración completa. Iniciando registro de datos...");
}

void loop() {
  if ((millis() - lastTime) > timerDelay) {
    // Obtener fecha y hora formateadas
    String formattedDateTime = getFormattedDateTime();

    // Obtener lecturas de temperatura y humedad
    float temp = dht.readTemperature();
    float hum = dht.readHumidity();

    // Proceder solo si obtuvimos datos válidos
    if (formattedDateTime != "" && !isnan(temp) && !isnan(hum)) {
      // Concatenar toda la información separada por comas
      String dataMessage = formattedDateTime + "," + String(temp, 2) + "," + String(hum, 2) + "rn";
      Serial.print("Guardando datos: ");
      Serial.print("Hora: ");
      Serial.print(formattedDateTime);
      Serial.print(", Temperatura: ");
      Serial.print(temp, 2);
      Serial.print("°C");
      Serial.print(", Humedad: ");
      Serial.print(hum, 2);
      Serial.println("%");

      // Añadir los datos al archivo
      appendFile(SD, "/log.txt", dataMessage.c_str());
    } else {
      // Imprimir mensajes de error para depuración
      if (formattedDateTime == "") {
        Serial.println("Error: No se pudo obtener la hora del servidor NTP");
      }
      if (isnan(temp) || isnan(hum)) {
        Serial.println("Error: No se pudo leer del sensor DHT");
      }
    }

    lastTime = millis();
  }
}

Demostración del funcionamiento del código

Después de subir el sketch a tu ESP32, abre el Monitor Serial y asegúrate de que la tasa de baudios esté configurada en 115200. Luego, presiona el botón EN (reset) en tu ESP32. Si todo está configurado correctamente, deberías empezar a ver mensajes en el Monitor Serial que indican que el ESP32 se está conectando a Wi-Fi, obteniendo la hora de Internet, leyendo los datos del sensor y guardándolos en la tarjeta SD.

Deja que tu ESP32 funcione durante un tiempo, tal vez unas horas, para que pueda recoger suficientes datos de temperatura y humedad. Cuando estés listo para verificar los resultados, retira la tarjeta microSD del módulo e insértala en tu computadora mediante un lector de tarjetas SD. En la tarjeta, deberías encontrar un archivo llamado log.txt.

Este archivo contendrá todas las lecturas, incluyendo la fecha y hora, la temperatura en grados Celsius y la humedad en porcentaje. Puedes abrir el archivo log.txt usando un editor de texto simple o, mejor aún, copiar su contenido en Microsoft Excel o Google Sheets. Allí podrás crear gráficos que te ayudarán a visualizar cómo cambiaron la temperatura y la humedad a lo largo del tiempo, facilitando así el análisis de los datos.

Explicación del código

El sketch comienza incluyendo varias bibliotecas: Las bibliotecas FS, SD y SPI permiten que el ESP32 utilice el protocolo SPI para comunicarse con la tarjeta microSD y gestionar operaciones de archivos como crear, escribir y leer archivos. La biblioteca DHT ayuda al ESP32 a leer la temperatura y la humedad del sensor DHT22. Las bibliotecas WiFi y time permiten que el ESP32 se conecte a Internet y obtenga la hora actual desde un servidor NTP.

// Librerías para SD card
#include "FS.h"
#include "SD.h"
#include <SPI.h>

// Librería para sensor DHTxx
#include "DHT.h"

// Librerías para obtener la hora desde el servidor NTP
#include <WiFi.h>
#include "time.h"

A continuación, se definen dos variables para tu conexión Wi-Fi: una para el nombre de la red (SSID) y otra para la contraseña. Este paso es fundamental porque el ESP32 necesita conectarse a tu Wi-Fi para poder contactar al servidor NTP y obtener la hora correcta.

// Reemplaza con tus credenciales de red
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Luego, se crea un temporizador simple utilizando dos variables. La variable lastTime recuerda cuándo se registraron datos por última vez, y timerDelay establece con qué frecuencia registramos de nuevo. En este caso, timerDelay se establece en 2000 milisegundos (2 segundos), por lo que el ESP32 intentará registrar datos cada dos segundos.

// Variables del temporizador
unsigned long lastTime = 0;
unsigned long timerDelay = 2000;  // Registrar datos cada 2 segundos

Después, se especifica a qué pin está conectado el sensor DHT22. En nuestro caso, es el pin GPIO 4. También se especifica el tipo de sensor DHT que estamos usando. A continuación, se crea un objeto DHT en el código que nos permitirá utilizar comandos simples para obtener lecturas de temperatura y humedad del sensor.

// Configuración del sensor DHT
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);  // Inicializar sensor DHT

Después, configuramos la información de NTP. Elegimos un servidor de tiempo, en este caso, “pool.ntp.org”, y le indicamos al ESP32 cómo ajustar desde UTC (Tiempo Universal Coordinado) a tu zona horaria local. Usamos gmtOffset_sec para ajustar la zona horaria y daylightOffset_sec para añadir horario de verano si tu ubicación lo utiliza. Por ejemplo, un gmtOffset_sec de -18000 significa UTC-5, que se utiliza en el horario estándar del este, y un desfase diurno de 3600 añade una hora para el horario de verano. Debes cambiar estos valores según donde vivas. Si no son correctos, tus timestamps se verán erróneos incluso si el tiempo NTP está funcionando correctamente.

// Configuración del servidor NTP
const char* ntpServer = "pool.ntp.org";
const long gmtOffset_sec = -18000;
const int daylightOffset_sec = 3600;

El servidor “pool.ntp.org” es un buen valor por defecto ya que se conecta automáticamente a un servidor de tiempo cercano. Si lo prefieres, puedes elegir un servidor regional como “europe.pool.ntp.org” o “asia.pool.ntp.org” dependiendo de tu ubicación.

A continuación, definimos una función personalizada llamada getFormattedDateTime(). Esta función solicita al sistema la hora actual, que se configuró anteriormente usando el servidor NTP. Luego, formatea la fecha y la hora en una cadena legible, como “2025-08-13 16:45:23”, utilizando una función incorporada llamada strftime(). Si la función no puede obtener la hora, imprime un mensaje y devuelve una cadena vacía.

// Función que obtiene la fecha y hora formateadas en formato YYYY-MM-DD HH:MM:SS
String getFormattedDateTime() {
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    Serial.println("Error al obtener la hora");
    return "";
  }
  char timeStringBuff[20];  // Buffer para la cadena de tiempo formateada
  strftime(timeStringBuff, sizeof(timeStringBuff), "%Y-%m-%d %H:%M:%S", &timeinfo);
  return String(timeStringBuff);
}

También creamos dos funciones más personalizadas para escribir en la tarjeta SD. La primera, writeFile(), se utiliza para crear un nuevo archivo; se usa al principio para crear el archivo de registro con una línea de encabezado. La segunda, appendFile(), se usa para añadir nuevos datos al final de un archivo existente, que es lo que utilizamos de manera repetida durante el registro de datos. Ambas funciones abren el archivo, intentan escribir datos y luego cierran el archivo cuando han terminado. Si algo sale mal, imprimen un mensaje en el Monitor Serial.

// Función que escribe en la tarjeta SD
void writeFile(fs::FS& fs, const char* path, const char* message) {
  Serial.printf("Escribiendo archivo: %sn", path);
  File file = fs.open(path, FILE_WRITE);
  if (!file) {
    Serial.println("Error al abrir el archivo para escribir");
    return;
  }
  if (file.print(message)) {
    Serial.println("Archivo escrito");
  } else {
    Serial.println("Error al escribir");
  }
  file.close();
}

// Función que añade datos a la tarjeta SD
void appendFile(fs::FS& fs, const char* path, const char* message) {
  Serial.printf("Añadiendo al archivo: %sn", path);
  File file = fs.open(path, FILE_APPEND);
  if (!file) {
    Serial.println("Error al abrir el archivo para añadir");
    return;
  }
  if (file.print(message)) {
    Serial.println("Mensaje añadido");
  } else {
    Serial.println("Error al añadir");
  }
  file.close();
}

En la sección setup(), comenzamos la comunicación serial para poder imprimir mensajes en el Monitor Serial. También inicializamos el sensor DHT con dht.begin().

Serial.begin(115200);

// Inicializar sensor DHT
dht.begin();
Serial.println("Sensor DHT inicializado");

A continuación, intentamos conectar el ESP32 a la red Wi-Fi. Usamos la función WiFi.mode() para poner el radio Wi-Fi en modo estación y la función WiFi.begin() para conectarnos, proporcionando el nombre de la red y la contraseña.

// Conectar a WiFi
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);

Mientras el ESP32 intenta conectarse, verificamos su estado de conexión usando WiFi.status(). Si no está conectado aún, espera un momento y vuelve a intentarlo hasta que tenga éxito.

Serial.print("Conectando a WiFi ..");
while (WiFi.status() != WL_CONNECTED) {
  Serial.print('.');
  delay(1000);
}
Serial.println("");

Para referencia, la función WiFi.status() puede devolver los siguientes estados:

• WL_CONNECTED: Conectado a una red Wi-Fi.
• WL_NO_SHIELD: No se detectó un escudo Wi-Fi (no aplicable al ESP32, pero relevante para algunas placas Arduino).
• WL_IDLE_STATUS: Estado temporal durante el intento de conexión tras llamar a WiFi.begin().
• WL_NO_SSID_AVAIL: No se encontraron redes que coincidan con el SSID especificado.
• WL_SCAN_COMPLETED: La exploración de redes ha finalizado.
• WL_CONNECT_FAILED: Falló la conexión tras todos los intentos.
• WL_CONNECTION_LOST: Se perdió la conexión con la red.
• WL_DISCONNECTED: No conectado a ninguna red.

Una vez que el ESP32 está conectado a tu red Wi-Fi, imprime la dirección IP que recibió de tu router usando WiFi.localIP(), para que sepas que está en línea.

Serial.print("Conectado a WiFi. Dirección IP: ");
Serial.println(WiFi.localIP());

Luego, intentamos inicializar la tarjeta SD. Si falla la inicialización, imprimirá un mensaje de error y se detendrá.

// Inicializar tarjeta SD
if (!SD.begin()) {
  Serial.println("Error al montar la tarjeta");
  return;
}
Serial.println("Tarjeta SD inicializada");

A continuación, llamamos a la función configTime() para sincronizar el reloj interno del ESP32 con el servidor NTP usando los desfases de tiempo que configuramos anteriormente. Una vez hecho esto, el ESP32 conoce la fecha y la hora correctas y las mantendrá incluso si se desconecta de Wi-Fi.

// Configurar hora con el servidor NTP
configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
Serial.println("Hora NTP configurada");

Antes de comenzar a registrar datos, verificamos si el archivo /log.txt ya existe en la tarjeta microSD. Si no existe, lo creamos y escribimos una línea de encabezado que etiqueta las columnas: Timestamp, Temperatura (°C) y Humedad (%). Esto facilita la lectura del archivo más tarde en Excel o Google Sheets. Si el archivo ya existe, lo dejamos intacto para proteger los datos antiguos. Luego cerramos el archivo e imprimimos un mensaje que indica que la configuración está completa, para que sepas que el sistema está listo para comenzar a grabar.

// Verificar si el archivo de registro existe, crear si no existe
File file = SD.open("/log.txt");
if (!file) {
  Serial.println("El archivo de registro no existe");
  Serial.println("Creando archivo de registro...");
  writeFile(SD, "/log.txt", "Timestamp,Temperatura (°C),Humedad (%)rn");
} else {
  Serial.println("El archivo de registro ya existe");
}
file.close();

Serial.println("Configuración completa. Iniciando registro de datos...");

En la función loop(), el programa verifica cuánto tiempo ha pasado comparando el tiempo actual de millis() con el valor de lastTime. Si la diferencia es mayor que nuestro timerDelay, entonces es hora de registrar nuevos datos.

Llamamos a la función getFormattedDateTime() para obtener la hora actual como una cadena, y usamos el objeto DHT para leer la temperatura y la humedad.

if ((millis() - lastTime) > timerDelay) {
  // Obtener fecha y hora formateadas
  String formattedDateTime = getFormattedDateTime();

  // Obtener lecturas de temperatura y humedad
  float temp = dht.readTemperature();
  float hum = dht.readHumidity();

A continuación, verificamos que las tres lecturas sean válidas: la cadena de tiempo no debe estar vacía y ni la temperatura ni la humedad pueden ser NaN (no es un número). Si son válidas, creamos una línea de datos uniendo la hora, la temperatura (redondeada a dos decimales) y la humedad (también redondeada), separadas por comas y con un salto de línea al final. Imprimimos esta línea en el Monitor Serial para que puedas ver los datos en vivo, y luego llamamos a appendFile() para guardarla en la tarjeta SD en el archivo log.txt.

Si el timestamp está vacío o las lecturas del sensor son inválidas (lo cual se mostraría como “NaN”), imprimimos mensajes de error para ayudar en la depuración.

// Proceder solo si obtuvimos datos válidos
if (formattedDateTime != "" && !isnan(temp) && !isnan(hum)) {
  // Concatenar toda la información separada por comas
  String dataMessage = formattedDateTime + "," + String(temp, 2) + "," + String(hum, 2) + "rn";
  Serial.print("Guardando datos: ");
  Serial.print("Hora: ");
  Serial.print(formattedDateTime);
  Serial.print(", Temperatura: ");
  Serial.print(temp, 2);
  Serial.print("°C");
  Serial.print(", Humedad: ");
  Serial.print(hum, 2);
  Serial.println("%");

  // Añadir los datos al archivo
  appendFile(SD, "/log.txt", dataMessage.c_str());
} else {
  // Imprimir mensajes de error para depuración
  if (formattedDateTime == "") {
    Serial.println("Error: No se pudo obtener la hora del servidor NTP");
  }
  if (isnan(temp) || isnan(hum)) {
    Serial.println("Error: No se pudo leer del sensor DHT");
  }
}

Finalmente, actualizamos lastTime al valor actual de millis() para que el siguiente ciclo de registro comience aproximadamente dos segundos después.

Resolución de problemas

Fallo en el montaje de la tarjeta

Si ves el mensaje de error “Fallo en el montaje de la tarjeta” en el Monitor Serial, esto generalmente significa que hay un problema con la forma en que el módulo de la tarjeta SD está conectado al ESP32. Verifica todas tus conexiones para asegurarte de que cada cable está en el pin correcto y que están firmemente conectados. Además, tu tarjeta microSD debe estar formateada utilizando los sistemas de archivos FAT16 o FAT32; otros formatos como exFAT no funcionarán.

Algunos sitios pueden recomendarte alimentar tu módulo de tarjeta microSD con 5V, pero no lo hagas a menos que estés seguro de que tu módulo tiene un regulador de voltaje incorporado y un convertidor de nivel lógico. La mayoría de las tarjetas microSD están diseñadas para funcionar a 3.3 voltios, y proporcionarles 5V directamente podría dañarlas de forma permanente.

No se pudo obtener la hora del servidor NTP

Otro problema común es el mensaje “Error: No se pudo obtener la hora del servidor NTP”. Esto significa que el ESP32 no pudo obtener la hora actual de Internet. La razón más probable es que tu ESP32 no se conectó correctamente a Internet. Asegúrate de que tu red tenga acceso a Internet.

También ten en cuenta que el sistema NTP utiliza el puerto UDP 123, y en algunas redes, especialmente en redes de escuelas, empresas o redes de invitados, este puerto puede estar bloqueado por un cortafuegos. En caso de ser así, intenta conectar el ESP32 a otra red Wi-Fi, como tu enrutador doméstico o un hotspot móvil.

Puedes probar diferentes direcciones de servidores NTP, como time.nist.gov. También puedes proporcionar múltiples servidores en tu función configTime() para que, si uno falla, los otros puedan actuar como respaldo.