Enviar datos de Arduino a Excel: Data Streamer, PLX-DAQ y Python

Enviar datos de Arduino a Excel consiste en mandar al ordenador, por el cable USB, los valores que el Arduino lee de sus sensores y reunirlos fila a fila en una hoja de cálculo. El Arduino escribe cada medida en el puerto serie como una sola línea separada por comas; en el ordenador hay cuatro formas habituales de llevar esas líneas a Excel: guardar la salida del monitor serie como CSV, el complemento Data Streamer de Microsoft, la macro PLX-DAQ y el registro automático con Python. La idea es siempre la misma: cada línea que envía el Arduino se convierte en una fila de Excel, y cada coma abre una columna nueva.

En esta guía usamos como ejemplo un sensor de temperatura y humedad DHT11 y un sensor de luz LDR. Primero comparamos los cuatro métodos para que elijas el que más te conviene y después montamos cada uno paso a paso. A continuación verás cómo añadir marcas de tiempo a tus medidas, cómo elegir el tipo de gráfico adecuado en Excel y cómo preparar una tabla de medidas para el informe de laboratorio que puedes usar en clase o en una feria de ciencias. En las últimas secciones aprenderás a hacer lo mismo con un ESP32 y una Raspberry Pi Pico y a resolver los errores más frecuentes.

¿Cómo funciona el envío de datos de Arduino a Excel?

El Arduino no puede escribir directamente en Excel; lo único que hace es enviar texto al puerto serie con Serial.print(). El ordenador accede a ese puerto con un nombre como COM3 en Windows, /dev/cu.usbmodem… en macOS o /dev/ttyACM0 en Linux. El idioma común entre Excel y el Arduino es CSV (Comma Separated Values, valores separados por comas): una línea como 12.0,23.0,45,78 se divide en cuatro columnas. Por eso tu código solo tiene que cumplir dos reglas: pon siempre el mismo separador entre los valores y termina cada medida con Serial.println(). Encontrarás los fundamentos del puerto serie en detalle en la guía del monitor serie de Arduino.

Circuito de ejemplo: conexión del DHT11 y la LDR

El circuito de ejemplo tiene dos sensores. El DHT11 mide la temperatura con una resolución de 1 °C y la humedad con una de 1 %; su precisión es de unos ±2 °C y ±5 % de humedad relativa, y solo necesita un pin de datos. La LDR es una fotorresistencia cuya resistencia baja cuando aumenta la luz; con una resistencia de 10 kΩ montas un divisor de tensión y conectas el punto medio a una entrada analógica. Con la conexión de abajo, el valor analógico sube cuanto más luz hay. El número que da una LDR no está en lux, sino que es un nivel de luz relativo, así que lo honesto es indicarlo en tu informe como "luz (%)". Si necesitas lux reales, usa un sensor de luz calibrado como el BH1750.

Código de Arduino: enviar las medidas como líneas CSV

1// DHT11 + LDR ölçümlerini CSV satırı olarak gönderir / Sends DHT11 + LDR readings as CSV lines
2#include <DHT.h>
3
4const int DHT_PIN = 2;                 // DHT11 veri pini / DHT11 data pin
5const int LDR_PIN = A0;                // LDR + 10k gerilim bölücü / LDR + 10k voltage divider
6const unsigned long ARALIK = 2000;     // ölçüm aralığı, ms (DHT11 için en az 1000) / interval in ms (at least 1000 for DHT11)
7
8DHT dht(DHT_PIN, DHT11);               // DHT22 kullanıyorsan DHT22 yaz / write DHT22 if you use one
9unsigned long sonOlcum = 0;
10
11void setup() {
12  Serial.begin(9600);                  // Data Streamer ve PLX-DAQ varsayılanı / default of Data Streamer and PLX-DAQ
13  dht.begin();
14  Serial.println("zaman_s,sicaklik_C,nem_yuzde,isik_yuzde");   // başlık satırı / header row
15}
16
17void loop() {
18  if (millis() - sonOlcum < ARALIK) return;   // zamanı gelmediyse çık / not time yet
19  sonOlcum = millis();
20
21  float sicaklik = dht.readTemperature();     // santigrat derece / degrees Celsius
22  float nem = dht.readHumidity();             // bağıl nem, % / relative humidity, %
23  int isik = map(analogRead(LDR_PIN), 0, 1023, 0, 100);   // göreli ışık, % / relative light, %
24
25  if (isnan(sicaklik) || isnan(nem)) {
26    Serial.println("HATA,DHT okunamadi");     // sayı olmadığı için kolay ayıklanır / easy to filter out, not a number
27    return;
28  }
29
30  Serial.print(sonOlcum / 1000.0, 1);         // açılıştan beri geçen saniye / seconds since power-up
31  Serial.print(',');                          // sütun ayırıcı / column separator
32  Serial.print(sicaklik, 1);
33  Serial.print(',');
34  Serial.print(nem, 0);
35  Serial.print(',');
36  Serial.println(isik);                       // satır sonu = yeni Excel satırı / line end = new Excel row
37}

