¡Descubre cómo registrar la temperatura con ESP32 en una tarjeta MicroSD!

¿Estás buscando una manera efectiva de registrar la temperatura con tu ESP32? En este artículo te mostraremos cómo utilizar tu microcontrolador ESP32 para almacenar datos de temperatura en una tarjeta MicroSD. Sigue leyendo para descubrir cómo llevar a cabo este proceso de manera sencilla y eficiente.

Este proyecto muestra cómo usar el ESP32 para registrar datos con marcas de tiempo en una tarjeta microSD. Como ejemplo, registramos los valores de temperatura del sensor DS18B20 cada 10 minutos. El ESP32 está en modo de suspensión profunda entre cada lectura y solicita la fecha y la hora a través del Protocolo de tiempo de red (NTP).

Temperatura de registro de datos ESP32 a la tarjeta MicroSD

También te puede interesar: ESP32: Cómo registrar datos (10 formas diferentes)

Contenido

Descripción del proyecto

Antes de comenzar, resaltemos las principales características del proyecto:

El ESP32 lee la temperatura utilizando el sensor de temperatura DS18B20.
Después de detectar la temperatura, envía una solicitud a un servidor de protocolo de tiempo de red (NTP) para recuperar la fecha y la hora. Entonces el ESP32 requiere una conexión Wi-Fi.
Los datos (temperatura y marca de tiempo) se registran en una tarjeta microSD. Para registrar datos en la tarjeta microSD, utilizamos un módulo de tarjeta microSD.
Luego de completar estas tareas anteriores, el ESP32 dormirá durante 10 minutos.
El ESP32 se despierta y repite el proceso.

Piezas requeridas

Aquí hay una lista de las piezas necesarias para construir este proyecto (haga clic en los enlaces a continuación para encontrar el mejor precio en Asesor de creadores):

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

Preparando el módulo de la tarjeta microSD

Para guardar datos en la tarjeta microSD con el ESP32, utilizamos lo siguiente módulo de tarjeta microSD que se comunica con el ESP32 a través del protocolo de comunicación SPI.

Contenido relacionado: ESP32: Instrucciones del módulo de tarjeta MicroSD con Arduino IDE

Formatear la tarjeta microSD

Si está utilizando una tarjeta microSD con el ESP32, primero debe formatearla. Siga las siguientes instrucciones para formatear su tarjeta microSD.

1. Inserta la tarjeta microSD en tu computadora. Ir a Mi computadora y haga clic derecho en la tarjeta SD. Elegir formato como se muestra en la siguiente figura.

2. Una nueva ventana se abrirá. Elegir FAT32Prensa comenzar para inicializar el proceso de formateo y siga las instrucciones que aparecen en pantalla.

Esquema

Siga el siguiente esquema para ensamblar el circuito para este proyecto.

También puede utilizar la siguiente tabla como referencia para el cableado del módulo de tarjeta microSD:

módulo de tarjeta microSD	ESP32
3 contra 3	3 contra 3
ÉL	GPIO5
MOSI	GPIO23
CLK	GPIO 18
MISO	GPIO 19
Dimensiones	Dimensiones

La siguiente imagen muestra cómo debería verse su circuito:

Preparando el IDE de Arduino

Existe un complemento para Arduino IDE que le permite programar el ESP32 usando el Arduino IDE y su lenguaje de programación. Siga el siguiente tutorial para preparar su IDE de Arduino para que funcione con ESP32 si aún no lo ha hecho.

Instalación de la placa ESP32 en Arduino IDE 2 (Windows, Mac OS X, Linux)

Instalación de bibliotecas

Antes de cargar el código, debe instalar algunas bibliotecas en el IDE de Arduino. El Biblioteca OneWire de Paul Stoffregen y eso Biblioteca de temperatura de Dallas para que puedas utilizar el sensor DS18B20. Usted también debe Biblioteca NTPClient bifurcada por Taranais para realizar una solicitud a un servidor NTP.

Siga los siguientes pasos para instalar estas bibliotecas en su IDE de Arduino:

Biblioteca OneWire

En el IDE de Arduino, vaya a Bosquejo > incluir biblioteca > Administrar bibliotecas.
Buscar Un cable.
Instale la biblioteca OneWire como se muestra en la imagen a continuación.

Biblioteca de temperatura de Dallas

En el IDE de Arduino, vaya a Bosquejo > incluir biblioteca > Administrar bibliotecas.
Buscar Dallastemperatura.
Instalar eso Dallastemperatura Biblioteca Miles Burton.

Biblioteca NTPClient

