ESP32 Google Sheets: guardar datos de sensores por WiFi
Tutorial ESP32 Google Sheets: aplicación web de Apps Script, filas con doPost, petición HTTPS, marca de tiempo, DHT22 + LDR, gráficos, cuotas y token secreto.
Conectar el ESP32 con Google Sheets es la forma más sencilla de reunir datos de sensores en una hoja de cálculo gratuita y accesible desde cualquier lugar, sin montar tu propio servidor. Cada minuto el ESP32 lee la temperatura, la humedad y la luz, las envía a Google por WiFi y aparece una nueva fila en Google Sheets. Al abrir la hoja en el móvil ves la última lectura, su marca de tiempo y un gráfico que se actualiza solo. El puente que lo hace posible es una pequeña aplicación web escrita con Apps Script, el servicio gratuito de Google.
En esta guía prepararás la hoja, escribirás el código de Apps Script que comprueba los datos recibidos y añade una fila, lo publicarás como aplicación web y enviarás datos desde el ESP32 por HTTPS. Después veremos la marca de tiempo, varios sensores y dispositivos, cómo dibujar un gráfico, los límites de cuota de Google, los códigos de error y cómo mantener en secreto la URL de la aplicación web. Al final encontrarás una comparación con alternativas como ThingSpeak. Si estás empezando con el ESP32, echa antes un vistazo a ¿Qué es el ESP32?; también puedes ver cómo hace peticiones HTTP en el ejemplo de la API del tiempo.

¿Cómo escribe el ESP32 datos en Google Sheets?
El ESP32 no puede escribir en la hoja directamente; la API de Sheets de Google exige autenticación OAuth, algo engorroso para un microcontrolador pequeño. En su lugar escribes un proyecto de Apps Script vinculado a la hoja y lo publicas como aplicación web. Google te da una dirección del tipo script.google.com/macros/s/.../exec. Cuando el ESP32 envía datos a esa dirección, el flujo es este:
- El ESP32 lee los sensores y convierte los valores en un texto JSON corto.
- El JSON se envía por HTTPS con una petición POST a la dirección /exec de la aplicación web.
- Google pasa la petición a la función doPost(e), que se ejecuta con tu cuenta; la función comprueba el token secreto y añade una fila con appendRow().
- Google no responde al momento, sino que devuelve una redirección 302; el ESP32 pide esa nueva dirección con GET y recibe la respuesta generada por tu función.
- Si el ESP32 ve "ok":true en la respuesta, da el trabajo por hecho; si no, espera un poco y lo vuelve a intentar.
Paso 1: Prepara el archivo de Google Sheets
- Crea una hoja de cálculo nueva en Google Drive y ponle un nombre como "Registro ESP32".
- Cambia el nombre de la pestaña inferior a Veri; debe coincidir exactamente con SHEET_NAME en el código, mayúsculas incluidas (o cambia ambos).
- Escribe los encabezados en la primera fila: Hora, Dispositivo, Temperatura, Humedad, Luz. Puedes fijar la fila con Ver > Inmovilizar.
- Selecciona las columnas sin usar de la F a la Z y elimínalas. En la sección de cuotas verás por qué importa.
- En Archivo > Configuración, ajusta la zona horaria a tu región; las marcas de tiempo se escriben en esa zona.
Paso 2: Escribe doPost y doGet en Apps Script
Con la hoja abierta, elige Extensiones > Apps Script; se abre un proyecto vinculado a la hoja. Borra todo lo que hay en Code.gs, pega el código siguiente y guarda. Luego abre la Configuración del proyecto desde el icono del engranaje a la izquierda, añade abajo en Propiedades de la secuencia de comandos una propiedad llamada TOKEN y dale un valor largo que nadie pueda adivinar. Guardar la clave en las propiedades y no en el código evita que se filtre cuando compartas el código.
1// Google Apps Script - ESP32 veri alıcı / ESP32 data receiver
2const SHEET_NAME = 'Veri'; // sayfa (sekme) adı / sheet (tab) name
3
4function doPost(e) {
5 try {
6 const data = JSON.parse(e.postData.contents); // ESP32'nin gönderdiği JSON / JSON sent by the ESP32
7 return addRow(data);
8 } catch (err) {
9 return reply({ ok: false, error: 'json: ' + err });
10 }
11}
12
13function doGet(e) {
14 // Tarayıcı testi / browser test: .../exec?token=...&device=test&temp=21.5&hum=40&light=1200
15 return addRow(e.parameter);
16}
17
18function addRow(data) {
19 const token = PropertiesService.getScriptProperties().getProperty('TOKEN');
20 if (!token || data.token !== token) {
21 return reply({ ok: false, error: 'yetkisiz / unauthorized' });
22 }
23 const lock = LockService.getScriptLock(); // aynı anda gelen istekleri sıraya koy / queue simultaneous requests
24 lock.waitLock(10000);
25 try {
26 const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(SHEET_NAME);
27 sheet.appendRow([
28 new Date(), // zaman damgası / timestamp
29 String(data.device || ''),
30 num(data.temp),
31 num(data.hum),
32 num(data.light)
33 ]);
34 return reply({ ok: true, row: sheet.getLastRow() });
35 } catch (err) {
36 return reply({ ok: false, error: String(err) });
37 } finally {
38 lock.releaseLock();
39 }
40}
41
42function num(v) {
43 const n = Number(v); // metni sayıya çevir / turn text into a number
44 return isFinite(n) ? n : '';
45}
46
47function reply(obj) {
48 return ContentService.createTextOutput(JSON.stringify(obj))
49 .setMimeType(ContentService.MimeType.JSON);
50}| Parte | Función |
|---|---|
| doPost(e) | Recibe la petición POST del ESP32; el cuerpo está en e.postData.contents |
| doGet(e) | Permite probar desde el navegador o con una petición GET simple; los valores están en e.parameter |
| PropertiesService | Guarda el TOKEN fuera del código, en la configuración del proyecto |
| LockService | Evita que las filas se pisen si dos dispositivos envían a la vez |
| appendRow([...]) | Añade una fila nueva bajo la última fila con datos |
| ContentService | Devuelve al ESP32 una pequeña respuesta JSON como {"ok":true} |
Paso 3: Implementa el script como aplicación web
- Pulsa Implementar > Nueva implementación arriba a la derecha y elige Aplicación web como tipo.
- En "Ejecutar como" elige Yo y en "Quién tiene acceso" elige Cualquier usuario; es obligatorio porque el ESP32 no puede iniciar sesión con una cuenta de Google.
- Pulsa Implementar; Google pide permiso para acceder a la hoja. Elige tu cuenta, entra al proyecto desde el enlace "Configuración avanzada" y concede el permiso.
- Copia la URL de la aplicación web que termina en /exec; la pegarás en la variable SCRIPT_URL del código del ESP32.
Paso 4: Conexión del DHT22 y la LDR