El programa usa la DHT sensor library de Adafruit; al instalarla desde el gestor de bibliotecas, acepta instalar también su dependencia, Adafruit Unified Sensor. Las medidas se toman cada 2 segundos y se temporizan con millis() en lugar de delay(), así loop() nunca se bloquea (detalles en la guía de millis y delay). Cada línea contiene, por este orden, las columnas tiempo, temperatura, humedad y luz. Serial.print(sicaklik, 1) escribe el número con un decimal y siempre con punto. Si el sensor no se puede leer, el programa escribe "HATA" (error) en lugar de un número, de modo que ves la fila defectuosa en la tabla al instante y puedes filtrarla. La línea de cabecera de setup() te sirve para el monitor serie y para Python; si usas Data Streamer, puedes borrarla. Para medidas que cambian despacio, como la temperatura de una habitación, pon ARALIK (intervalo) a 60000 y tomarás una medida por minuto.

Método 1: guardar la salida del monitor serie como CSV

1. Sube el programa, abre Herramientas > Monitor Serie y elige 9600 baudios en el menú de velocidad.
2. Si quieres, activa las marcas de tiempo: en Arduino IDE 2 haz clic en el icono del reloj, arriba a la derecha de la ventana; en el IDE 1.8, en la casilla de marca de tiempo de abajo. Al principio de cada línea se añade la hora del ordenador con el formato 14:03:21.512 ->.
3. Cuando acabe el experimento, selecciona las líneas con el ratón y cópialas con Ctrl+C (Cmd+C en macOS). Si quieres conservar los datos en bruto, pégalos en el Bloc de notas y guárdalos como olcum.csv con el tipo Todos los archivos.
4. En Excel, haz clic en la celda A1 de una hoja vacía y pega con Ctrl+V; todas las líneas quedan en la columna A.
5. Con la columna A seleccionada, abre Datos > Texto en columnas, elige Delimitados y marca Coma como separador. Si las marcas de tiempo están activas, marca también Espacio: la hora va a la primera columna y las marcas "->" a la segunda, que luego borras.
6. En el último paso pulsa Avanzadas y pon el punto como separador decimal; así el Excel en español reconoce valores como 23.5 como números. Pulsa Finalizar y guarda el archivo como .xlsx.

Este método es muy práctico hasta unos cientos de líneas; con miles de líneas cuesta seleccionar y la ventana del IDE se vuelve lenta. Para registros de horas, programas de terminal como PuTTY (Session > Logging > All session output) o CoolTerm, que funciona en Windows, macOS y Linux (Connection > Capture to Text/Binary File), escriben cada línea que llega directamente en un archivo. Ese archivo lo llevas a Excel con los mismos pasos. Recuerda: mientras un programa de terminal o el monitor serie usa el puerto, ni los complementos de Excel ni Python pueden conectarse a él.

Método 2: datos en directo con Excel Data Streamer

Data Streamer es un complemento gratuito que Microsoft creó para la enseñanza; hace fluir las líneas CSV del puerto serie directamente a una hoja de cálculo. Viene incluido con el Excel de escritorio de Microsoft 365 (versión 1902 y posteriores), así que solo tienes que activarlo. Como es un complemento COM, funciona solo en Windows; no existe en Excel para macOS ni en Excel para la web. En el lado del Arduino no tienes que cambiar nada: el programa de arriba funciona tal cual a 9600 baudios, la velocidad predeterminada del complemento.

