La librería de Arduino

En la placa, tu sketch usa la librería Transparent. La app de escritorio de Undercromo la instala en tu Arduino IDE al arrancar; en tu sketch solo la incluyes:

#include <Transparent.h>

Serial o WiFi: lo único que cambia es el constructor

Transparent funciona sobre tres conexiones, pero el sketch es el mismo en todas; lo único que cambia es la línea del constructor:

Transparent tpt(Serial);   // USB directo, o bridge WiFi ESP8266 (el ESP8266 traduce WiFi↔UART serial)
Transparent tpt(27016);    // WiFi nativo, SOLO ESP32 (la placa abre un servidor TCP en ese puerto)

Conexión	Constructor	Placas
USB directo / bridge ESP8266	Transparent tpt(Serial)	Arduino y ESP32
WiFi nativo	Transparent tpt(27016) (el número es el puerto)	Solo ESP32

Misma API en ambos

Todo lo demás es idéntico sin importar la conexión: TPT_VAR(...), begin(), update(), every(), after() e isConnected() se usan igual. No hay métodos exclusivos de serial ni de WiFi. Si cambias de USB a WiFi, solo cambias esa primera línea (y conectas el WiFi en setup()); el resto del sketch no se toca.

Declarar variables: TPT_VAR

Declaras tus variables normales de C++ y las registras en setup() con la macro TPT_VAR, indicando la dirección (ver Introducción):

float temperatura = 0;    // la placa reporta
bool  ledDeseado = false; // la plataforma manda
int   objetivo = 22;      // ambos lados

void setup() {
  Serial.begin(115200);
  TPT_VAR(tpt, temperatura, DEVICE_TO_GATEWAY);
  TPT_VAR(tpt, ledDeseado,  GATEWAY_TO_DEVICE);
  TPT_VAR(tpt, objetivo,    BIDIRECTIONAL);
  tpt.begin();
}

• TPT_VAR(tpt, variable, dirección) — registra una variable ya declarada. Valida en tiempo de compilación que el tipo esté soportado (ver Tipos de datos) y que el nombre no pase de 32 caracteres.
• A partir de ahí no llamas a “enviar”: editas la variable en tu código y la librería la reporta según su cadencia; las variables g2d/bi las escribe la plataforma y la librería las aplica sola.

El ciclo de vida (igual en serial y WiFi)

Dos llamadas sostienen todo:

Transparent tpt(Serial); // (o tpt(27016) para WiFi)

void setup() {
  Serial.begin(115200);
  // En WiFi: aquí también conectas a la red (WiFi.begin(...)) antes de tpt.begin().
  // ...registra tus variables con TPT_VAR...
  tpt.begin();   // inicializa la conexión. Llámalo UNA vez, al final del setup().
}

void loop() {
  tpt.update();  // imprescindible en CADA vuelta: sincroniza variables y corre timers.
}

• tpt.begin() — una sola vez en setup(), después de registrar las variables. En WiFi imprime en el monitor serial la IP y el puerto de la placa (los copias al config del thing). El apretón de manos y el chequeo de salud los hace la librería.
• tpt.update() — en cada vuelta del loop(). Es el motor: sin él no se sincroniza nada y no corren los timers. (Reemplaza al antiguo loop() de la librería.)
• tpt.isConnected() — true si la plataforma está conectada (en WiFi, si hay un cliente activo).

Tiempos: hacer cosas a su debido momento (sin delay)

Regla base: no uses delay(). delay(1000) congela el loop() un segundo entero, y durante ese segundo no se llama a tpt.update() — no se sincroniza nada. Para repetir o diferir acciones (que no sean el sync de variables, que ya es automático) tienes dos timers de utilidad:

void avisarListo() {
  estado = "listo";          // editas una variable; la librería la reporta
}

void setup() {
  Serial.begin(115200);
  // ...TPT_VAR...
  tpt.begin();
  tpt.every(2000, latido);   // repite cada 2000 ms
  tpt.after(500, avisarListo); // corre UNA vez, 500 ms tras el boot
}

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

• every repite indefinidamente; after corre una sola vez. En ambos, la función no recibe argumentos.
• El ritmo con el que se reportan tus variables d2g/bi lo controlas desde el thing con setRate (ver boardCode), no con estos timers. every/after son para lógica auxiliar de tu sketch.

Cuántos timers puedes tener

every y after comparten un cupo de 8 timers en total (8 entre los dos).

• Regístralos una sola vez, en setup(). Un noveno se ignora en silencio y los espacios no se liberan, así que no llames a every/after una y otra vez dentro del loop().
• ¿Necesitas más de 8? Súbelo antes del #include: #define TPT_MAX_TIMERS 16.

WiFi: el puerto y varias placas (solo ESP32)

Con Transparent tpt(puerto), tu placa es un pequeño servidor en su propia IP. La plataforma se conecta a esa IP:puerto (que copias al config del thing tras subir el sketch). El puerto lo eliges tú en el constructor. Puedes tener varias placas WiFi en el mismo gateway: cada una está en su propia IP, así que no chocan aunque usen el mismo puerto.

ESP32-S3 por USB nativo (CDC)

Para usar el puerto USB nativo del ESP32-S3:

• Activa “USB CDC On Boot: Enabled” en las opciones de la placa (Tools).
• Conecta al puerto USB nativo del S3 (no al bridge UART).
• El constructor es Transparent tpt(Serial) (igual que en Arduino).

Ajustes avanzados (y cuándo cambiarlos)

Se redefinen antes del #include:

#define TPT_MAX_TIMERS 12         // por defecto 8
#define TPT_MAX_VARIABLES 12      // por defecto 8
#define TPT_MAX_STRING_VARIABLES 3 // por defecto 2
#include <Transparent.h>

• TPT_MAX_TIMERS (8): más timers every/after a la vez.
• TPT_MAX_VARIABLES (8): máximo de variables registrables con TPT_VAR.
• TPT_MAX_STRING_VARIABLES (2): máximo de variables de tipo String (cada una reserva memoria fija para comparar cambios).

Memoria en placas pequeñas

En placas con poca RAM (Uno/Nano) subir estos límites consume memoria. Súbelos solo si los necesitas y prueba que el sketch siga estable.

Sigue con la API del MCU.