Registra temperatura en microSD con Arduino y ESP32 (RTC + DHT22)

Guarda hora, temperatura y humedad en una microSD con Arduino, ESP8266 o ESP32 usando un módulo RTC DS1307 y un sensor DHT22.

15 de julio de 202645 min de armado~CLP $20.000

Registra temperatura en microSD con Arduino y ESP32 (RTC + DHT22)

Necesitas

Lista de materiales

Módulo lector microSD (SPI)
core
no disponible
Sensor DHT22
temperatura y humedad
no disponible
Módulo RTC DS1307
reloj en tiempo real
no disponible
Tarjeta microSD 32GB FAT32
almacenamiento
no disponible
Placa Arduino Uno
controlador (opción A)
no disponible
Placa ESP32 NodeMCU
controlador (opción B)
no disponible
Protoboard 830 puntos
prototipado
no disponible
Jumpers macho-hembra 20 cm
conexiones
no disponible

¿Qué haces cuando quieres registrar datos en un lugar sin WiFi, como el patio o el invernadero? La memoria interna del microcontrolador es de apenas unos megabytes y se borra en cada reinicio. La solución es guardar todo en una tarjeta microSD. En este tutorial vas a armar un registrador de temperatura que anota la hora, la temperatura y la humedad en una microSD, y vas a aprender a leer esos datos de vuelta. Sirve para Arduino, ESP8266 y ESP32, y al final vas a poder adaptar el mismo montaje a cualquier proyecto de datalogging.

Cómo es el módulo microSD por dentro

Antes de conectar, vale la pena entender qué trae el módulo. La tarjeta microSD trabaja con lógica de 3.3 V, mientras que un Arduino opera a 5 V. Por eso el módulo incluye dos componentes clave:

Regulador de voltaje: baja los 5 V de alimentación a los 3.3 V que necesita la tarjeta.
Conversor de nivel lógico (level shifter): el chip 74LVC125A traduce las señales SPI entre 5 V y 3.3 V, porque el regulador solo baja la alimentación, no las señales de datos.

La tarjeta SD ya trae su propia interfaz SPI integrada, así que no se necesitan más componentes. Importante: la microSD debe estar formateada como FAT16 o FAT32, y muchos módulos tienen un límite de 32 GB.

Módulo lector de tarjeta microSD y shield para Arduino Uno

Conexión por SPI

El módulo se comunica por SPI, el bus más rápido para transferir datos. Los pines típicos del módulo, de izquierda a derecha, son: GND, VCC, MISO, MOSI, SCK y CS. Cada placa tiene sus pines SPI por defecto, y el pin CS (Chip Select) puede ser cualquier pin digital que definas en el código.

Un detalle que ahorra horas de depuración: si usas un pin CS distinto al de por defecto, el pin CS por defecto de la placa debe quedar libre y configurado como salida, porque la librería SD lo reserva internamente. En Arduino el CS por defecto es el pin 10 y en ESP8266 el D8.

Diagrama de conexión del módulo microSD con Arduino Uno

Diagrama de conexión del módulo microSD con ESP32 NodeMCU

Registrador de temperatura para Arduino y ESP8266

Ahora armamos el registrador completo: lee temperatura y humedad de un sensor DHT22, toma la hora de un módulo de reloj en tiempo real (RTC DS1307) y escribe todo en la microSD. La única librería que no viene por defecto es RTClib, que instalas desde el gestor de librerías del IDE de Arduino.

Diagrama de conexión del registrador de temperatura con RTC y microSD en Arduino Uno

C++

#include "SPI.h"
#include "SD.h"
#include "DHT.h"
#include "RTClib.h"

#define DHTPIN 7    // used for Arduino
//#define DHTPIN D4   // used for ESP8266

#define DHTYPE DHT22

const int chipSelect = 10;  // used for Arduino
//const int chipSelect = D8;  // used for ESP8266