1. En Excel, abre Archivo > Opciones > Complementos, elige Complementos COM en la lista Administrar de abajo y pulsa Ir.
2. Marca Microsoft Data Streamer for Excel y pulsa Aceptar; en la cinta aparece la pestaña Data Streamer.
3. Cierra el monitor serie del Arduino IDE; un puerto serie solo puede abrirlo un programa a la vez.
4. Con el botón Connect a Device elige el puerto COM del Arduino y después pulsa Start Data. Según el idioma de Excel, los botones pueden aparecer traducidos.
5. Excel crea tres hojas: Data In (datos de entrada), Data Out (datos para el Arduino) y Settings (ajustes). En la hoja Settings pon Data Channels a 4 y aumenta Data Rows para ver más historial en la tabla.
6. Para guardar un registro permanente, empieza a grabar con Record Data; cuando lo detengas con Stop Recording, las medidas quedarán guardadas en un archivo CSV. Más tarde puedes reproducir ese archivo con Import Data File.

En la parte superior de la hoja Data In están los valores más recientes (Current Data) y, debajo, una tabla por la que van pasando las medidas anteriores (Historical Data). Si seleccionas esa tabla y añades un gráfico de líneas o de dispersión con Insertar > Gráficos recomendados, el gráfico se actualiza solo con cada dato nuevo; es ideal para mostrar en clase cómo cae la curva de luz en cuanto pones la mano sobre el sensor. En la hoja Settings, Data Interval (ms) fija cada cuánto se actualiza la hoja, y Data Orientation decide si los datos más nuevos aparecen arriba o abajo de la tabla. Los valores que escribas en la hoja Data Out también se envían al Arduino como una línea CSV; el Arduino puede leerlos con Serial.parseInt(), de modo que podrías, por ejemplo, ajustar un umbral de alarma desde Excel.

Método 3: escribir en Excel fila a fila con la macro PLX-DAQ

PLX-DAQ (Parallax Data Acquisition) es una macro VBA que se ejecuta dentro de Excel y convierte en celdas unos comandos especiales que llegan por el puerto serie. Como la versión original de Parallax solo funciona en Excel de 32 bits, hoy se usa PLX-DAQ v2, desarrollada por la comunidad de Arduino; es compatible con Excel de 64 bits y viene en un único archivo .xlsm. Como la macro se apoya en la API de Windows, también funciona solo en Windows. La diferencia con Data Streamer es que aquí el Arduino controla Excel: escribe los encabezados, borra la hoja y hace que Excel añada la fecha y la hora.

1// PLX-DAQ v2: Excel'e tarih, saat ve ölçüm satırı yazar / PLX-DAQ v2: writes date, time and readings into Excel
2#include <DHT.h>
3
4DHT dht(2, DHT11);                     // DHT11 veri pini D2 / DHT11 data pin D2
5const int LDR_PIN = A0;
6
7void setup() {
8  Serial.begin(9600);                  // PLX-DAQ'ta da 9600 seç / choose 9600 in PLX-DAQ too
9  dht.begin();
10  Serial.println("CLEARDATA");         // eski ölçümleri sil / clear old readings
11  Serial.println("LABEL,Tarih,Saat,Sure (s),Sicaklik (C),Nem (%),Isik (%)");   // 1. satır başlıkları / row 1 headers
12  Serial.println("RESETTIMER");        // TIMER sayacını sıfırla / reset the TIMER counter
13}
14
15void loop() {
16  float sicaklik = dht.readTemperature();
17  float nem = dht.readHumidity();
18  int isik = map(analogRead(LDR_PIN), 0, 1023, 0, 100);
19
20  if (!isnan(sicaklik) && !isnan(nem)) {
21    Serial.print("DATA,DATE,TIME,TIMER,");   // DATE, TIME, TIMER'ı Excel doldurur / Excel fills in DATE, TIME, TIMER
22    Serial.print(sicaklik, 1);
23    Serial.print(',');
24    Serial.print(nem, 0);
25    Serial.print(',');
26    Serial.println(isik);
27  }
28  delay(2000);                         // DHT11 saniyede en fazla 1 ölçüm verir / DHT11 gives at most 1 reading per second
29}

