Dados do Arduino no Excel: Data Streamer, PLX-DAQ, CSV e Python

Levar dados do Arduino para o Excel significa enviar os valores que o Arduino lê dos sensores para o computador pelo cabo USB e reuni-los linha por linha em uma planilha. O Arduino escreve cada leitura na porta serial como uma única linha separada por vírgulas; no computador, há quatro jeitos comuns de trazer essas linhas para o Excel: salvar a saída do Monitor Serial como arquivo CSV, o suplemento Data Streamer da Microsoft, a macro PLX-DAQ e o registro automático com Python. A ideia é a mesma em todos os casos: cada linha que o Arduino envia vira uma linha no Excel, e cada vírgula começa uma nova coluna.

Neste guia usamos como exemplo um sensor de temperatura e umidade DHT11 e um sensor de luz LDR. Primeiro comparamos os quatro métodos para você escolher o certo, depois configuramos cada um passo a passo. Em seguida, você vai ver como adicionar marcação de data e hora às leituras, como escolher o tipo de gráfico certo no Excel e como montar uma tabela de dados para relatório de experimento que você pode usar na escola ou em uma feira de ciências. As últimas seções mostram como fazer o mesmo com um ESP32 e um Raspberry Pi Pico, e como resolver os erros mais comuns.

Como funciona o envio de dados do Arduino para o Excel?

O Arduino não consegue escrever diretamente no Excel; ele só envia texto para a porta serial com Serial.print(). O computador acessa essa porta por um nome como COM3 no Windows, /dev/cu.usbmodem… no macOS ou /dev/ttyACM0 no Linux. A linguagem comum entre o Excel e o Arduino é o CSV (Comma Separated Values, valores separados por vírgula): uma linha como 12.0,23.0,45,78 é dividida em quatro colunas. Então seu sketch só precisa seguir duas regras: sempre colocar o mesmo separador entre os valores e terminar cada leitura com Serial.println(). Os fundamentos da porta serial estão em detalhes no guia Monitor Serial do Arduino.

Circuito de exemplo: ligando o DHT11 e o LDR

O circuito de exemplo tem dois sensores. O DHT11 mede temperatura com resolução de 1 °C e umidade com resolução de 1%; sua precisão é de cerca de ±2 °C e ±5% de umidade relativa, e ele precisa de apenas um pino de dados. O LDR é um fotorresistor cuja resistência cai conforme a luz aumenta; você monta um divisor de tensão com um resistor de 10 kΩ e liga o ponto do meio a um pino analógico. Com a ligação abaixo, o valor analógico sobe quando a luz fica mais forte. O número que um LDR fornece não está em lux, mas é um nível de luz relativo, então o honesto é chamá-lo de “luz (%)” no relatório. Se você precisa de valores reais em lux, use um sensor de luz calibrado como o BH1750.

Código Arduino: enviando as leituras como linhas 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}

O sketch usa a biblioteca DHT sensor library da Adafruit; ao instalá-la pelo Gerenciador de Bibliotecas, aceite instalar também a dependência Adafruit Unified Sensor. As leituras são feitas a cada 2 segundos e cronometradas com millis() em vez de delay(), então o loop() nunca fica bloqueado (detalhes no guia millis e delay). Cada linha contém as colunas tempo, temperatura, umidade e luz, nessa ordem. Serial.print(sicaklik, 1) imprime o número com uma casa decimal e sempre com ponto. Se o sensor não puder ser lido, o sketch imprime “HATA” (erro, em turco) no lugar do número, para você identificar e filtrar a linha com problema na tabela na hora. A linha de cabeçalho no setup() é útil para os métodos do Monitor Serial e do Python; você pode apagá-la se for usar o Data Streamer. Para leituras que mudam devagar, como a temperatura do ambiente, defina ARALIK (intervalo) como 60000 para fazer uma leitura por minuto.

Método 1: salvando a saída do Monitor Serial como CSV

