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

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).

Sigue con la API del MCU.