1. Descarga el archivo de PLX-DAQ v2 y descomprime el zip. Haz clic derecho en el archivo .xlsm y, en Propiedades, marca la casilla Desbloquear; Office bloquea por defecto las macros de los archivos descargados de internet.
2. Abre el archivo y pulsa Habilitar contenido en la barra amarilla de arriba.
3. Cierra el monitor serie del Arduino IDE y pulsa el botón Open PLX DAQ UI de la hoja.
4. En la ventana que se abre, escribe en la casilla Port solo el número de COM (5 para COM5), elige 9600 en Baud y pulsa Connect.
5. Si no aparecen los encabezados, pulsa el botón de reset del Arduino: setup() se ejecuta de nuevo, los comandos CLEARDATA y LABEL llegan a Excel y las filas empiezan a entrar.
6. Cuando termines, pulsa Disconnect y, si quieres, guarda los datos como un archivo .xlsx aparte.

Método 4: archivos CSV y Excel automáticos con Python

Si usas Mac o Linux, vas a registrar durante horas o te cansa preparar el informe a mano cada vez, Python es la opción más flexible. Primero instala los dos paquetes en una terminal con python -m pip install pyserial openpyxl. El primer script de abajo escucha al Arduino y escribe cada medida, junto con la hora del ordenador, en el archivo deney_olcumleri.csv. Temas como encontrar el puerto, el reinicio automático y los gráficos en directo los explicamos en detalle en la guía de comunicación serie entre Arduino y Python.

1import csv
2import time
3from datetime import datetime
4
5import serial
6
7PORT = "COM3"               # macOS: /dev/cu.usbmodem…, Linux: /dev/ttyACM0
8BAUD = 9600                 # Arduino'daki Serial.begin ile aynı / same as Serial.begin on the Arduino
9DOSYA = "deney_olcumleri.csv"
10AYIRICI = ";"               # Türkçe Excel ; bekler, İngilizce Excel , / Turkish Excel expects ;, English Excel ,
11ONDALIK = ","               # Türkçe Excel ondalık virgül, İngilizce nokta / decimal comma in Turkish Excel, dot in English
12
13
14def sayi(x):
15    return f"{x:.1f}".replace(".", ONDALIK)   # 23.5 -> "23,5"
16
17
18with serial.Serial(PORT, BAUD, timeout=3) as ser, \
19        open(DOSYA, "w", newline="", encoding="utf-8-sig") as f:   # BOM: Excel Türkçe harfleri doğru gösterir / BOM keeps accents readable
20    time.sleep(2)                       # Uno port açılınca resetlenir / the Uno resets when the port opens
21    ser.reset_input_buffer()            # yarım kalmış satırları at / drop partial lines
22    yazici = csv.writer(f, delimiter=AYIRICI)
23    yazici.writerow(["Zaman", "Süre (s)", "Sıcaklık (°C)", "Nem (%)", "Işık (%)"])
24    print("Kayıt başladı, durdurmak için Ctrl+C / logging, press Ctrl+C to stop")
25    try:
26        while True:
27            satir = ser.readline().decode("utf-8", errors="ignore").strip()
28            parca = satir.split(",")
29            if len(parca) != 4:
30                continue                # boş, hata ya da başlık satırı / empty, error or header line
31            try:
32                sure, sicaklik, nem, isik = (float(p) for p in parca)
33            except ValueError:
34                continue                # sayı olmayan satır / non-numeric line
35            simdi = datetime.now()
36            yazici.writerow([simdi.strftime("%Y-%m-%d %H:%M:%S"),   # bilgisayar saati / PC clock
37                             sayi(sure), sayi(sicaklik), sayi(nem), sayi(isik)])   # süre Arduino'dan gelir / elapsed time comes from the Arduino
38            f.flush()                   # satırı hemen diske yaz / write the row to disk now
39            print(simdi.strftime("%H:%M:%S"), sicaklik, nem, isik)
40    except KeyboardInterrupt:
41        print("Kayıt bitti / logging stopped:", DOSYA)