IMPORTANTE: No utilizamos la biblioteca NTPClient estándar. Para seguir este tutorial necesitas instalar la biblioteca. Recomendamos los siguientes pasos.

Usamos esos Biblioteca NTPClient bifurcada por TaranaisSiga los siguientes pasos para instalar esta biblioteca en su IDE de Arduino:

Haga clic aquí para descargar la biblioteca del cliente NTP. Deberías tener una carpeta .zip en tu Descargas
Vaya a su IDE de Arduino Bosquejo > incluir biblioteca > Agregar biblioteca ZIP…
Seleccione el archivo ZIP de la biblioteca que acaba de descargar.
La biblioteca se instalará después de unos segundos.

Subir código

Aquí está el código que necesita cargar en su ESP32. Antes de cargar, debe cambiar el código para incluir sus credenciales de red (SSID y contraseña). Continúe leyendo para saber cómo funciona el código.

/*********
  Rui Santos
  Complete project details at https://randomnerdtutorials.com  
*********/

// Libraries for SD card
#include "FS.h"
#include "SD.h"
#include <SPI.h>

//DS18B20 libraries
#include <OneWire.h>
#include <DallasTemperature.h>

// Libraries to get time from NTP Server
#include <WiFi.h>
#include <NTPClient.h>
#include <WiFiUdp.h>

// Define deep sleep options
uint64_t uS_TO_S_FACTOR = 1000000;  // Conversion factor for micro seconds to seconds
// Sleep for 10 minutes = 600 seconds
uint64_t TIME_TO_SLEEP = 600;

// Replace with your network credentials
const char* ssid     = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Define CS pin for the SD card module
#define SD_CS 5

// Save reading number on RTC memory
RTC_DATA_ATTR int readingID = 0;

String dataMessage;

// Data wire is connected to ESP32 GPIO 21
#define ONE_WIRE_BUS 21
// Setup a oneWire instance to communicate with a OneWire device
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);

// Temperature Sensor variables
float temperature;

// Define NTP Client to get time
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP);

// Variables to save date and time
String formattedDate;
String dayStamp;
String timeStamp;

void setup() {
  // Start serial communication for debugging purposes
  Serial.begin(115200);

  // Connect to Wi-Fi network with SSID and password
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected.");

  // Initialize a NTPClient to get time
  timeClient.begin();
  // Set offset time in seconds to adjust for your timezone, for example:
  // GMT +1 = 3600
  // GMT +8 = 28800
  // GMT -1 = -3600
  // GMT 0 = 0
  timeClient.setTimeOffset(3600);

  // Initialize SD card
  SD.begin(SD_CS);  
  if(!SD.begin(SD_CS)) {
    Serial.println("Card Mount Failed");
    return;
  }
  uint8_t cardType = SD.cardType();
  if(cardType == CARD_NONE) {
    Serial.println("No SD card attached");
    return;
  }
  Serial.println("Initializing SD card...");
  if (!SD.begin(SD_CS)) {
    Serial.println("ERROR - SD card initialization failed!");
    return;    // init failed
  }

  // If the data.txt file doesn't exist
  // Create a file on the SD card and write the data labels
  File file = SD.open("/data.txt");
  if(!file) {
    Serial.println("File doens't exist");
    Serial.println("Creating file...");
    writeFile(SD, "/data.txt", "Reading ID, Date, Hour, Temperature rn");
  }
  else {
    Serial.println("File already exists");  
  }
  file.close();

  // Enable Timer wake_up
  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);

  // Start the DallasTemperature library
  sensors.begin(); 

  getReadings();
  getTimeStamp();
  logSDCard();
  
  // Increment readingID on every new reading
  readingID++;
  
  // Start deep sleep
  Serial.println("DONE! Going to sleep now.");
  esp_deep_sleep_start(); 
}

void loop() {
  // The ESP32 will be in deep sleep
  // it never reaches the loop()
}

// Function to get temperature
void getReadings(){
  sensors.requestTemperatures(); 
  temperature = sensors.getTempCByIndex(0); // Temperature in Celsius
  //temperature = sensors.getTempFByIndex(0); // Temperature in Fahrenheit
  Serial.print("Temperature: ");
  Serial.println(temperature);
}

// Function to get date and time from NTPClient
void getTimeStamp() {
  while(!timeClient.update()) {
    timeClient.forceUpdate();
  }
  // The formattedDate comes with the following format:
  // 2018-05-28T16:00:13Z
  // We need to extract date and time
  formattedDate = timeClient.getFormattedDate();
  Serial.println(formattedDate);

  // Extract date
  int splitT = formattedDate.indexOf("T");
  dayStamp = formattedDate.substring(0, splitT);
  Serial.println(dayStamp);
  // Extract time
  timeStamp = formattedDate.substring(splitT+1, formattedDate.length()-1);
  Serial.println(timeStamp);
}

