📡 Telemetria e registro de dados

// Três curvas no Serial Plotter da Arduino IDE 2.x (ESP32, pacote esp32 3.x)
const int PINO_SENSOR = 34;   // potenciômetro ou sensor IR analógico (ADC1)
const int ALVO = 2000;
float filtrado = 0;
unsigned long tPlot = 0;
void setup() { Serial.begin(115200); }
void loop() {
  int cru = analogRead(PINO_SENSOR);           // 0 a 4095
  filtrado = 0.9 * filtrado + 0.1 * cru;        // filtro exponencial: 10% do novo, 90% do antigo
  if (millis() - tPlot >= 20) {                // 50 linhas por segundo: o Plotter acompanha
    tPlot = millis();
    Serial.printf("pot:%d,filtrado:%.0f,alvo:%d\n", cru, filtrado, ALVO);
  }
}

// Log CSV no cartão microSD (ESP32, pacote esp32 3.x, módulo microSD por SPI)
#include <SPI.h>
#include <SD.h>
const int PINO_CS = 5, PINO_SENSOR = 34, BOTAO = 0;   // SCK 18, MISO 19, MOSI 23 (VSPI padrão)
File arq;
char nome[16];
unsigned long tLog = 0, linhas = 0;
float filtrado = 0;
bool gravando = true;
void setup() {
  Serial.begin(115200);
  pinMode(BOTAO, INPUT_PULLUP);
  if (!SD.begin(PINO_CS)) { Serial.println("SD nao encontrado: confira fios e FAT32"); while (true) delay(1000); }
  for (int i = 1; i < 1000; i++) {                       // primeiro nome livre
    snprintf(nome, sizeof nome, "/log%03d.csv", i);   // a barra inicial é obrigatória
    if (!SD.exists(nome)) break;
  }
  arq = SD.open(nome, FILE_WRITE);
  arq.println("t_ms,sensor,filtrado");                 // cabeçalho, uma vez
  Serial.printf("Gravando em %s (BOOT encerra)\n", nome);
}
void loop() {
  if (!gravando) return;
  if (millis() - tLog >= 20) {                            // 50 linhas por segundo
    tLog = millis();
    int cru = analogRead(PINO_SENSOR);
    filtrado = 0.9 * filtrado + 0.1 * cru;
    arq.printf("%lu,%d,%.1f\n", tLog, cru, filtrado);
    if (++linhas % 25 == 0) arq.flush();                    // grava de fato a cada 0,5 s
  }
  if (digitalRead(BOTAO) == LOW) {                          // encerrar antes de tirar o cartão
    arq.close(); gravando = false;
    Serial.printf("Arquivo fechado: %lu linhas. Pode tirar o cartao.\n", linhas);
  }
}

# Broker para a rede de casa ou da escola (Mosquitto 2.x)
listener 1883
listener 9001
protocol websockets
# sem senha: só em rede local de confiança; exposto na internet, configure usuário e senha
allow_anonymous true

sudo apt install mosquitto mosquitto-clients
sudo nano /etc/mosquitto/conf.d/robo.conf      # cole o bloco acima e salve
sudo systemctl restart mosquitto
mosquitto_sub -h localhost -t 'robo/#' -v         # mostra tudo que o robô publica
mosquitto_pub -h localhost -t robo/comando -m parar   # em outro terminal: manda um comando