Tres detalles del script garantizan la compatibilidad con Excel. La codificación utf-8-sig añade una marca BOM invisible al principio del archivo; sin ella, Excel muestra estropeados caracteres como "°C" o las letras con tilde. Las constantes AYIRICI (separador) y ONDALIK (decimal) están puestas en punto y coma y coma decimal, el formato que espera Excel con la configuración regional de España; con una configuración de Estados Unidos o de México, cámbialas a coma y punto. f.flush() escribe cada fila en el disco al momento, así que si el ordenador se apaga o se suelta el cable, como mucho pierdes la última medida. Después de detener el script con Ctrl+C, basta con hacer doble clic en el archivo para que se abra con las columnas bien separadas. Si quieres mirar el archivo mientras el registro sigue en marcha, abre una copia, porque Excel puede bloquear los archivos que abre.

1import csv
2from datetime import datetime
3
4from openpyxl import Workbook
5from openpyxl.chart import Reference, ScatterChart, Series
6
7GIRIS = "deney_olcumleri.csv"
8CIKIS = "deney_raporu.xlsx"
9
10wb = Workbook()
11ws = wb.active
12ws.title = "Olcumler"
13
14with open(GIRIS, encoding="utf-8-sig", newline="") as f:
15    okuyucu = csv.reader(f, delimiter=";")
16    ws.append(next(okuyucu))                               # başlık satırı / header row
17    for satir in okuyucu:
18        zaman = datetime.strptime(satir[0], "%Y-%m-%d %H:%M:%S")
19        degerler = [float(x.replace(",", ".")) for x in satir[1:]]   # "23,5" -> 23.5
20        ws.append([zaman] + degerler)                      # .xlsx sayıyı sayı olarak saklar / .xlsx stores real numbers
21
22son = ws.max_row
23for hucre in ws["A"][1:]:
24    hucre.number_format = "hh:mm:ss"                       # zaman sütunu biçimi / time column format
25ws.column_dimensions["A"].width = 12
26
27# Özet tablo: formüller İngilizce yazılır, Excel kendi diline çevirir
28# Summary: formulas are written in English, Excel shows them in its own language
29ws["G1"], ws["H1"], ws["I1"], ws["J1"] = "Özet", "Sıcaklık (°C)", "Nem (%)", "Işık (%)"
30for i, (ad, fonk) in enumerate([("Ortalama", "AVERAGE"), ("En düşük", "MIN"),
31                                ("En yüksek", "MAX"), ("Std. sapma", "STDEV")], start=2):
32    ws.cell(row=i, column=7, value=ad)
33    for sutun, harf in ((8, "C"), (9, "D"), (10, "E")):
34        ws.cell(row=i, column=sutun, value=f"={fonk}({harf}2:{harf}{son})")
35
36# Her ölçüm için süre-değer (XY dağılım) grafiği / one time-value (XY scatter) chart per reading
37x = Reference(ws, min_col=2, min_row=2, max_row=son)       # Süre (s) sütunu / elapsed time column
38for sutun, baslik, konum in ((3, "Sıcaklık (°C)", "G8"), (5, "Işık (%)", "G24")):
39    grafik = ScatterChart()
40    grafik.title = baslik + " - süre"
41    grafik.x_axis.title = "Süre (s)"
42    grafik.y_axis.title = baslik
43    grafik.x_axis.delete = False                           # yeni Excel'de eksenler görünsün / keep axes visible
44    grafik.y_axis.delete = False
45    y = Reference(ws, min_col=sutun, min_row=1, max_row=son)
46    grafik.series.append(Series(y, x, title_from_data=True))
47    grafik.width, grafik.height = 18, 8                    # cm
48    ws.add_chart(grafik, konum)
49
50wb.save(CIKIS)
51print(son - 1, "ölçüm yazıldı / readings written:", CIKIS)