// Write the sensor readings on the SD card
void logSDCard() {
  dataMessage = String(readingID) + "," + String(dayStamp) + "," + String(timeStamp) + "," + 
                String(temperature) + "rn";
  Serial.print("Save data: ");
  Serial.println(dataMessage);
  appendFile(SD, "/data.txt", dataMessage.c_str());
}

// Write to the SD card (DON'T MODIFY THIS FUNCTION)
void writeFile(fs::FS &fs, const char * path, const char * message) {
  Serial.printf("Writing file: %sn", 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();
}

// Append data to the SD card (DON'T MODIFY THIS FUNCTION)
void appendFile(fs::FS &fs, const char * path, const char * message) {
  Serial.printf("Appending to file: %sn", 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();
}

Ver código sin formato

Cómo funciona el código

En este ejemplo, el ESP32 está en modo de suspensión profunda entre cada lectura. En modo de suspensión profunda, todo su código debe ir al configuración() Función, ya que el ESP32 nunca Cinta().

Importando bibliotecas

Primero importe las bibliotecas necesarias para el módulo de la tarjeta microSD:

#include "FS.h"
#include "SD.h"
#include <SPI.h>

Importe estas bibliotecas para trabajar con el sensor de temperatura DS18B20.

#include <OneWire.h>
#include <DallasTemperature.h>

Puede utilizar las siguientes bibliotecas para solicitar la fecha y la hora de un servidor NTP.

#include <WiFi.h>
#include <NTPClient.h>
#include <WiFiUdp.h>

Establecer tiempo de sueño profundo

Este ejemplo utiliza un factor de conversión de microsegundos a segundos, por lo que puedes calcular el tiempo de descanso en el HORA DE DORMIR variable en segundos.

En este caso, configuramos el ESP32 para que entre en modo de suspensión durante 10 minutos (600 segundos). Si desea que el ESP32 entre en modo de suspensión por un período de tiempo diferente, solo necesita ingresar la cantidad de segundos para la suspensión profunda en el campo. HORA DE DORMIR Variable.

// Define deep sleep options
uint64_t uS_TO_S_FACTOR = 1000000; // Conversion factor for micro seconds to seconds
// Sleep for 10 minutes = 600 seconds
uint64_t TIME_TO_SLEEP = 600;

Configuración de sus credenciales de red

Ingrese sus credenciales de red en las siguientes variables para permitir que ESP32 se conecte a su red local.

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Inicialización de sensores y variables

A continuación, defina el pin SD de la tarjeta microSD. En este caso se establece en GPIO5.

#define SD_CS 5

Crea una variable llamada Leer identificación para guardar el ID de medición. De esta manera puedes organizar tus métricas. Para almacenar un valor variable durante el sueño profundo, podemos almacenarlo en la memoria RTC. Para guardar datos en el almacenamiento RTC, solo necesita agregar RTC_DATA_ATTR antes de la definición de la variable.

// Save reading number on RTC memory
RTC_DATA_ATTR int readingID = 0;

Cree una variable de cadena para contener los datos que se almacenarán en la tarjeta microSD.

String dataMessage;

A continuación, cree las instancias necesarias para el sensor de temperatura. El sensor de temperatura está conectado a GPIO21.

// Data wire is connected to ESP32 GPIO21
#define ONE_WIRE_BUS 21
// Setup a oneWire instance to communicate with a OneWire device
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);

Luego cree una variable flotante para almacenar la temperatura recuperada del sensor DS18B20.

float temperature;

Las dos líneas siguientes definen un cliente NTP para solicitar la fecha y hora de un servidor NTP.

WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP);

Luego inicialice las variables de cadena para almacenar la fecha y la hora.

String formattedDate;
String dayStamp;
String timeStamp;

configuración()

Si está utilizando Deep Sleep con el ESP32, todo el código debe estar en el configuración() Función, ya que el ESP32 nunca Cinta().

Conéctate a Wi-Fi

El siguiente fragmento de código se conecta a la red WiFi. Debe conectarse a WiFi para solicitar la fecha y hora del servidor NTP.

Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print(".");
}

Inicializando el cliente NTP

A continuación, inicialice el cliente NTP para recuperar la fecha y la hora de un servidor NTP.

timeClient.begin();

Puedes utilizar el… setTimeOffset() Método para ajustar la hora a tu zona horaria.

timeClient.setTimeOffset(3600);

