📡 Telemetría y registro de datos

// Tres curvas en Serial Plotter de Arduino IDE 2.x (ESP32, paquete esp32 3.x)
const int PINO_SENSOR = 34;   // potenciómetro o 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% del valor nuevo, 90% del anterior
  if (millis() - tPlot >= 20) {                // 50 líneas por segundo: Plotter puede seguir el ritmo
    tPlot = millis();
    Serial.printf("pot:%d,filtrado:%.0f,alvo:%d\n", cru, filtrado, ALVO);
  }
}

// Registro CSV en tarjeta microSD (ESP32, paquete 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 estándar)
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 no encontrado: comprueba los cables y FAT32"); while (true) delay(1000); }
  for (int i = 1; i < 1000; i++) {                       // primer nombre libre
    snprintf(nome, sizeof nome, "/log%03d.csv", i);   // la barra inicial es obligatoria
    if (!SD.exists(nome)) break;
  }
  arq = SD.open(nome, FILE_WRITE);
  arq.println("t_ms,sensor,filtrado");                 // encabezado, una vez
  Serial.printf("Grabando en %s (BOOT finaliza)\n", nome);
}
void loop() {
  if (!gravando) return;
  if (millis() - tLog >= 20) {                            // 50 líneas 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();                    // realmente escribe cada 0,5 s
  }
  if (digitalRead(BOTAO) == LOW) {                          // finalizar antes de retirar la tarjeta
    arq.close(); gravando = false;
    Serial.printf("Archivo cerrado: %lu líneas. Puedes retirar la tarjeta.\n", linhas);
  }
}

# Broker para la red de casa o de la escuela (Mosquitto 2.x)
listener 1883
listener 9001
protocol websockets
# sin contraseña: solo en una red local de confianza; si está expuesto a Internet, configura usuario y contraseña
allow_anonymous true

sudo apt install mosquitto mosquitto-clients
sudo nano /etc/mosquitto/conf.d/robo.conf      # pega el bloque de arriba y guarda
sudo systemctl restart mosquitto
mosquitto_sub -h localhost -t 'robo/#' -v         # muestra todo lo que publica el robot
mosquitto_pub -h localhost -t robo/comando -m parar   # en otra terminal: envía un comando

// Telemetría por MQTT (ESP32, paquete esp32 3.x + biblioteca PubSubClient)
#include <WiFi.h>
#include <PubSubClient.h>
const char *WIFI_NOME  = "<seu_wifi>";       // en Wokwi: "Wokwi-GUEST" con contraseña ""
const char *WIFI_SENHA = "<sua_senha>";
const char *BROKER     = "<ip_do_seu_pc>";    // prueba rápida: "test.mosquitto.org" (público: cualquiera puede leer)
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) {   // los comandos llegan aquí
  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 solo en setup
  Serial.printf("\nWi-Fi listo: %s\n", WiFi.localIP().toString().c_str());
  mqtt.setServer(BROKER, 1883);
  mqtt.setCallback(aoReceber);
}
void loop() {
  if (!mqtt.connected() && millis() - tTentativa > 2000) {    // se reconecta sin bloquear el robot
    tTentativa = millis();
    if (mqtt.connect("robo-inema-01")) { mqtt.subscribe("robo/comando"); Serial.println("MQTT conectado"); }
  }
  mqtt.loop();                                                 // envía y recibe; llama en cada vuelta
  if (mqtt.connected() && millis() - tPub >= 200) {           // 5 mensajes por segundo
    tPub = millis();
    char json[96];                                             // breve: el búfer predeterminado es 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>Panel del robot</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>Robot: <span id="estado">desconectado</span></h1>
<p>sensor: <b id="sensor">-</b> · Wi-Fi: <b id="rssi">-</b> dBm · detenido: <b id="parado">-</b></p>
<canvas id="g" width="600" height="200" style="background:#000;max-width:100%"></canvas>
<p><button onclick="cmd('parar')">Detener</button> <button onclick="cmd('andar')">Avanzar</button></p>
<script>
const cli = mqtt.connect('ws://localhost:9001');   // en otro dispositivo: 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 ? 'sí' : 'no';
  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: resumen y gráfico de un registro CSV del robot
# Uso: python analisa_log.py log001.csv [columna1 columna2 ...]
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="#")                    # las filas con # son anotaciones
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 el inicio
dt = df["t_ms"].diff()                                       # intervalo entre filas

print(f"{len(df)} filas, {df['t_s'].iloc[-1]:.1f} s registrados")
print(f"intervalo: promedio {dt.mean():.1f} ms, máximo {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("tiempo (s)"); a2.grid(alpha=0.3)
plt.tight_layout()
plt.savefig(arquivo.replace(".csv", ".png"), dpi=120)
plt.show()