El segundo script convierte el CSV en un archivo .xlsx de verdad. Dentro de un .xlsx los números se guardan como números y no como texto, así que el problema de separadores y decimales desaparece por completo; el archivo se abre igual en un Excel en español, en inglés o en alemán. El script también añade una tabla resumen con la media, el mínimo, el máximo y la desviación estándar, además de dos gráficos de dispersión para la temperatura y la luz. Las fórmulas se escriben en el archivo con sus nombres en inglés (AVERAGE, MIN, MAX, STDEV) y Excel las traduce al abrirlo: en un Excel en español verás PROMEDIO, MIN, MAX y DESVEST. Las líneas delete = False evitan un problema por el que los rótulos de los ejes no aparecen en los gráficos creados con versiones recientes de openpyxl.

Añadir marcas de tiempo: millis(), reloj del ordenador o RTC

En los experimentos conectados a un ordenador, lo más sencillo es su reloj, y nuestro script de Python lo escribe en cada fila. Aun así, conviene guardar también el tiempo que envía el Arduino: muestra el intervalo real entre medidas y te permite notar enseguida si falta una fila. Si envías el valor de millis() en bruto desde el Arduino, en Excel lo pasas a segundos con =B2/1000 o a minutos con =B2/60000. Si el Arduino va a trabajar sin ordenador, por ejemplo guardando datos en una tarjeta SD, debes tomar la fecha y la hora de un módulo de reloj RTC; los detalles de guardar CSV en una tarjeta SD están en la guía del módulo de tarjeta SD. Con un ESP32 también puedes obtener la hora de internet: hora NTP con el ESP32.

Crear un gráfico en Excel

1. Selecciona las columnas de tiempo y temperatura con sus encabezados; si no están juntas, mantén pulsada la tecla Ctrl al seleccionar la segunda.
2. Elige un tipo de dispersión con líneas en Insertar > Gráficos > Dispersión (X, Y).
3. Con el botón + que aparece junto al gráfico activa los Títulos de ejes y nombra los ejes con sus unidades: "Tiempo (s)" y "Temperatura (°C)".
4. Para añadir la serie de luz, haz clic derecho en el gráfico y añade la columna de luz con Seleccionar datos > Agregar; como las escalas son muy distintas, haz clic derecho en la serie y elige Dar formato a serie de datos > Eje secundario.
5. Haz clic derecho en el eje vertical y fija los valores mínimo y máximo en Dar formato al eje, para que un cambio de 1 °C no parezca una oscilación enorme.

¿Por qué un gráfico de dispersión y no uno de líneas? El gráfico de Línea de Excel trata los valores del eje horizontal como etiquetas a intervalos iguales; si falta una medida o cambias el intervalo, el eje de tiempo se deforma sin avisar. El gráfico de Dispersión (X, Y), en cambio, coloca cada punto en su tiempo real, que es lo que se espera de un gráfico científico. Si solo vas a comparar unos pocos valores fijos, como la temperatura media de tres habitaciones, un gráfico de columnas se lee mejor. Si el sensor tiene ruido, haz clic derecho en la serie y suaviza la curva con Agregar línea de tendencia > Media móvil.

Ejemplo de tabla de medidas para el informe de laboratorio

Supongamos que la pregunta de tu experimento es: "¿Cómo cambian la temperatura, la humedad y el nivel de luz del aire junto a un flexo cuando se enciende?" Colocamos los sensores a unos 15 cm de la lámpara y pusimos ARALIK a 60000 en el programa, es decir, una medida por minuto. Encendimos la lámpara en el minuto 1 y la apagamos en el minuto 6. Los valores de abajo son valores de ejemplo típicos que puedes obtener con este montaje; las dos últimas filas son resúmenes calculados con fórmulas de Excel:

Las filas de resumen se calculan en Excel con =PROMEDIO(B2:B10), =MIN(B2:B10) y =MAX(B2:B10); para mostrar cuánto se dispersan las medidas, puedes añadir también =DESVEST(B2:B10). Al interpretar los resultados, describe el patrón de la tabla: en cuanto se encendió la lámpara, la luz saltó del 14 % al 81 %, mientras que la temperatura subió despacio 3 °C en unos 3 minutos; a esto se le llama inercia térmica. Al apagar la lámpara, la luz cayó de inmediato, pero la temperatura siguió alta unos minutos más. La humedad relativa bajó mientras subía la temperatura, porque el aire más caliente puede contener más humedad aunque la cantidad de agua que lleva no cambie. Una bombilla incandescente o halógena muestra este efecto con claridad; con una lámpara LED la subida de temperatura es mucho menor.