Aquí hay algunos ejemplos para diferentes zonas horarias:

GMT +1 = 3600
GMT +8 = 28800
GMT -1 = -3600
GMT 0 = 0

Inicializando el módulo de la tarjeta microSD

A continuación, inicialice la tarjeta microSD. Si Instrucciones Compruebe que la tarjeta microSD esté insertada correctamente.

SD.begin(SD_CS); 
if(!SD.begin(SD_CS)) {
  Serial.println("Card Mount Failed");
  return;
}
uint8_t cardType = SD.cardType();
if(cardType == CARD_NONE) {
  Serial.println("No SD card attached");
  return;
}
Serial.println("Initializing SD card...");
if (!SD.begin(SD_CS)) {
  Serial.println("ERROR - SD card initialization failed!");
  return; // init failed
}

Entonces prueba esto datos.txt Archivo en la tarjeta microSD.

File file = SD.open("/data.txt");

Si este archivo no existe, debemos crearlo y el encabezado del .TXT Archivo.

writeFile(SD, "/data.txt", "Reading ID, Date, Hour, Temperature rn");

Si el archivo ya existe, el código continúa.

else {
  Serial.println("File already exists");
}

Finalmente cerramos el archivo.

file.close();

Habilitar activación del temporizador

Luego active el temporizador para despertarse con el temporizador que configuró previamente en el HORA DE DORMIR Variable.

esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);

Inicializando la biblioteca para DS18B20

A continuación, inicialice la biblioteca para el sensor de temperatura DS18B20.

sensors.begin();

Obtención de las mediciones y registro de los datos.

Una vez inicializado todo, podemos obtener las lecturas, la marca de tiempo y registrar todo en la tarjeta microSD.

Para que el código sea más fácil de entender, creamos las siguientes funciones:

obtener lecturas(): lee la temperatura del sensor de temperatura DS18B20;
obtener marca de hora(): recupera la fecha y la hora del servidor NTP;
registrotarjetaSD(): registra los datos anteriores en la tarjeta microSD.

Después de completar estas tareas, aumentamos la Leer identificación.

readingID++;

Finalmente, el ESP32 entra en sueño profundo.

esp_deep_sleep_start();

obtener lecturas()

Echemos un vistazo a esos obtener lecturas() Función. Esta función simplemente lee la temperatura del sensor de temperatura DS18B20.

sensors.requestTemperatures(); 
temperature = sensors.getTempCByIndex(0); // Temperature in Celsius

De forma predeterminada, el código recupera la temperatura en grados Celsius. Puede descomentar la siguiente línea y descomentar la anterior para obtener la temperatura en Fahrenheit.

//temperature = sensors.getTempFByIndex(0); // Temperature in Fahrenheit

obtener marca de hora()

El obtener marca de hora() La función recupera la fecha y la hora. Las siguientes líneas garantizan que obtengamos una fecha y hora válidas:

while(!timeClient.update()) {
  timeClient.forceUpdate();
}

A veces, NTPClient recupera el año 1970. Para asegurarnos de que esto no suceda, forzamos la actualización.

Luego convierta la fecha y la hora a un formato legible usando el obtener fecha formateada() Método:

formattedDate = timeClient.getFormattedDate();

La fecha y la hora se devuelven en este formato:

2018-04-30T16:00:13Z

Entonces necesitamos dividir la cadena para obtener la fecha y la hora por separado. Y eso es lo que hacemos aquí:

// Extract date
int splitT = formattedDate.indexOf("T");
dayStamp = formattedDate.substring(0, splitT);
Serial.println(dayStamp);
// Extract time
timeStamp = formattedDate.substring(splitT+1, formattedDate.length()-1);
Serial.println(timeStamp);

La fecha se guarda en el Sello del día variable y el tiempo en el marca de tiempo Variable.

registroTarjetaSD()

El registroTarjetaSD() La función vincula toda la información en el mensaje de datos Variable de cadena. Los valores individuales están separados por comas.

dataMessage = String(readingID) + "," + String(dayStamp) + "," + String(timeStamp) + "," + String(temperature) + "rn";

Nota: El «rn» Al final de mensaje de datosLa variable garantiza que la siguiente medición se escriba en la siguiente línea.

Luego escribimos toda la información en el usando la siguiente línea datos.txt Archivo en la tarjeta microSD.

appendFile(SD, "/data.txt", dataMessage.c_str());

Nota: El Adjuntar un archivo() La función solo acepta variables de tipo const char para el mensaje. Entonces usa eso cadena_c() Método para convertir el mensaje de datos Variable.

escribirFile() y appendFile()