1. Carregue o sketch, abra Ferramentas > Monitor Serial e escolha 9600 baud no menu de velocidade.
2. Se quiser, ative a marcação de data e hora: clique no ícone de relógio no canto superior direito da janela na Arduino IDE 2, ou na caixa de marcação de data e hora na parte de baixo na IDE 1.8. A hora do computador é adicionada no início de cada linha no formato 14:03:21.512 ->.
3. Quando o experimento terminar, selecione as linhas com o mouse e copie com Ctrl+C (Cmd+C no macOS). Se quiser guardar os dados brutos, cole no Bloco de Notas e salve como olcum.csv com o tipo de arquivo definido como Todos os Arquivos.
4. No Excel, clique na célula A1 de uma planilha vazia e cole com Ctrl+V; todas as linhas vão parar na coluna A.
5. Com a coluna A selecionada, abra Dados > Texto para Colunas, escolha Delimitado e marque Vírgula como delimitador. Se a marcação de data e hora estiver ativa, marque também Espaço: a hora vai para a primeira coluna e as marcas “->” para a segunda, que você apaga depois.
6. Na última etapa, clique em Avançado e defina o separador decimal como ponto; assim, valores como 23.5 são reconhecidos como números mesmo que o seu Excel use vírgula para decimais. Clique em Concluir e salve o arquivo como .xlsx.

Esse método é muito prático para até algumas centenas de linhas; com milhares de linhas, selecionar fica difícil e a janela da IDE fica lenta. Para gravações que duram horas, programas de terminal como o PuTTY (Session > Logging > All session output) ou o CoolTerm, que roda no Windows, macOS e Linux (Connection > Capture to Text/Binary File), gravam cada linha recebida direto em um arquivo. Você leva esse arquivo para o Excel com os mesmos passos. Lembre-se: enquanto um programa de terminal ou o Monitor Serial estiver usando a porta, os suplementos do Excel e o Python não conseguem se conectar a ela.

Método 2: dados ao vivo com o Excel Data Streamer

O Data Streamer é um suplemento gratuito que a Microsoft criou para a educação; ele transmite linhas CSV da porta serial direto para uma planilha. Ele vem com o Excel para desktop do Microsoft 365 (versão 1902 e posteriores), então você só precisa ativá-lo. Por ser um suplemento COM, funciona somente no Windows; não está disponível no Excel para macOS nem no Excel no navegador. Você não precisa mudar nada no lado do Arduino: o sketch acima funciona como está a 9600 baud, a velocidade padrão do suplemento.

1. No Excel, abra Arquivo > Opções > Suplementos, escolha Suplementos de COM na lista Gerenciar, na parte de baixo, e clique em Ir.
2. Marque Microsoft Data Streamer for Excel e clique em OK; a guia Data Streamer aparece na faixa de opções.
3. Feche o Monitor Serial na Arduino IDE; uma porta serial só pode ser aberta por um programa de cada vez.
4. Escolha a porta COM do Arduino no botão Connect a Device e depois clique em Start Data. Dependendo do idioma do Excel, os nomes dos botões podem aparecer traduzidos.
5. O Excel cria três planilhas: Data In (dados recebidos), Data Out (dados para enviar ao Arduino) e Settings (configurações). Na planilha Settings, defina Data Channels como 4 e aumente Data Rows para ver mais histórico na tabela.
6. Para manter um registro permanente, comece a gravar com Record Data; quando você parar com Stop Recording, as leituras são salvas em um arquivo CSV. Você pode reproduzir esse arquivo depois com Import Data File.

A parte de cima da planilha Data In mostra os valores mais recentes (Current Data) e, abaixo deles, há uma tabela onde as leituras anteriores vão passando (Historical Data). Se você selecionar essa tabela e adicionar um gráfico de linhas ou de dispersão em Inserir > Gráficos Recomendados, o gráfico se atualiza sozinho a cada nova leitura; é ideal para mostrar à turma como a curva de luz cai no instante em que você coloca a mão sobre o sensor. Na planilha Settings, Data Interval (ms) define com que frequência a planilha é atualizada, e Data Orientation decide se os dados mais novos aparecem no topo ou no fim da tabela. Os valores que você digita na planilha Data Out também são enviados ao Arduino como uma linha CSV; o Arduino pode lê-los com Serial.parseInt(), então você poderia, por exemplo, definir um limite de alarme pelo Excel.

Método 3: escrevendo no Excel linha por linha com a macro PLX-DAQ