| Componente | Conexión | Pin del ESP32 |
|---|---|---|
| DHT22 | VCC | 3V3 |
| DHT22 | DATA (pull-up de 10 kΩ a 3V3 si el sensor va suelto) | GPIO 4 |
| DHT22 | GND | GND |
| LDR | Una pata a 3V3 y la otra a GPIO 34 | 3V3 / GPIO 34 |
| Resistencia de 10 kΩ | Entre GPIO 34 y GND | GPIO 34 / GND |
La LDR y la resistencia de 10 kΩ forman un divisor de tensión: cuanta más luz, menor es la resistencia de la LDR y mayor la tensión en GPIO 34. GPIO 34 está elegido a propósito; en el ESP32, los pines ADC2 (GPIO 0, 2, 4, 12-15, 25-27) no pueden hacer lecturas analógicas con el WiFi activo, así que conecta siempre los sensores analógicos a los pines ADC1, GPIO 32-39. El DHT22 es un sensor digital y funciona sin problema en GPIO 4. Para más detalles sobre la familia DHT, consulta la guía de DHT11 y DHT22.
Paso 5: Enviar la petición HTTPS desde el ESP32
En el Arduino IDE instala la librería DHT sensor library (Adafruit) desde el Gestor de librerías y acepta su dependencia Adafruit Unified Sensor si te lo pide. Las librerías WiFi, WiFiClientSecure y HTTPClient vienen con el paquete del ESP32. Sustituye los datos del WiFi, la URL de la aplicación web que copiaste y el valor de TOKEN por los tuyos, sube el sketch y abre el Monitor Serie a 115200 baudios.
1// ESP32 -> Google E-Tablolar veri kaydı / ESP32 -> Google Sheets data logger
2#include <WiFi.h>
3#include <WiFiClientSecure.h>
4#include <HTTPClient.h>
5#include <DHT.h> // "DHT sensor library" (Adafruit)
6
7const char* WIFI_SSID = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
8const char* WIFI_PASS = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
9const char* SCRIPT_URL = "https://script.google.com/macros/s/BURAYA_DAGITIM_ID/exec"; // web uygulaması / web app
10const char* TOKEN = "gizli-anahtar-123"; // Komut dosyası özelliğiyle aynı / same as the script property
11const char* DEVICE = "salon"; // cihaz adı / device name
12
13const int DHT_PIN = 4; // DHT22 veri / data
14const int LDR_PIN = 34; // LDR bölücü, ADC1 / LDR divider, ADC1
15const unsigned long INTERVAL_MS = 60000; // dakikada bir satır / one row per minute
16
17DHT dht(DHT_PIN, DHT22);
18unsigned long lastSend = 0;
19bool firstRun = true;
20
21void connectWiFi() {
22 if (WiFi.status() == WL_CONNECTED) return;
23 WiFi.mode(WIFI_STA);
24 WiFi.begin(WIFI_SSID, WIFI_PASS);
25 Serial.print("Wi-Fi");
26 for (int i = 0; i < 40 && WiFi.status() != WL_CONNECTED; i++) { // en fazla 20 sn / 20 s max
27 delay(500);
28 Serial.print(".");
29 }
30 Serial.println(WiFi.status() == WL_CONNECTED ? " OK" : " HATA / FAIL");
31}
32
33bool sendRow(float temp, float hum, int light) {
34 WiFiClientSecure client;
35 client.setInsecure(); // sertifika denetimi yok, yazıdaki nota bak / no cert check, see note
36 HTTPClient http;
37 http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS); // 302 yönlendirmesini GET ile izle / follow 302 with GET
38 http.setTimeout(15000); // Apps Script yavaş olabilir / Apps Script can be slow
39 if (!http.begin(client, SCRIPT_URL)) return false;
40 http.addHeader("Content-Type", "application/json");
41
42 char body[160];
43 snprintf(body, sizeof(body),
44 "{\"token\":\"%s\",\"device\":\"%s\",\"temp\":%.1f,\"hum\":%.1f,\"light\":%d}",
45 TOKEN, DEVICE, temp, hum, light);
46
47 int code = http.POST(body); // negatif = bağlantı hatası / negative = connection error
48 String reply = http.getString();
49 http.end();
50 Serial.printf("HTTP %d: %s\n", code, reply.c_str());
51 return code == 200 && reply.indexOf("\"ok\":true") >= 0;
52}
53
54void setup() {
55 Serial.begin(115200);
56 dht.begin();
57 connectWiFi();
58}
59
60void loop() {
61 if (!firstRun && millis() - lastSend < INTERVAL_MS) return;
62 firstRun = false;
63 lastSend = millis();
64
65 float t = dht.readTemperature(); // °C
66 float h = dht.readHumidity(); // %
67 int light = analogRead(LDR_PIN); // 0-4095
68 if (isnan(t) || isnan(h)) {
69 Serial.println("DHT22 okunamadı / read failed");
70 return;
71 }
72
73 connectWiFi();
74 for (int attempt = 1; attempt <= 3; attempt++) { // 3 deneme / 3 attempts
75 if (sendRow(t, h, light)) break;
76 delay(2000 * attempt); // giderek uzayan bekleme / growing back-off
77 }
78}- Sin setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS), el ESP32 se queda en la respuesta 302 de Google y nunca ve la respuesta real; la fila se añade igualmente, pero no puedes confirmar el éxito.
- client.setInsecure() cifra la conexión pero no verifica el certificado del servidor. Para un proyecto casero basta; si quieres más seguridad, añade el certificado raíz de Google con setCACert().
- setTimeout(15000) es importante; Apps Script a veces tarda 2-5 segundos en responder y el tiempo por defecto puede no bastar.
- Si el envío falla, el código lo reintenta tres veces esperando 2, 4 y 6 segundos; así se pierden menos datos cuando la red se corta un momento.
- La temporización usa millis(), así que el bucle nunca se bloquea; puedes añadir al mismo bucle la actualización de una pantalla o la lectura de pulsadores.
Marca de tiempo, varios sensores y dispositivos
Escribir la marca de tiempo en Apps Script con new Date() es lo más práctico: el ESP32 no necesita saber la hora y todos los dispositivos comparten la misma fuente de tiempo. El único inconveniente es que la marca indica cuándo llegó el dato a Google, no el momento de la medición; la diferencia suele ser de unos segundos. Si acumulas lecturas y las envías por lotes, obtén la hora en el ESP32 con NTP y añádela al JSON como un campo ts. Para añadir un sensor nuevo solo cambias tres sitios: el campo en el texto JSON del ESP32, una línea num(data.nuevo) en el array de appendRow de Apps Script y el encabezado en la hoja. Varios ESP32 pueden escribir en la misma hoja; da a cada placa un nombre DEVICE distinto y podrás filtrar las filas por esa columna o abrir una pestaña por dispositivo.
Crear un gráfico en vivo en Google Sheets
- Selecciona las columnas completas de la A a la D pulsando en las letras de columna, no en los encabezados (A:D); así las filas nuevas entran solas en el gráfico.
- Abre Insertar > Gráfico y en el editor elige el tipo Gráfico de líneas.
- Deja la columna Hora como eje X y Temperatura y Humedad como series; quita la columna Dispositivo de las series.
- Como la luz va de 0 a 4095, aplasta las otras curvas; muéstrala en un gráfico aparte o en el eje derecho desde Personalizar > Series.
- Con Publicar gráfico en los tres puntos de la esquina del gráfico obtienes un enlace que muestra el gráfico sin abrir la hoja.
Cuotas y límites: ¿cada cuánto puedes enviar datos?
| Límite | Valor | Qué significa en la práctica |
|---|---|---|
| Número de celdas | 10 millones de celdas por hoja de cálculo | Las columnas vacías también cuentan; borra las que no uses |
| Ejecuciones simultáneas | Unas 30 por usuario | Si muchos dispositivos envían en el mismo segundo, puede haber errores |
| Tiempo de ejecución | 6 minutos por llamada | Sin problema para appendRow |
| Tiempo de respuesta | Normalmente 1-5 segundos | No sirve para varias lecturas por segundo |
| Intervalo recomendado | 1 minuto o más | Más que suficiente para vigilar una casa o un invernadero |
Veamos el límite de celdas con un cálculo concreto. Una fila por minuto son 1440 filas al día. Si dejas solo 5 columnas en la hoja, usas 7200 celdas al día y los 10 millones de celdas duran unos 3,8 años. Si no borras las 26 columnas por defecto de una hoja nueva, cada fila cuenta como 26 celdas y el mismo límite se alcanza en unos 9 meses. En registros largos, abrir una pestaña nueva cada año o mover los datos antiguos a otro archivo también mantiene la hoja ágil; una hoja con cientos de miles de filas se abre lenta en el móvil.
Gestión de errores: ¿qué significan los códigos HTTP?
| En el Monitor Serie | Significado | Qué hacer |
|---|---|---|
| HTTP 200 + "ok":true | Fila añadida | Todo correcto |
| HTTP 200 + unauthorized | El TOKEN no coincide o falta la propiedad | Compara el código con las propiedades del script |
| HTTP 302 | No se siguió la redirección | Añade la línea setFollowRedirects |
| HTTP 401 / 403 o página HTML de inicio de sesión | El acceso no está en "Cualquier usuario" | Edita la implementación y cambia el acceso |
| HTTP 404 | URL errónea o implementación archivada | Copia la URL actual que termina en /exec |
| Código negativo (-1, -11) | Sin conexión o tiempo agotado | Revisa la señal WiFi y el valor de setTimeout |
En un dispositivo que funciona mucho tiempo, los cortes de red son inevitables. Para cortes breves basta el bucle de tres intentos del código. Si no quieres perder datos en cortes de horas, acumula las lecturas en un array o en un archivo en la flash del ESP32 y envíalas en orden cuando vuelva la conexión. Si no logras conectarte al WiFi, los pasos de el ESP32 no se conecta al WiFi te ayudarán a encontrar la causa.
Mantener en secreto la URL de la aplicación web
- Como el acceso está en "Cualquier usuario", quien conozca la URL puede añadir filas; borra siempre la URL y la clave antes de compartir tu código en internet.
- No publiques nunca sin la comprobación del TOKEN; las peticiones sin clave se rechazan sin tocar la hoja.
- Si pones la contraseña del WiFi, la URL y la clave en un archivo aparte secrets.h y lo incluyes con #include, es fácil dejarlo fuera al compartir el código.
- Si la URL se filtra, archiva la implementación antigua en Gestionar implementaciones, crea una nueva y cambia el TOKEN.
- No hace falta compartir la hoja con "cualquier persona con el enlace"; la aplicación web se ejecuta con tu cuenta, así que la hoja puede seguir siendo privada.
ThingSpeak y otras alternativas
| Método | Punto fuerte | Punto débil |
|---|---|---|
| Google Sheets | Gratis, interfaz conocida, fórmulas y uso compartido fáciles | Respuesta lenta, no sirve para datos más frecuentes que cada minuto |
| ThingSpeak | Gráficos listos, análisis con MATLAB, API HTTP sencilla | En el plan gratuito, mínimo 15 s entre envíos y 8 campos por canal |
| MQTT + Home Assistant | Instantáneo, bidireccional, se integra con la domótica | Necesita un servidor encendido siempre en casa |
| Blynk | Interfaz móvil lista, notificaciones | El plan gratuito limita dispositivos y datos |
| Tarjeta SD | No necesita internet, registro muy rápido | No puedes ver los datos a distancia |
¿Cuál elegir? Si quieres editar los datos en una hoja, procesarlos con fórmulas o compartirlos con alguien, Google Sheets es imbatible. Si solo vas a mirar gráficos, los paneles listos de ThingSpeak dan menos trabajo. Si ya tienes un sistema domótico, MQTT con Home Assistant es la opción más flexible. Si prefieres trabajar con Excel en el ordenador, mira el método por puerto serie en pasar datos de Arduino a Excel, y para lugares sin internet, el registro en tarjeta SD.
Ideas de proyectos con ESP32 y Google Sheets
- Diario del invernadero: escribe en la hoja la temperatura, la humedad y la humedad del suelo cada 10 minutos y decide el riego según el historial.
- Estación exterior a pilas: despierta el ESP32 del sueño profundo cada 15 minutos, envía la lectura y vuelve a dormirlo.
- Contador de puerta y movimiento: registra cada apertura de puerta o detección PIR con su marca de tiempo y grafica los totales diarios.
- Seguimiento del consumo eléctrico: envía la lectura de un sensor de corriente como media por minuto y calcula los kWh con una fórmula en la hoja.
- Experimento en clase: que varias placas de alumnos escriban en la misma hoja con distintos nombres DEVICE y comparad juntos los resultados.
En cuanto sabes escribir datos en Google Sheets, cada proyecto con ESP32 se convierte en un pequeño dispositivo IoT con historial de medidas y gráfico. En la app BlueGrays encontrarás proyectos con ESP32 como la conexión WiFi, temperatura y humedad con DHT22, hora NTP, el tiempo con HTTPClient y el sueño profundo, cada uno con esquema y código paso a paso, para añadirles el registro en Google Sheets de este artículo.
Preguntas frecuentes
¿Cómo envío datos del ESP32 a Google Sheets?
Escribes una función doPost en un proyecto de Google Apps Script vinculado a la hoja y lo publicas como aplicación web. El ESP32 usa WiFiClientSecure y HTTPClient para enviar una petición HTTPS POST con JSON a la URL /exec de la aplicación, y la función añade una fila nueva con appendRow.
¿Necesito una clave de API de Google Sheets?
Con el método de la aplicación web de Apps Script no necesitas clave de API ni configurar OAuth. El script se ejecuta con tu cuenta y escribe él mismo en la hoja. Para la seguridad basta con comprobar una clave secreta (TOKEN) elegida por ti.
¿Por qué el ESP32 recibe un error 302 de Google Sheets?
La aplicación web de Apps Script responde primero a la petición POST con una redirección 302. HTTPClient en el ESP32 no sigue redirecciones por defecto, por eso ves el código 302. Al añadir http.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS) recibes la respuesta real.
¿Cada cuánto puedo enviar datos a Google Sheets?
Cada petición tarda 1-5 segundos y hay un límite de ejecuciones simultáneas, así que se recomienda enviar una vez por minuto o menos. Una hoja admite hasta 10 millones de celdas; una fila de 5 columnas por minuto dura unos 3,8 años. Si necesitas varias lecturas por segundo, promédialas en el ESP32 y envíalas por lotes.
He cambiado el código de Apps Script pero el ESP32 recibe el resultado antiguo. ¿Por qué?
Una aplicación web ejecuta la versión publicada; guardar el código no basta. En Implementar > Gestionar implementaciones edita la implementación existente y elige Nueva versión. Si creas una implementación nueva, la URL cambia y también tendrás que actualizarla en el ESP32.
¿Qué es mejor, ThingSpeak o Google Sheets?
Si quieres gráficos listos y un panel IoT sencillo, ThingSpeak se configura antes, pero el plan gratuito exige al menos 15 segundos entre envíos y permite 8 campos por canal. Si quieres procesar, editar y compartir los datos con fórmulas, Google Sheets es más flexible.
Proyectos para hacer después de leer esto
Ver todos los proyectos
Conexión Wi-Fi STA con ESP32 (con pantalla LCD)
En este proyecto, conectamos el ESP32 a la red Wi-Fi doméstica en modo Station (STA) de forma segura y tolerante a fallos. Separamos el SSID y la contraseña en el archivo secrets.h para evitar que se filtren a Git, configuramos un mecanismo de reconexión automática y mostramos el nivel de señal RSSI y la dirección IP en una pantalla LCD I2C. El LED interno actúa como indicador de estado.