Las dos últimas funciones: escribir archivo() Y Adjuntar un archivo() se utilizan para escribir y adjuntar datos a la tarjeta microSD. Se incluyen con los ejemplos de la biblioteca de tarjetas SD y no deben modificarse.

Puede encontrar más ejemplos de cómo trabajar con la tarjeta microSD en archivo > Ejemplos > SD (esp32).

Sube el código

Ahora sube el código a tu ESP32. Asegúrese de haber seleccionado la placa y el puerto COM correctos.

demostración

Abra el monitor serie con una velocidad de baudios de 115200.

Presione el botón “Activar ESP32” y verifique que todo esté funcionando correctamente (el ESP32 está conectado a su red local y la tarjeta microSD está insertada correctamente).

Nota: Si todo está conectado correctamente y aún recibe un mensaje de error al inicializar la tarjeta SD, suministrar 5 V al módulo de su tarjeta microSD puede resolver el problema.

Deje que el ESP32 funcione durante unas horas para probar si todo funciona como se esperaba. Después del período de prueba, retira la tarjeta microSD e insértala en tu computadora. La tarjeta microSD debe tener un archivo llamado datos.txt.

Por ejemplo, puede copiar el contenido del archivo a una hoja de cálculo en Google Sheets y luego dividir los datos mediante comas. Para dividir datos por comas, seleccione la columna donde tiene sus datos y luego vaya a Datos > Dividir el texto en columnas… Luego puede crear gráficos para el análisis de datos.

Envolver

En este tutorial aprendiste cómo registrar datos en una tarjeta microSD usando el ESP32. También le mostramos cómo leer la temperatura del sensor de temperatura DS18B20 y solicitar la hora desde un servidor NTP.

Puede aplicar los conceptos de este tutorial a sus propios proyectos. Usted también puede estar interesado en:

Quizás también te interesen los otros artículos sobre ESP32:

ESP32: Instrucciones para módulo de tarjeta MicroSD con Arduino IDE
Registrador de datos de altímetro: ESP32 con BMP388, almacenamiento en tarjeta MicroSD y pantalla OLED
Registrador de datos ESP32: descargue el archivo de datos a través del servidor web (Arduino IDE)
ESP32: Cómo registrar datos (10 formas diferentes)
Registro de datos ESP32 en Google Sheets (usando la cuenta de servicio de Google)

Obtenga más información sobre el ESP32 con nuestros recursos:

Aprenda ESP32 con Arduino IDE (libro electrónico)
HOGAR INTELIGENTE con Raspberry Pi, ESP32, ESP8266
Construya servidores web con ESP32 y ESP8266 (libro electrónico)
Aplicación web Firebase con ESP32 y ESP8266
Proyectos y tutoriales ESP32 gratuitos…

Gracias por leer.

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded

Temperatura de registro de datos ESP32 a la tarjeta MicroSD

Este proyecto muestra cómo registrar datos con marcas de tiempo en una tarjeta microSD utilizando el ESP32. Como ejemplo, registraremos lecturas de temperatura del sensor DS18B20 cada 10 minutos. El ESP32 estará en modo de suspensión profunda entre cada lectura, y solicitará la fecha y hora utilizando el Protocolo de Tiempo de Red (NTP).

Visión general del proyecto

Antes de comenzar, resaltemos las características principales del proyecto:

El ESP32 lee la temperatura utilizando el sensor de temperatura DS18B20.
Después de obtener la temperatura, realiza una solicitud a un servidor NTP (Protocolo de Tiempo de Red) para obtener la fecha y hora. Por lo tanto, el ESP32 necesita una conexión Wi-Fi.
Los datos (temperatura y marca de tiempo) se registran en una tarjeta microSD. Para registrar datos en la tarjeta microSD estamos usando un módulo de tarjeta microSD.
Después de completar estas tareas previas, el ESP32 duerme durante 10 minutos.
El ESP32 se despierta y repite el proceso.

Partes requeridas

Aquí hay una lista de las partes necesarias para construir este proyecto:

Placa ESP32 DOIT DEVKIT V1 – revisión y comparación de placas de desarrollo ESP32
Módulo de tarjeta microSD
Tarjeta microSD
Sensor de temperatura DS18B20
Resistor de 10k Ohm
Cables de puente
Protoboard

Puede usar los siguientes enlaces o ir directamente a MakerAdvisor.com/tools para encontrar todas las piezas para sus proyectos al mejor precio.

Preparación del módulo de tarjeta microSD

Para guardar datos en la tarjeta microSD con el ESP32, utilizamos el siguiente módulo de tarjeta microSD que se comunica con el ESP32 utilizando el protocolo de comunicación SPI.