• Objetivo: la pregunta de investigación y tu hipótesis en una frase.
• Materiales: modelo de placa, sensores, resistencias y el software que usaste (Arduino IDE, Excel).
• Método: dónde estaban los sensores, el intervalo de medida (por ejemplo 60 s), cuánto duró el experimento y con qué método pasaste los datos a Excel.
• Tabla de medidas: cada encabezado de columna debe llevar su unidad; usa la tabla resumen en el texto y adjunta todos los datos en bruto como anexo.
• Gráfico: un gráfico de dispersión con títulos de ejes, unidades y los sucesos marcados (lámpara encendida, apagada).
• Conclusión y fuentes de error: compara los resultados con la hipótesis y señala limitaciones como la precisión de ±2 °C del DHT11, que la LDR no está calibrada y la distancia del sensor a la lámpara.

Enviar datos del ESP32 a Excel

En el ESP32 todos los métodos funcionan igual; para Data Streamer y PLX-DAQ el ESP32 es simplemente otro puerto serie. Cambian tres cosas: la lectura analógica es de 12 bits (0–4095), el divisor de la LDR se alimenta con 3,3 V y como entrada analógica conviene elegir uno de los pines ADC1 (GPIO 32–39), porque siguen funcionando con el Wi-Fi activado. Las placas ESP32 suelen usarse a 115200 baudios, así que cambia la velocidad en el script de Python, en Data Streamer y en PLX-DAQ. Los mensajes del cargador de arranque que aparecen en el puerto serie al encender no son números, así que el script de Python los ignora de todos modos. Si quieres enviar las medidas a la nube sin conectar nada a un ordenador, echa un vistazo a la guía para guardar datos del ESP32 en Hojas de cálculo de Google.

1// ESP32: aynı CSV çıktısı, 12 bit ADC ve 3,3 V / ESP32: same CSV output, 12-bit ADC and 3.3 V
2#include <DHT.h>
3
4const int DHT_PIN = 4;                 // güvenli bir GPIO / a safe GPIO
5const int LDR_PIN = 34;                // ADC1 pini, Wi-Fi açıkken de okur / ADC1 pin, still reads with Wi-Fi on
6DHT dht(DHT_PIN, DHT11);
7
8void setup() {
9  Serial.begin(115200);                // Python'da ve Data Streamer'da da 115200 / 115200 in Python and Data Streamer too
10  dht.begin();
11  analogReadResolution(12);            // 0-4095
12}
13
14void loop() {
15  float sicaklik = dht.readTemperature();
16  float nem = dht.readHumidity();
17  int isik = map(analogRead(LDR_PIN), 0, 4095, 0, 100);   // göreli ışık, % / relative light, %
18
19  if (!isnan(sicaklik) && !isnan(nem)) {
20    // zaman_s,sicaklik,nem,isik biçimi, Uno koduyla aynı / same zaman_s,temp,hum,light format as the Uno sketch
21    Serial.printf("%.1f,%.1f,%.0f,%d\n", millis() / 1000.0, sicaklik, nem, isik);
22  }
23  delay(2000);
24}

Registro en CSV con la Raspberry Pi Pico (MicroPython)

Si usas MicroPython en una Raspberry Pi Pico, puedes escribir las medidas en un archivo CSV dentro de la memoria flash de la propia placa en lugar de mandarlas a un ordenador; así no necesitas ordenador y puedes dejar la Pico, alimentada con una batería externa, donde quieras medir. El código de abajo usa el sensor de temperatura integrado (ADC4), que no requiere hardware extra, y una LDR conectada a GP26, y escribe el archivo con punto y coma y coma decimal para que encaje con un Excel en español. Como el sensor integrado mide la temperatura del chip, puede marcar algunos grados más que la del ambiente; para medidas precisas usa un sensor externo. Si empiezas con MicroPython, comienza por la guía Qué es la Raspberry Pi Pico.