O PLX-DAQ (Parallax Data Acquisition) é uma macro VBA que roda dentro do Excel e transforma comandos especiais que chegam pela porta serial em células do Excel. Como a versão original da Parallax só funciona no Excel de 32 bits, hoje se usa o PLX-DAQ v2, desenvolvido pela comunidade Arduino; ele é compatível com o Excel de 64 bits e vem como um único arquivo .xlsm. Como a macro depende da API do Windows, ela também roda só no Windows. A diferença em relação ao Data Streamer é que o Arduino é quem comanda o Excel: ele escreve os cabeçalhos, limpa a planilha e faz o Excel adicionar a data e a 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. Baixe o arquivo do PLX-DAQ v2 e extraia do zip. Clique com o botão direito no arquivo .xlsm e marque Desbloquear em Propriedades; por padrão, o Office bloqueia macros em arquivos vindos da internet.
2. Abra o arquivo e clique em Habilitar Conteúdo na barra amarela no topo.
3. Feche o Monitor Serial na Arduino IDE e clique no botão Open PLX DAQ UI na planilha.
4. Na janela que abrir, digite só o número da COM na caixa Port (5 para COM5), escolha 9600 como Baud e clique em Connect.
5. Se nenhum cabeçalho aparecer, aperte o botão reset do Arduino: o setup() roda de novo, os comandos CLEARDATA e LABEL chegam ao Excel e as linhas começam a entrar.
6. Quando terminar, clique em Disconnect e, se quiser, salve os dados como um arquivo .xlsx separado.

Método 4: arquivos CSV e Excel automáticos com Python

Se você usa Mac ou Linux, pretende registrar por horas ou cansou de montar o relatório na mão toda vez, o Python é a opção mais flexível. Primeiro instale os dois pacotes em um terminal com python -m pip install pyserial openpyxl. O primeiro script abaixo escuta o Arduino e grava cada leitura, junto com a hora do computador, no arquivo deney_olcumleri.csv. Assuntos como encontrar a porta, o reset automático e o gráfico ao vivo estão explicados em detalhes no guia comunicação serial entre Arduino e 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)

Três detalhes do script garantem a compatibilidade com o Excel. A codificação utf-8-sig adiciona um BOM invisível no início do arquivo; sem ele, o Excel mostra caracteres como “°C” ou letras acentuadas embaralhados. As constantes AYIRICI (separador) e ONDALIK (decimal) estão definidas como ponto e vírgula e vírgula decimal, o formato que o Excel espera com as configurações regionais do Brasil e da maior parte da Europa continental; com configurações dos EUA ou do Reino Unido, basta trocá-las por vírgula e ponto. f.flush() grava cada linha no disco na hora, então, se o computador desligar ou o cabo se soltar, você perde no máximo a última leitura. Depois de parar o script com Ctrl+C, é só dar dois cliques no arquivo e as colunas abrem corretamente separadas. Se quiser olhar o arquivo enquanto o registro ainda está rodando, abra uma cópia, porque o Excel pode bloquear os arquivos 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)

O segundo script converte o CSV em um arquivo .xlsx de verdade. Dentro de um .xlsx, os números são armazenados como números, e não como texto, então o problema de separador e decimal desaparece por completo; o arquivo abre do mesmo jeito no Excel em inglês, alemão ou turco. O script também adiciona uma tabela de resumo com média, mínimo, máximo e desvio padrão, além de dois gráficos de dispersão para temperatura e luz. As fórmulas são gravadas no arquivo com os nomes em inglês (AVERAGE, MIN, MAX, STDEV), e o Excel as traduz para o próprio idioma ao abrir o arquivo; no Excel em português, você vê MÉDIA, MÍNIMO, MÁXIMO e DESVPAD. As linhas delete = False evitam um problema em que os rótulos dos eixos não aparecem em gráficos criados com versões recentes do openpyxl.

Adicionando marcação de data e hora: millis(), relógio do computador ou RTC