Artículo relacionado: Guía para el módulo de tarjeta microSD utilizando Arduino IDE

Formateo de la tarjeta microSD

Cuando se utiliza una tarjeta microSD con el ESP32, debe formatearla primero. Siga las siguientes instrucciones para formatear su tarjeta microSD.

Inserte la tarjeta microSD en su computadora. Vaya a Mi PC y haga clic derecho en la tarjeta SD. Seleccione Formatear como se muestra en la figura a continuación.
Se abre una nueva ventana. Seleccione FAT32, presione Iniciar para inicializar el proceso de formateo y siga las instrucciones en pantalla.

Esquemático

Siga el siguiente diagrama esquemático para ensamblar el circuito para este proyecto.

También puede utilizar la siguiente tabla como referencia para cablear el módulo de tarjeta microSD:

Módulo de tarjeta MicroSD	ESP32
3V3	3V3
CS	GPIO 5
MOSI	GPIO 23
CLK	GPIO 18
MISO	GPIO 19
GND	GND

La siguiente figura muestra cómo debería verse su circuito:

Preparando el Arduino IDE

Hay un complemento para el Arduino IDE que le permite programar el ESP32 utilizando el Arduino IDE y su lenguaje de programación. Siga el siguiente tutorial para preparar su Arduino IDE para trabajar con el ESP32, si aún no lo ha hecho.

Instalando el nodo ESP32 en Arduino IDE 2 (Windows, Mac OS X, Linux)

Instalando bibliotecas

Antes de cargar el código, debe instalar algunas bibliotecas en el Arduino IDE. La biblioteca OneWire de Paul Stoffregen y la biblioteca de Temperatura Dallas para que pueda utilizar el sensor DS18B20. También debe instalar la biblioteca NTPClient bifurcada por Taranais para realizar solicitudes a un servidor NTP.

Siga los siguientes pasos para instalar esas bibliotecas en su Arduino IDE:

Biblioteca OneWire

En el IDE de Arduino, vaya a Sketch > Incluir Biblioteca > Gestionar Bibliotecas.
Busque OneWire.
Instale la biblioteca OneWire como se muestra en la imagen a continuación.

Biblioteca de Temperatura Dallas

En el IDE de Arduino, vaya a Sketch > Incluir Biblioteca > Gestionar Bibliotecas.
Busque DallasTemperature.
Instale la biblioteca DallasTemperature de Miles Burton.

Biblioteca NTPClient

IMPORTANTE: no estamos utilizando la biblioteca NTPClient predeterminada. Para seguir este tutorial, debe instalar la biblioteca que recomendamos siguiendo los siguientes pasos.

Utilizaremos la biblioteca NTPClient bifurcada por Taranais. Siga los siguientes pasos para instalar esta biblioteca en su Arduino IDE:

Haga clic aquí para descargar la biblioteca NTP Client. Debería tener una carpeta .zip en su Descargas.
En su Arduino IDE, vaya a Sketch > Incluir Biblioteca > Añadir biblioteca .ZIP…
Seleccione el archivo .ZIP de la biblioteca que acaba de descargar.
La biblioteca se instalará después de unos segundos.

Subir código

Aquí está el código que necesita cargar en su ESP32. Antes de cargar, debe modificar el código para incluir sus credenciales de red (SSID y contraseña).

Código fuente

A continuación se muestra cómo funciona el código:

En este ejemplo, el ESP32 está en modo de suspensión profunda entre cada lectura. En el modo de suspensión profunda, todo su código debe estar en la función setup(), ya que el ESP32 nunca llega al bucle().

Importando bibliotecas

Primero, importa las bibliotecas necesarias para el módulo de tarjeta microSD:

#include "FS.h" #include "SD.h" #include <SPI.h>

Importa estas bibliotecas para trabajar con el sensor de temperatura DS18B20:

#include <OneWire.h> #include <DallasTemperature.h>

Las siguientes bibliotecas le permiten solicitar la fecha y hora de un servidor NTP:

#include <WiFi.h> #include <NTPClient.h> #include <WiFiUdp.h>

Estableciendo tiempo de suspensión profunda

Este ejemplo utiliza un factor de conversión de microsegundos a segundos, para que pueda configurar el tiempo de suspensión en la variable TIME_TO_SLEEP en segundos.

En este caso, estamos configurando el ESP32 para que se duerma durante 10 minutos (600 segundos). Si desea que el ESP32 duerma durante un período diferente de tiempo, solo necesita ingresar el número de segundos para la suspensión profunda en la variable TIME_TO_SLEEP.