DHT dht(DHTPIN, DHTYPE);
RTC_DS1307 rtc;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
  }
  if (!rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }
  if (!rtc.isrunning()) {
    Serial.println("RTC lost power, lets set the time!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  if (!SD.begin(chipSelect)) {
    Serial.println("Initialization failed!");
    while (1);
  }

  dht.begin();
}

void loop() {
  String dataString = "";
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  DateTime now = rtc.now();

  dataString += String(now.unixtime());
  dataString += ",";
  dataString += String(h);
  dataString += ",";
  dataString += String(t);

  File dataFile = SD.open("datalog.txt", FILE_WRITE);
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    Serial.println(dataString);
  } else {
    Serial.println("error opening datalog.txt");
  }
  delay(2000);
}

El código incluye las librerías SPI (comunicación con la SD), SD (lectura/escritura), DHT (sensor) y RTClib (reloj). En Arduino el DHT22 se lee del pin digital 7 y en ESP8266 del pin D4: solo comentas la línea de la placa que no uses. En el setup(), tres condicionales inicializan el RTC y la SD, y si algo falla verás el error en el monitor serial. En el loop() se arma un string con la hora Unix, la humedad y la temperatura separadas por comas, se abre datalog.txt con permiso de escritura, se escribe la línea y se cierra el archivo. Cada 2 segundos se repite.

Registrador de temperatura para ESP32

En el ESP32 el montaje es el mismo (DHT22 + RTC + microSD), pero el código cambia porque usa el sistema de archivos FS y funciones separadas para escribir y agregar líneas. El DHT22 se conecta al pin digital 2.

C++

#include "FS.h"
#include "SD.h"
#include "SPI.h"
#include "RTClib.h"
#include "DHT.h"

#define DHTPIN 2
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);
RTC_DS1307 rtc;

void writeFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Writing file: %s\n", path);
  File file = fs.open(path, FILE_WRITE);
  if (!file){
    Serial.println("Failed to open file for writing");
    return;
  }
  if (file.print(message)){
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  file.close();
}

void appendFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Appending to file: %s\n", path);
  File file = fs.open(path, FILE_APPEND);
  if (!file){
    Serial.println("Failed to open file for appending");
    return;
  }
  if (file.print(message)){
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

void setup(){
  Serial.begin(9600);
  dht.begin();
  if (!SD.begin()){
    Serial.println("Card Mount Failed");
    return;
  }
  if (!rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }
  if (!rtc.isrunning()) {
    Serial.println("RTC lost power, lets set the time!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }

  writeFile(SD, "/datalog_ESP32.txt", "Time, Humidity, Temperature \r\n");
}

void loop(){
  String dataString = "";
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  DateTime now = rtc.now();

  dataString += String(now.unixtime());
  dataString += ",";
  dataString += String(h);
  dataString += ",";
  dataString += String(t);
  dataString += "\r\n";
  Serial.println(dataString);
  appendFile(SD, "/datalog_ESP32.txt", dataString.c_str());
  delay(2000);
}

La diferencia principal: además de la librería SD, se incluye la librería FS (file system). La función writeFile() se ejecuta una sola vez para crear el archivo con un encabezado, y appendFile() se llama en cada ciclo del loop() para agregar una nueva línea con la marca de tiempo, la humedad y la temperatura, terminando con \r\n para saltar de línea.

Leer los datos desde la microSD

Una vez que tienes datos guardados, quieres recuperarlos. Este ejemplo abre el archivo sin permiso de escritura (solo lectura) y vuelca cada línea al monitor serial.

C++

#include "SPI.h"
#include "SD.h"

const int chipSelect = 10;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
  }
  if (!SD.begin(chipSelect)) {
    Serial.println("Initialization failed!");
    while (1);
  }
  File dataFile = SD.open("datalog.txt");
  if (dataFile) {
    Serial.println("datalog.txt:");
    // read from the file until there's nothing else in it:
    while (dataFile.available()) {
      Serial.write(dataFile.read());
    }
    dataFile.close();
  } else {
    Serial.println("error opening datalog.txt");
  }
}

void loop() {
}

La única diferencia con el registrador es que se abre el archivo sin el argumento FILE_WRITE, así el microcontrolador solo puede leer. El bucle while recorre cada fila del archivo de texto y la imprime en el serial. En el ESP32 se usa una función readFile() equivalente con la librería FS.

Variantes y mejoras

Estas extensiones no están en el tutorial original, pero potencian mucho el proyecto:

Enviar a una Raspberry Pi vía MQTT cuando hay WiFi: en el garaje guardas en la SD, pero cuando el dispositivo detecta una red conocida, publica los datos acumulados por MQTT a un broker en tu Raspberry Pi. Así tienes respaldo local y una base de datos central sin perder registros.
Guardar en formato CSV con encabezado: cambia el string a un CSV limpio (fecha,hora,temp,humedad) para abrirlo directo en una planilla de cálculo y graficar tendencias.
Estación meteorológica completa: combina el DHT22 con un sensor de presión BMP280 y un LDR para registrar también presión atmosférica y luz, todo en el mismo archivo.

Personalización para Chile

Todos los componentes están disponibles en el catálogo de MechatronicStore:

Módulo lector microSD (SPI). almacenamiento de datos
Sensor DHT22. temperatura y humedad
Módulo RTC DS1307. reloj en tiempo real (marca de tiempo)
Tarjeta microSD 32 GB (FAT32). soporte de datos
Placa Arduino Uno o placa ESP32 NodeMCU. controlador (elige según tu proyecto)
Protoboard 830 puntos y jumpers macho hembra. prototipado

Si en el tutorial original ves el "Data Logger Shield" de AZDelivery, no es imprescindible: con el módulo microSD suelto más el RTC DS1307 armas la misma función y eliges tú los pines.

Recursos

Tutorial original: SD Card Tutorial for Arduino, ESP8266 and ESP32
Librería recomendada: RTClib (Adafruit), instalable desde el gestor de librerías del IDE de Arduino

Versión chilena con componentes en stock local en MechatronicStore.

Paso a paso

Cómo armarlo

Conocer el módulo microSD
Identifica el regulador de 3.3 V y el level shifter 74LVC125A. Formatea la microSD como FAT16 o FAT32 (límite típico 32 GB).
Conectar por SPI
Cablea GND, VCC, MISO, MOSI, SCK y CS a los pines SPI de tu placa. En Arduino el CS por defecto es el pin 10; en ESP8266 el D8. Deja libre el CS por defecto si usas otro pin.
Agregar DHT22 y RTC DS1307
Conecta el DHT22 (pin 7 en Arduino, pin 2 en ESP32) y el RTC DS1307. Instala la librería RTClib desde el gestor de librerías del IDE de Arduino.
Cargar el registrador
Sube el código correspondiente a tu placa. En el loop se arma un string con hora Unix, humedad y temperatura, y se escribe en datalog.txt cada 2 segundos.
Leer los datos guardados
Carga el sketch de lectura para volcar el contenido de la microSD al monitor serial y verificar que el registro funciona.

Código fuente

Los snippets que necesitas

C++ · Registrador de temperatura para Arduino y ESP8266 (DHT22 + RTC + microSD)

#include "SPI.h"
#include "SD.h"
#include "DHT.h"
#include "RTClib.h"

#define DHTPIN 7    // used for Arduino
//#define DHTPIN D4   // used for ESP8266

#define DHTYPE DHT22

const int chipSelect = 10;  // used for Arduino
//const int chipSelect = D8;  // used for ESP8266

DHT dht(DHTPIN, DHTYPE);
RTC_DS1307 rtc;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
  }
  if (!rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }
  if (!rtc.isrunning()) {
    Serial.println("RTC lost power, lets set the time!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }
  if (!SD.begin(chipSelect)) {
    Serial.println("Initialization failed!");
    while (1);
  }

  dht.begin();
}

void loop() {
  String dataString = "";
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  DateTime now = rtc.now();

  dataString += String(now.unixtime());
  dataString += ",";
  dataString += String(h);
  dataString += ",";
  dataString += String(t);

  File dataFile = SD.open("datalog.txt", FILE_WRITE);
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    Serial.println(dataString);
  } else {
    Serial.println("error opening datalog.txt");
  }
  delay(2000);
}