Para experimentos ligados a um computador, o relógio do computador é a escolha mais fácil, e nosso script Python o grava em todas as linhas. Guardar também o tempo decorrido enviado pelo Arduino é um bom hábito: ele mostra o intervalo real entre as leituras, e você percebe na hora se uma linha sumiu. Se você enviar o valor bruto de millis() pelo Arduino, pode convertê-lo para segundos no Excel com =B2/1000, ou para minutos com =B2/60000. Se o Arduino for trabalhar sem computador, por exemplo gravando em um cartão SD, pegue a data e a hora de um módulo de relógio RTC; os detalhes de gravar CSV em um cartão SD estão no guia módulo de cartão SD. Com um ESP32, você também pode buscar a hora na internet: hora NTP com o ESP32.

Criando um gráfico no Excel

1. Selecione as colunas de tempo e temperatura junto com os cabeçalhos; se as colunas não estiverem lado a lado, mantenha Ctrl pressionado ao selecionar a segunda.
2. Escolha um tipo de dispersão com linhas em Inserir > Gráficos > Dispersão (X, Y).
3. Use o botão + ao lado do gráfico para ativar Títulos dos Eixos e dê nome aos eixos com as unidades: “Tempo (s)” e “Temperatura (°C)”.
4. Para adicionar a série de luz, clique com o botão direito no gráfico e adicione a coluna de luz em Selecionar Dados > Adicionar; como as escalas são muito diferentes, clique com o botão direito na série e escolha Formatar Série de Dados > Eixo Secundário.
5. Clique com o botão direito no eixo vertical e fixe os valores mínimo e máximo em Formatar Eixo, para que uma variação de 1 °C não pareça uma oscilação enorme.

Por que um gráfico de dispersão em vez de um gráfico de linhas? O gráfico de Linhas do Excel trata os valores do eixo horizontal como rótulos igualmente espaçados; se faltar uma leitura ou você mudar o intervalo, o eixo do tempo fica distorcido sem nenhum aviso. Um gráfico de Dispersão (X, Y) coloca cada ponto no seu tempo real, que é o que se espera de um gráfico científico. Se você só está comparando alguns valores fixos, como a temperatura média em três cômodos diferentes, um gráfico de colunas é mais fácil de ler. Se o sensor for ruidoso, clique com o botão direito na série e suavize a curva com Adicionar Linha de Tendência > Média Móvel.

Exemplo para relatório de experimento: uma tabela de medições

Digamos que a pergunta do seu experimento seja: “Como a temperatura, a umidade e o nível de luz do ar perto de uma luminária de mesa mudam quando ela é ligada?” Colocamos os sensores a cerca de 15 cm da luminária e definimos ARALIK no sketch como 60000, ou seja, uma leitura por minuto. Ligamos a luminária no minuto 1 e desligamos no minuto 6. Os valores abaixo são valores de exemplo típicos que você poderia obter com essa montagem; as duas últimas linhas são resumos calculados com fórmulas do Excel:

Você calcula as linhas de resumo no Excel com =MÉDIA(B2:B10), =MÍNIMO(B2:B10) e =MÁXIMO(B2:B10); para mostrar o quanto as leituras estão espalhadas, você também pode adicionar =DESVPAD(B2:B10). Ao interpretar os resultados, descreva o padrão da tabela: a luz saltou de 14% para 81% no momento em que a luminária acendeu, enquanto a temperatura subiu devagar, 3 °C em cerca de 3 minutos; isso se chama inércia térmica. Quando a luminária apagou, a luz caiu na hora, mas a temperatura continuou alta por mais alguns minutos. A umidade relativa caiu conforme a temperatura subiu, porque o ar mais quente consegue reter mais umidade mesmo que a quantidade de água nele continue a mesma. Uma lâmpada incandescente ou halógena mostra esse efeito com clareza; com uma lâmpada de LED, o aumento de temperatura é bem menor.

• Objetivo: sua pergunta de pesquisa e sua hipótese em uma frase.
• Materiais: o modelo da placa, os sensores, os resistores e os softwares que você usou (Arduino IDE, Excel).
• Método: onde os sensores foram colocados, o intervalo de medição (por exemplo, 60 s), quanto tempo durou o experimento e qual método você usou para levar os dados ao Excel.
• Tabela de dados: todo cabeçalho de coluna deve incluir a unidade; use a tabela de resumo no texto e anexe os dados brutos completos como apêndice.
• Gráfico: um gráfico de dispersão com títulos dos eixos, unidades e os eventos marcados (luminária ligada, desligada).
• Conclusão e fontes de erro: compare seus resultados com a hipótese e liste limitações como a precisão de ±2 °C do DHT11, o LDR não calibrado e a distância do sensor até a luminária.