// Define opciones de suspensión profunda uint64_t uS_TO_S_FACTOR = 1000000; // Factor de conversión para microsegundos a segundos // Dormir durante 10 minutos = 600 segundos uint64_t TIME_TO_SLEEP = 600;

Configurando sus credenciales de red

Escriba sus credenciales de red en las siguientes variables, para que el ESP32 pueda conectarse a su red local.

// Reemplace con sus credenciales de red const char* ssid = "REEMPLAZAR_CON_SU_SSID"; const char* password = "REEMPLAZAR_CON_SU_CONTRASEÑA";

Inicialización de sensores y variables

A continuación, defina el pin CS de la tarjeta SD. En este caso, se establece en GPIO 5.

#define SD_CS 5

Cree una variable llamada readingID para contener la identificación de la lectura. Esta es una forma de organizar sus lecturas. Para guardar un valor de variable durante la suspensión profunda, podemos guardarlo en la memoria RTC. Para guardar datos en la memoria RTC, solo necesita agregar RTC_DATA_ATTR antes de la definición de la variable.

// Guardar número de lectura en la memoria RTC RTC_DATA_ATTR int readingID = 0;

Cree una variable de cadena para contener los datos que se guardarán en la tarjeta microSD.

String dataMessage;

A continuación, cree las instancias necesarias para el sensor de temperatura. El sensor de temperatura está conectado al GPIO 21.

// El cable de datos está conectado a GPIO 21 del ESP32 #define ONE_WIRE_BUS 21 // Configurar una instancia de OneWire para comunicarse con un dispositivo OneWire OneWire oneWire(ONE_WIRE_BUS); // Pasar nuestra referencia oneWire al sensor de temperatura Dallas DallasTemperature sensors(&oneWire);

Luego, cree una variable float para contener la temperatura recuperada por el sensor DS18B20.

float temperature;

Las siguientes dos líneas definen un NTPClient para solicitar la fecha y la hora de un servidor NTP.

WiFiUDP ntpUDP; NTPClient timeClient(ntpUDP);

Luego, inicialice las variables String para guardar la fecha y la hora.

String formattedDate; String dayStamp; String timeStamp;

Función de inicio()

Cuando use la suspensión profunda con el ESP32, todo el código debe ir dentro de la función de inicio(), porque el ESP32 nunca llega al bucle().

Conectando a la red Wi-Fi

El siguiente fragmento de código se conecta a la red Wi-Fi. Debes conectarte a Wi-Fi para solicitar la fecha y la hora al servidor NTP.

Serial.print("Conectando a "); Serial.println(ssid); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); }

Inicializando el cliente NTP

Luego, inicialice el cliente NTP para obtener la fecha y la hora de un servidor NTP.

timeClient.begin();

Puede usar el método setTimeOffset(<tiempo>) para ajustar la hora para su zona horaria.

timeClient.setTimeOffset(3600);

Aquí hay algunos ejemplos para diferentes zonas horarias:

GMT +1 = 3600
GMT +8 = 28800
GMT -1 = -3600
GMT 0 = 0

Inicializando el módulo de tarjeta microSD

Luego, inicialice la tarjeta microSD. Las siguientes declaraciones if verifican si la tarjeta microSD está correctamente conectada.

SD.begin(SD_CS); if(!SD.begin(SD_CS)) { Serial.println("Error al montar la tarjeta"); return; } uint8_t cardType = SD.cardType(); if(cardType == CARD_NONE) { Serial.println("No se detecta una tarjeta SD"); return; } Serial.println("Inicializando la tarjeta SD..."); if (!SD.begin(SD_CS)) { Serial.println("ERROR - ¡Falló la inicialización de la tarjeta SD!"); return; // fallo de inicialización }

Luego, intente abrir el archivo data.txt en la tarjeta microSD.

File file = SD.open("/data.txt");

Si ese archivo no existe, necesitamos crearlo y escribir el encabezado para el archivo .txt.

writeFile(SD, "/data.txt", "ID de lectura, Fecha, Hora, Temperatura rn");

Si el archivo ya existe, el código continúa.

else { Serial.println("El Archivo ya existe"); }

Finalmente, cerramos el archivo.

file.close();

Habilitar el temporizador de despertar

Después, habilitamos el temporizador de despertar con el temporizador que ha definido anteriormente en la variable TIME_TO_SLEEP.

esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);

Inicializando la biblioteca para DS18B20

A continuación, inicializa la biblioteca para el sensor de temperatura DS18B20.

sensors.begin();

Obteniendo los valores y registrando los datos