ESP32 HTTPClient + API del tiempo (con pantalla LCD)
El ESP32 hace una llamada REST por internet a una API del tiempo (wttr.in) con HTTPClient.h. La respuesta JSON se analiza con ArduinoJson v7, y la ciudad, la temperatura, la humedad, el estado del tiempo y el viento aparecen en una LCD I2C. wttr.in no pide clave de API: basta con escribir el nombre de cualquier ciudad.

ESP32 DHT22 Temperatura y humedad (con pantalla LCD)
Se trata de un proyecto que mide la temperatura y la humedad ambientales mediante el sensor DHT22 y las muestra en tiempo real en una pantalla LCD I2C 16x2. Los datos del sensor se leen mediante el protocolo de un solo cable (one-wire) utilizando la biblioteca DHT de Adafruit. Este proyecto constituye la base para estaciones meteorológicas IoT, sistemas de automatización doméstica inteligente o sistemas de monitorización ambiental en invernaderos.

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

ESP32: hora real desde Internet con NTP
El ESP32 se conecta al Wi-Fi y obtiene la hora real de servidores NTP (Network Time Protocol) con precisión de milisegundos. Gracias a configTzTime(), se aplica automáticamente la zona horaria de Turquía (TRT, UTC+3), y en los países con horario de verano el cambio (DST) se gestiona solo mediante una cadena POSIX TZ. La hora se muestra en el Serial Monitor y en una LCD I2C opcional.

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

Lectura de la intensidad luminosa con el módulo LDR del ESP32
Visualización en tiempo real en el monitor serie del valor bruto del ADC del módulo LDR y del porcentaje relativo de luz calculado a partir de referencias de oscuridad y claridad. Este porcentaje no es una medición en lux. Explica el funcionamiento de la calibración del módulo. Es recomendable realizarlo antes del Proyecto 10, ya que se utiliza para determinar el valor umbral.
Más artículos
App BlueGrays
Monta este circuito paso a paso en tu teléfono
Esquema, código y lista de piezas en una sola pantalla. Más de 500 proyectos de Arduino, ESP32 y Pico listos para montar.
Escanea con tu teléfono
Apunta la cámara al código y se abrirá la tienda de apps de tu teléfono.
o ábrela en la tienda

