Protocolo Transparent

Con el protocolo Transparent, tú escribes y flasheas el sketch de la placa. La placa y la plataforma se comunican con mensajes de texto por canales (canal: valor). Es el camino cuando quieres tu propia lógica, tiempos ajustados o hardware que prefieres manejar tú.

Tiene dos lados:

1. El sketch de la placa, que usa la librería Arduino Transparent.
2. El boardCode en la plataforma, que usa el objeto tpt.

Lado placa: la librería Transparent

La app de escritorio instala la librería Transparent en tu sketchbook de Arduino. Un sketch mínimo:

#include <Transparent.h>

Transparent tpt(Serial);   // conexión por USB / bridge

void setup() {
  Serial.begin(115200);
  tpt.begin();             // llamar tras Serial.begin()
}

void loop() {
  tpt.loop();              // imprescindible: bombea el protocolo
}

La librería resuelve por ti el enlace con la plataforma (handshake y chequeo de salud). Tú solo envías y recibes canales.

Constructor según la conexión

Transparent tpt(Serial);   // USB directo o bridge ESP8266 (Arduino y ESP32)
Transparent tpt(27016);    // WiFi nativo: servidor TCP en ese puerto (solo ESP32)

Enviar datos

send(canal, valor) acepta números, booleanos y texto:

tpt.send("voltaje", analogRead(A0) * (5.0 / 1023.0)); // double
tpt.send("boton", digitalRead(2) == LOW);             // bool
tpt.send("uptime", millis());                          // unsigned long
tpt.send("estado", "ok");                              // texto

Para listas, sendArray envía un arreglo como canal:[a,b,c]:

int lecturas[3] = { 10, 20, 30 };
tpt.sendArray("lecturas", lecturas);

Sin enteros de 64 bits

send no tiene variante para 64 bits (long long, int64_t, p. ej. esp_timer_get_time()). Conviértelos a unsigned long o double antes de enviar.

Temporizadores

tpt.every(1000, enviarVoltaje);  // cada 1000 ms
tpt.after(5000, hacerUnaVez);    // una sola vez, a los 5 s

Recibir canales

if (tpt.available()) {                 // ¿llegó un canal nuevo?
  if (tpt.channel() == "led") {
    digitalWrite(13, tpt.payloadBool());
  }
}

Lecturas del último mensaje: channel(), payload() (texto), payloadInt(), payloadFloat(), payloadBool().

available() es de slot único

available() devuelve solo el último canal recibido entre llamadas a loop(). Si llegan varios en el mismo ciclo, los anteriores se pierden. Está pensado para estado y telemetría, no para colas de eventos.

Lado plataforma: el boardCode con tpt

En el editor web, tu boardCode recibe el objeto tpt para conversar con la placa. Reaccionas a los canales que la placa envía y le mandas canales de vuelta:

// Reaccionar a un canal que envía la placa
tpt.onChannel("voltaje", (value) => {
  varG.voltaje = value;          // último valor
  pushData("historialVoltaje", value); // historial
});

tpt.onChannel("boton", (value) => {
  varG.botonPresionado = value;  // boolean
});

// Enviar un canal a la placa
tpt.send("led", false);

API del tpt en boardCode: onChannel(canal, cb), onData(cb) (cualquier mensaje), send(canal, valor) y sendArray(canal, arreglo).

Ejemplos

Arduino Uno por USB

Envía un voltaje cada segundo y el estado de un botón; enciende un LED cuando la plataforma manda el canal led.

#include <Transparent.h>

Transparent tpt(Serial);
bool estadoAnterior = false;

void enviarVoltaje() {
  tpt.send("voltaje", analogRead(A0) * (5.0 / 1023.0));
}

void setup() {
  Serial.begin(115200);
  pinMode(2, INPUT_PULLUP);
  pinMode(13, OUTPUT);
  tpt.begin();
  tpt.every(1000, enviarVoltaje);
}

void loop() {
  tpt.loop();

  bool actual = !digitalRead(2);
  if (actual != estadoAnterior) {
    estadoAnterior = actual;
    tpt.send("boton", actual);
  }

  if (tpt.available() && tpt.channel() == "led") {
    digitalWrite(13, tpt.payloadBool());
  }
}

ESP32 por WiFi (100 Hz)

Levanta un servidor TCP y envía una muestra del ADC cada 10 ms. Tras subir el sketch, copia la IP:puerto que imprime el monitor serial en la configuración del thing (modo WiFi).

#include <WiFi.h>
#include <Transparent.h>

Transparent tpt(27016);

void enviarMuestra() {
  tpt.send("muestra", analogRead(34));
}

void setup() {
  Serial.begin(115200);
  WiFi.begin("TU_RED", "TU_CONTRASENA");
  while (WiFi.status() != WL_CONNECTED) delay(500);
  tpt.begin();                   // imprime IP:puerto
  tpt.every(10, enviarMuestra);  // 100 muestras/seg
}

void loop() {
  tpt.loop();
}

ESP32‑S3 por USB nativo (CDC)

Para usar el puerto USB nativo del S3, activa “USB CDC On Boot: Enabled” en las opciones de la placa del IDE de Arduino y conéctate al puerto USB nativo (no al bridge UART). El constructor es el mismo Transparent tpt(Serial).