Después de tener todo inicializado, podemos obtener los valores, la marca de tiempo y registrar todo en la tarjeta microSD.

Para que el código sea más fácil de entender, hemos creado las siguientes funciones:

getReadings(): lee la temperatura del sensor de temperatura DS18B20;
getTimeStamp(): obtiene la fecha y hora del servidor NTP;
logSDcard(): registra los datos anteriores en la tarjeta microSD.

Después de completar estas tareas, incrementamos el readingID.

readingID++;

Finalmente, el ESP32 inicia la suspensión profunda.

esp_deep_sleep_start();

getReadings()

Veamos la función getReadings(). Esta función simplemente lee la temperatura del sensor DS18B20.

sensors.requestTemperatures(); temperature = sensors.getTempCByIndex(0); // Temperatura en grados Celsius

De forma predeterminada, el código recupera la temperatura en grados Celsius. Puede descomentar la siguiente línea y comentar la anterior para obtener la temperatura en grados Fahrenheit.

//temperature = sensors.getTempFByIndex(0); // Temperatura en Fahrenheit

getTimeStamp()

La función getTimeStamp() obtiene la fecha y hora. Estas líneas aseguran que obtengamos una fecha y hora válidas:

while(!timeClient.update()) { timeClient.forceUpdate(); }

A veces, el NTPClient recupera el año de 1970. Para asegurarnos de que eso no suceda, forzamos la actualización:

formattedDate = timeClient.getFormattedDate();

La fecha y hora se devuelven en este formato:

2018-04-30T16:00:13Z

Entonces, dividimos esa cadena para obtener la fecha y la hora por separado. Eso es lo que hacemos aquí:

// Extraer fecha int splitT = formattedDate.indexOf("T"); dayStamp = formattedDate.substring(0, splitT); Serial.println(dayStamp); // Extraer hora timeStamp = formattedDate.substring(splitT+1, formattedDate.length()-1); Serial.println(timeStamp);

La fecha se guarda en la variable dayStamp y la hora en la variable timeStamp.

logSDCard()

La función logSDCard() concatena toda la información en la variable String dataMessage. Cada lectura está separada por comas.

dataMessage = String(readingID) + "," + String(dayStamp) + "," + String(timeStamp) + "," + String(temperature) + "rn";

Nota: el «rn» al final de la variable dataMessage asegura que la próxima lectura se escriba en la siguiente línea.

Luego, con la siguiente línea, escribimos toda la información en el archivo data.txt en la tarjeta microSD.

appendFile(SD, "/data.txt", dataMessage.c_str());

Nota: la

2 comentarios en «Temperatura de registro de datos ESP32 a la tarjeta MicroSD»

alina20042pu

6 de marzo de 2023 a las 00:38

¡Interesante forma de almacenar datos con el ESP32! ¡Voy a probarlo en mi proyecto! 🤓

javier_75: ¡Qué buen artículo! Siempre es útil aprender nuevas formas de registrar datos con la ESP32. ¡Gracias por compartir! 😊
Accede para responder
melenahikuxy

11 de julio de 2023 a las 22:39

¡Me encanta la idea de poder guardar los datos de temperatura en una tarjeta MicroSD con el ESP32! ¡Definitivamente lo probaré en mi próximo proyecto! 🌡️📂
Accede para responder

Deja un comentario Cancelar la respuesta

Lo siento, debes estar conectado para publicar un comentario.

Descripción del proyecto

Piezas requeridas

Preparando el módulo de la tarjeta microSD

Formatear la tarjeta microSD

Esquema

Preparando el IDE de Arduino

Instalación de bibliotecas

Subir código

Cómo funciona el código

Importando bibliotecas

Establecer tiempo de sueño profundo

Configuración de sus credenciales de red

Inicialización de sensores y variables

configuración()

Conéctate a Wi-Fi

Inicializando el cliente NTP

Inicializando el módulo de la tarjeta microSD

Habilitar activación del temporizador

Inicializando la biblioteca para DS18B20

Obtención de las mediciones y registro de los datos.

obtener lecturas()

obtener marca de hora()

registroTarjetaSD()

escribirFile() y appendFile()

Sube el código

demostración

Envolver

Temperatura de registro de datos ESP32 a la tarjeta MicroSD

Visión general del proyecto

Partes requeridas

Preparación del módulo de tarjeta microSD

Formateo de la tarjeta microSD

Esquemático

Preparando el Arduino IDE

Instalando bibliotecas

Subir código

Related Posts:

2 comentarios en «Temperatura de registro de datos ESP32 a la tarjeta MicroSD»

Deja un comentario Cancelar la respuesta