1import os
2import time
3
4import machine
5
6ldr = machine.ADC(26)                 # GP26 = ADC0, LDR + 10k bölücü / LDR + 10k divider
7ic_sensor = machine.ADC(4)            # yongadaki sıcaklık sensörü / on-chip temperature sensor
8DOSYA = "olcum.csv"
9ARALIK_S = 10                         # ölçüm aralığı, saniye / interval in seconds
10
11
12def tr(x):
13    return "{:.1f}".format(x).replace(".", ",")   # Türkçe Excel için ondalık virgül / decimal comma for Turkish Excel
14
15
16try:
17    os.stat(DOSYA)                    # dosya varsa silme, sonuna ekle / keep an existing file, append to it
18except OSError:
19    with open(DOSYA, "w") as f:
20        f.write("Sure (s);Sicaklik (C);Isik (%)\n")   # ASCII başlık / ASCII header
21
22baslangic = time.ticks_ms()
23while True:
24    volt = ic_sensor.read_u16() * 3.3 / 65535
25    sicaklik = 27 - (volt - 0.706) / 0.001721       # RP2040 veri sayfası formülü / RP2040 datasheet formula
26    isik = ldr.read_u16() * 100 / 65535             # göreli ışık, % / relative light, %
27    sure = time.ticks_diff(time.ticks_ms(), baslangic) / 1000
28    satir = "{};{};{}".format(tr(sure), tr(sicaklik), tr(isik))
29    print(satir)                                    # Thonny kabuğunda da görünür / also shown in the Thonny shell
30    with open(DOSYA, "a") as f:                     # her satırda aç-kapat / open and close for every line
31        f.write(satir + "\n")                       # elektrik kesilse de veri kalır / data survives a power cut
32    time.sleep(ARALIK_S)

Si guardas el código en la Pico desde Thonny con el nombre main.py, la placa empieza a registrar sola cada vez que se enciende; si el archivo ya existe no se borra, y las líneas nuevas se añaden al final. Cuando termine la medida, conecta la Pico al ordenador, pulsa Stop en Thonny, haz clic derecho en olcum.csv en el panel Ver > Archivos, descárgalo a tu ordenador y ábrelo en Excel. Con una línea de unos 20 bytes cada 10 segundos, el archivo crece unos 170 KB al día; en el sistema de archivos de la Pico eso deja sitio de sobra para varios días de registro. Si tu Excel usa punto decimal, basta con quitar la llamada a replace() de la función tr().

Errores frecuentes y cómo solucionarlos

Ideas de proyectos con registro de datos en Excel

• Curva de enfriamiento: mide cómo se enfría un vaso de agua caliente con un DS18B20 sumergible, añade una línea de tendencia exponencial en Excel y estudia la ley de enfriamiento de Newton.
• Mini estación meteorológica: registra la temperatura, la humedad y la presión con un BME280 durante una semana y representa en un gráfico la diferencia entre el día y la noche.
• Diario de riego: guarda el valor del sensor de humedad del suelo antes y después de regar y averigua cuánto tarda la tierra en secarse.
• Análisis de movimiento: construye una tabla distancia-tiempo con un HC-SR04 y calcula en Excel la velocidad y la aceleración a partir de las diferencias entre filas consecutivas.
• Curva de descarga de una pila: mide la tensión de una pila con un divisor de tensión, regístrala durante horas y estudia cómo baja con el tiempo.
• Proyecto para la feria de ciencias: compara cuánto se calientan al sol cajas de distintos colores; para más ideas consulta la guía de ideas de proyectos con Arduino para ferias de ciencias.

Elijas el método que elijas, la base es la misma: genera en el Arduino líneas CSV limpias y coherentes y llévalas a Excel en el ordenador con el separador correcto. Para una comprobación rápida, lo mejor es el monitor serie; para una demostración en directo en clase, Data Streamer; para controlar Excel desde el Arduino, PLX-DAQ; y para registros largos y automáticos, Python. En la app BlueGrays encontrarás proyectos como la medida de temperatura y humedad con el DHT11, la lectura de la intensidad de luz con una LDR y un registrador de temperatura con ESP32, paso a paso con esquemas y código, y podrás enviar a Excel los datos que midas con estos métodos.