C++ · Registrador de temperatura para ESP32 (FS + writeFile/appendFile)

#include "FS.h"
#include "SD.h"
#include "SPI.h"
#include "RTClib.h"
#include "DHT.h"

#define DHTPIN 2
#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);
RTC_DS1307 rtc;

void writeFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Writing file: %s\n", path);
  File file = fs.open(path, FILE_WRITE);
  if (!file){
    Serial.println("Failed to open file for writing");
    return;
  }
  if (file.print(message)){
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  file.close();
}

void appendFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Appending to file: %s\n", path);
  File file = fs.open(path, FILE_APPEND);
  if (!file){
    Serial.println("Failed to open file for appending");
    return;
  }
  if (file.print(message)){
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

void setup(){
  Serial.begin(9600);
  dht.begin();
  if (!SD.begin()){
    Serial.println("Card Mount Failed");
    return;
  }
  if (!rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }
  if (!rtc.isrunning()) {
    Serial.println("RTC lost power, lets set the time!");
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }

  writeFile(SD, "/datalog_ESP32.txt", "Time, Humidity, Temperature \r\n");
}

void loop(){
  String dataString = "";
  float h = dht.readHumidity();
  float t = dht.readTemperature();

  DateTime now = rtc.now();

  dataString += String(now.unixtime());
  dataString += ",";
  dataString += String(h);
  dataString += ",";
  dataString += String(t);
  dataString += "\r\n";
  Serial.println(dataString);
  appendFile(SD, "/datalog_ESP32.txt", dataString.c_str());
  delay(2000);
}

C++ · Leer los datos desde la microSD (Arduino y ESP8266)

#include "SPI.h"
#include "SD.h"

const int chipSelect = 10;

void setup() {
  Serial.begin(9600);
  while (!Serial) {
  }
  if (!SD.begin(chipSelect)) {
    Serial.println("Initialization failed!");
    while (1);
  }
  File dataFile = SD.open("datalog.txt");
  if (dataFile) {
    Serial.println("datalog.txt:");
    // read from the file until there's nothing else in it:
    while (dataFile.available()) {
      Serial.write(dataFile.read());
    }
    dataFile.close();
  } else {
    Serial.println("error opening datalog.txt");
  }
}

void loop() {
}

Etiquetas

#arduino #esp32 #microsd #rtc #dht22 #datalogger

Compartir este tutorial

WhatsApp X Email

Tutorial adaptado al español chileno desde el original en fuente original. Hicimos reescritura editorial + adaptación de precios CLP + linkeo con productos disponibles en MechatronicStore.

Más sobre Arduino

Tutoriales relacionados

Ver todos →

Registra temperatura en microSD con Arduino y ESP32 (RTC + DHT22)

Lista de materiales

Cómo es el módulo microSD por dentro

Conexión por SPI

Registrador de temperatura para Arduino y ESP8266

Registrador de temperatura para ESP32

Leer los datos desde la microSD

Variantes y mejoras

Personalización para Chile

Recursos

Cómo armarlo

Conocer el módulo microSD

Conectar por SPI

Agregar DHT22 y RTC DS1307

Cargar el registrador

Leer los datos guardados

Los snippets que necesitas

Tutoriales relacionados

Arduino de bajo consumo: reduce el gasto de batería hasta 89%

Sensor de distancia para estacionar el auto con Arduino, HC SR04 y encoder KY-040

Medir distancia con el HC SR04 y Arduino: tu primer sensor de proximidad

Controla un LCD 16x2 con solo 2 cables usando el módulo I2C

Comentarios