// Telemetria por MQTT (ESP32, pacote esp32 3.x + biblioteca PubSubClient)
#include <WiFi.h>
#include <PubSubClient.h>
const char *WIFI_NOME  = "<seu_wifi>";       // no Wokwi: "Wokwi-GUEST" com senha ""
const char *WIFI_SENHA = "<sua_senha>";
const char *BROKER     = "<ip_do_seu_pc>";    // teste rápido: "test.mosquitto.org" (público: qualquer um lê)
const int PINO_SENSOR = 34, PINO_LED = 2;
WiFiClient wifi;
PubSubClient mqtt(wifi);
unsigned long tPub = 0, tTentativa = 0;
bool parado = false;
void aoReceber(char *topico, byte *dados, unsigned int n) {   // comandos chegam aqui
  String msg; for (unsigned int i = 0; i < n; i++) msg += (char)dados[i];
  if (msg == "parar") parado = true;
  if (msg == "andar") parado = false;
  digitalWrite(PINO_LED, parado);
  Serial.printf("comando: %s\n", msg.c_str());
}
void setup() {
  Serial.begin(115200);
  pinMode(PINO_LED, OUTPUT);
  WiFi.begin(WIFI_NOME, WIFI_SENHA);
  while (WiFi.status() != WL_CONNECTED) { delay(300); Serial.print("."); }   // espera só no setup
  Serial.printf("\nWi-Fi ok: %s\n", WiFi.localIP().toString().c_str());
  mqtt.setServer(BROKER, 1883);
  mqtt.setCallback(aoReceber);
}
void loop() {
  if (!mqtt.connected() && millis() - tTentativa > 2000) {    // reconecta sem travar o robô
    tTentativa = millis();
    if (mqtt.connect("robo-inema-01")) { mqtt.subscribe("robo/comando"); Serial.println("MQTT conectado"); }
  }
  mqtt.loop();                                                 // envia e recebe; chame em toda volta
  if (mqtt.connected() && millis() - tPub >= 200) {           // 5 mensagens por segundo
    tPub = millis();
    char json[96];                                             // curto: o buffer padrão é de 256 bytes
    snprintf(json, sizeof json, "{\"t\":%lu,\"sensor\":%d,\"rssi\":%d,\"parado\":%d}", tPub, analogRead(PINO_SENSOR), WiFi.RSSI(), parado);
    mqtt.publish("robo/telemetria", json);
  }
}

<!doctype html>
<html lang="pt-BR"><head><meta charset="utf-8"><title>Painel do robô</title>
<script src="https://unpkg.com/mqtt@5.10.1/dist/mqtt.min.js"></script></head>
<body style="font-family:sans-serif;background:#111;color:#eee;padding:16px">
<h1>Robô: <span id="estado">desconectado</span></h1>
<p>sensor: <b id="sensor">-</b> · Wi-Fi: <b id="rssi">-</b> dBm · parado: <b id="parado">-</b></p>
<canvas id="g" width="600" height="200" style="background:#000;max-width:100%"></canvas>
<p><button onclick="cmd('parar')">Parar</button> <button onclick="cmd('andar')">Andar</button></p>
<script>
const cli = mqtt.connect('ws://localhost:9001');   // em outro aparelho: ws://<ip_do_seu_pc>:9001
const pts = [], g = document.getElementById('g').getContext('2d');
const $ = id => document.getElementById(id);
cli.on('connect', () => { $('estado').textContent = 'conectado'; cli.subscribe('robo/telemetria'); });
cli.on('message', (topico, m) => {
  const d = JSON.parse(m.toString());
  $('sensor').textContent = d.sensor; $('rssi').textContent = d.rssi; $('parado').textContent = d.parado ? 'sim' : 'não';
  pts.push(d.sensor); if (pts.length > 120) pts.shift();
  g.clearRect(0, 0, 600, 200); g.strokeStyle = '#60a5fa'; g.lineWidth = 2; g.beginPath();
  pts.forEach((v, i) => g.lineTo(i * 5, 200 - v / 4095 * 200)); g.stroke();
});
function cmd(c) { cli.publish('robo/comando', c); }
</script></body></html>

# analisa_log.py: resumo e gráfico de um log CSV do robô
# Uso: python analisa_log.py log001.csv [coluna1 coluna2 ...]
import sys
import pandas as pd
import matplotlib.pyplot as plt

arquivo = sys.argv[1] if len(sys.argv) > 1 else "log001.csv"
df = pd.read_csv(arquivo, comment="#")                    # linhas com # são anotações
colunas = sys.argv[2:] or [c for c in df.columns if c != "t_ms"]
df["t_s"] = (df["t_ms"] - df["t_ms"].iloc[0]) / 1000      # segundos desde o início
dt = df["t_ms"].diff()                                       # intervalo entre linhas

print(f"{len(df)} linhas, {df['t_s'].iloc[-1]:.1f} s gravados")
print(f"intervalo: médio {dt.mean():.1f} ms, maior {dt.max():.0f} ms")
print(df[colunas].describe().round(1))

fig, (a1, a2) = plt.subplots(2, 1, sharex=True, figsize=(10, 6))
df.plot(x="t_s", y=colunas, ax=a1, title=arquivo)
a1.set_ylabel("valor"); a1.grid(alpha=0.3)
a2.plot(df["t_s"], dt, color="tab:red")
a2.set_ylabel("intervalo (ms)"); a2.set_xlabel("tempo (s)"); a2.grid(alpha=0.3)
plt.tight_layout()
plt.savefig(arquivo.replace(".csv", ".png"), dpi=120)
plt.show()