Enviando dados do ESP32 para o Excel

Todos os métodos funcionam do mesmo jeito no ESP32; para o Data Streamer e o PLX-DAQ, o ESP32 é só mais uma porta serial. Três coisas mudam: as leituras analógicas são de 12 bits (0–4095), o divisor do LDR é alimentado com 3,3 V, e você deve escolher um dos pinos do ADC1 (GPIO 32–39) como entrada analógica, porque eles continuam funcionando com o Wi-Fi ligado. As placas ESP32 normalmente são usadas a 115200 baud, então mude a velocidade no script Python, no Data Streamer e no PLX-DAQ de acordo. As mensagens do bootloader que aparecem na porta serial na inicialização não são números, então o script Python já as ignora. Se você quiser enviar as leituras para a nuvem sem ligar nada a um computador, veja o guia registro de dados do ESP32 no Planilhas 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}

Registrando CSV com um Raspberry Pi Pico (MicroPython)

Se você usa MicroPython em um Raspberry Pi Pico, pode gravar as leituras em um arquivo CSV na própria memória flash da placa em vez de enviá-las a um computador; assim, você não precisa de computador nenhum e pode deixar o Pico, alimentado por um power bank, onde quiser medir. O código abaixo usa o sensor de temperatura integrado (ADC4), que não precisa de hardware extra, e um LDR ligado ao GP26, e grava o arquivo com ponto e vírgula e vírgula decimal, para combinar com o Excel em português e em formatos europeus. Como o sensor integrado mede a temperatura do chip, ele pode marcar alguns graus acima da temperatura ambiente; use um sensor externo para medições precisas. Se você está começando com MicroPython, comece pelo guia O que é o 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)

Se você salvar o código no Pico pelo Thonny como main.py, a placa começa a registrar sozinha toda vez que é ligada; se o arquivo já existir, ele não é apagado, e as novas linhas são adicionadas no final. Quando a medição terminar, ligue o Pico ao computador, clique em Parar (Stop) no Thonny, clique com o botão direito em olcum.csv no painel Exibir > Arquivos (View > Files), baixe-o para o computador e abra no Excel. Com uma linha de cerca de 20 bytes a cada 10 segundos, o arquivo cresce uns 170 KB por dia; no sistema de arquivos do Pico, isso deixa bastante espaço para vários dias de registro. Se o seu Excel usa ponto para decimais, remova a chamada replace() da função tr().

Erros comuns e como resolver

Ideias de projetos com registro de dados no Excel

• Curva de resfriamento: meça como um copo de água quente esfria com um DS18B20 à prova d'água, adicione uma linha de tendência exponencial no Excel e explore a lei de resfriamento de Newton.
• Miniestação meteorológica: registre temperatura, umidade e pressão com um BME280 durante uma semana e mostre em gráfico a diferença entre noite e dia.
• Diário de rega das plantas: registre o valor do sensor de umidade do solo antes e depois de regar e descubra quanto tempo o solo leva para secar.
• Análise de movimento: monte uma tabela distância-tempo com um HC-SR04 e calcule velocidade e aceleração no Excel a partir das diferenças entre linhas consecutivas.
• Curva de descarga da bateria: meça a tensão de uma bateria com um divisor de tensão, registre por horas e estude como a tensão cai ao longo do tempo.
• Projeto para feira de ciências: compare o quanto caixas de cores diferentes esquentam ao sol; para mais ideias, veja o guia projetos Arduino para feira de ciências.

Seja qual for o método escolhido, a base é a mesma: gere linhas CSV limpas e consistentes no Arduino e leve-as para o Excel com o separador certo no computador. O Monitor Serial é melhor para uma verificação rápida, o Data Streamer para uma demonstração ao vivo em sala de aula, o PLX-DAQ para controlar o Excel pelo Arduino e o Python para registros longos e automáticos. No app BlueGrays você encontra projetos como medição de temperatura e umidade com DHT11, leitura da intensidade da luz com LDR e um registrador de temperatura com ESP32, passo a passo com esquemas do circuito e código, e pode enviar os dados medidos para o Excel com esses métodos.