IoT Architecture and Protocol Comparison

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <Adafruit_BME280.h>
#include <ArduinoJson.h>

/* ---- Configuration ---- */
const char* WIFI_SSID     = "YourSSID";
const char* WIFI_PASS     = "YourPassword";

/* Option A: Self-hosted Mosquitto (no TLS) */
const char* MQTT_SERVER   = "192.168.1.100";
const int   MQTT_PORT     = 1883;

/* Option B: SiliconWit.io (TLS on port 8883)
 * See siliconwit.io (Dashboard -> Devices) for connection details.
 * For TLS you need WiFiClientSecure instead of WiFiClient.
 */

const char* MQTT_USER     = "esp32";
const char* MQTT_PASS     = "changeme";
const char* MQTT_TOPIC    = "site/lab/bench1/esp32/bme280";
const char* DEVICE_ID     = "esp32-proto-bench";

/* ---- Objects ---- */
WiFiClient   wifiClient;
PubSubClient mqttClient(wifiClient);
Adafruit_BME280 bme;

/* ---- Wi-Fi connect ---- */
void wifi_connect() {
    Serial.printf("Connecting to %s", WIFI_SSID);
    WiFi.begin(WIFI_SSID, WIFI_PASS);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.printf("\nConnected, IP: %s\n", WiFi.localIP().toString().c_str());
}

/* ---- MQTT connect ---- */
void mqtt_connect() {
    mqttClient.setServer(MQTT_SERVER, MQTT_PORT);
    while (!mqttClient.connected()) {
        Serial.print("MQTT connecting...");
        if (mqttClient.connect(DEVICE_ID, MQTT_USER, MQTT_PASS)) {
            Serial.println("connected");
        } else {
            Serial.printf("failed, rc=%d, retrying in 2s\n", mqttClient.state());
            delay(2000);
        }
    }
}

/* ---- Build JSON payload ---- */
String build_payload(float temp, float hum, float pres) {
    JsonDocument doc;
    doc["device_id"]    = DEVICE_ID;
    doc["timestamp_ms"] = millis();
    doc["temperature_c"] = serialized(String(temp, 2));
    doc["humidity_pct"]  = serialized(String(hum, 2));
    doc["pressure_hpa"]  = serialized(String(pres, 2));

    String output;
    serializeJson(doc, output);
    return output;
}

/* ---- Send via MQTT and measure ---- */
void send_mqtt(float temp, float hum, float pres) {
    if (!mqttClient.connected()) {
        mqtt_connect();
    }
    mqttClient.loop();

    String payload = build_payload(temp, hum, pres);

    unsigned long start_us = micros();
    bool ok = mqttClient.publish(MQTT_TOPIC, payload.c_str());
    unsigned long elapsed_us = micros() - start_us;

    Serial.printf("[MQTT] %s | %d bytes | %lu us | %s\n",
                  ok ? "OK" : "FAIL",
                  payload.length(),
                  elapsed_us,
                  payload.c_str());
}

/* ---- Setup ---- */
void setup() {
    Serial.begin(115200);
    delay(1000);

    Wire.begin(21, 22);
    if (!bme.begin(0x76)) {
        Serial.println("BME280 not found, check wiring");
        while (1) delay(1000);
    }
    Serial.println("BME280 initialized");

    wifi_connect();
    mqtt_connect();
}

/* ---- Loop ---- */
void loop() {
    float temp = bme.readTemperature();
    float hum  = bme.readHumidity();
    float pres = bme.readPressure() / 100.0F;

    send_mqtt(temp, hum, pres);

    delay(10000);  /* Send every 10 seconds for testing */
}

#include <WiFiClientSecure.h>

/* Root CA for mqtt.siliconwit.io (replace with actual cert) */
const char* root_ca = R"EOF(
-----BEGIN CERTIFICATE-----
MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
... (paste the full certificate from siliconwit.io) ...
-----END CERTIFICATE-----
)EOF";

WiFiClientSecure secureClient;
PubSubClient mqttClient(secureClient);

void mqtt_connect_tls() {
    secureClient.setCACert(root_ca);
    mqttClient.setServer("mqtt.siliconwit.io", 8883);

    while (!mqttClient.connected()) {
        Serial.print("MQTT TLS connecting...");
        if (mqttClient.connect(DEVICE_ID, MQTT_USER, MQTT_PASS)) {
            Serial.println("connected with TLS");
        } else {
            Serial.printf("failed, rc=%d\n", mqttClient.state());
            delay(2000);
        }
    }
}

#include <WiFi.h>
#include <WiFiUdp.h>
#include <Wire.h>
#include <Adafruit_BME280.h>
#include <ArduinoJson.h>

/* ---- Configuration ---- */
const char* WIFI_SSID    = "YourSSID";
const char* WIFI_PASS    = "YourPassword";
const char* COAP_SERVER  = "192.168.1.100";
const int   COAP_PORT    = 5683;
const char* COAP_PATH    = "sensor/bme280";
const char* DEVICE_ID    = "esp32-proto-bench";

/* ---- Objects ---- */
WiFiUDP udp;
Adafruit_BME280 bme;

/* ---- CoAP message IDs ---- */
uint16_t coap_msg_id = 0;

/* ---- Build a minimal CoAP POST packet ---- */
/*
 * CoAP header (4 bytes):
 *   Ver=1, Type=CON(0), TKL=1, Code=POST(0.02)
 *   Message ID (2 bytes)
 * Token (1 byte)
 * Options:
 *   Uri-Path option (number 11)
 *   Content-Format option (number 12, value 50 = application/json)
 * Payload marker (0xFF) + payload
 */
int build_coap_post(uint8_t* buf, int buf_size,
                    const char* path, const uint8_t* payload, int payload_len) {
    int pos = 0;

    /* Header */
    buf[pos++] = 0x41;  /* Ver=1, Type=CON(0), TKL=1 */
    buf[pos++] = 0x02;  /* Code: 0.02 = POST */
    buf[pos++] = (coap_msg_id >> 8) & 0xFF;
    buf[pos++] = coap_msg_id & 0xFF;
    coap_msg_id++;

    /* Token (1 byte) */
    buf[pos++] = 0xAB;

    /* Uri-Path option (delta=11, length=strlen(path)) */
    /* Split path by '/' segments */
    char path_copy[64];
    strncpy(path_copy, path, sizeof(path_copy) - 1);
    path_copy[sizeof(path_copy) - 1] = '\0';

    int prev_option = 0;
    char* segment = strtok(path_copy, "/");
    while (segment != NULL) {
        int slen = strlen(segment);
        int delta = 11 - prev_option;
        prev_option = 11;

        if (delta < 13 && slen < 13) {
            buf[pos++] = (delta << 4) | slen;
        } else {
            /* Extended option encoding for longer paths */
            buf[pos++] = (delta << 4) | slen;
        }
        memcpy(&buf[pos], segment, slen);
        pos += slen;

        /* Subsequent Uri-Path options have delta=0 */
        segment = strtok(NULL, "/");
        if (segment != NULL) {
            prev_option = 11;  /* Same option number, delta=0 next time */
            int next_len = strlen(segment);
            buf[pos++] = (0 << 4) | next_len;  /* delta=0 */
            memcpy(&buf[pos], segment, next_len);
            pos += next_len;
            segment = strtok(NULL, "/");
        }
    }

    /* Content-Format option (delta = 12 - 11 = 1, value = 50) */
    buf[pos++] = (1 << 4) | 1;  /* delta=1, length=1 */
    buf[pos++] = 50;             /* application/json */

    /* Payload marker */
    buf[pos++] = 0xFF;

    /* Payload */
    if (pos + payload_len > buf_size) return -1;
    memcpy(&buf[pos], payload, payload_len);
    pos += payload_len;

    return pos;
}

/* ---- Build JSON payload ---- */
String build_payload(float temp, float hum, float pres) {
    JsonDocument doc;
    doc["device_id"]     = DEVICE_ID;
    doc["timestamp_ms"]  = millis();
    doc["temperature_c"] = serialized(String(temp, 2));
    doc["humidity_pct"]  = serialized(String(hum, 2));
    doc["pressure_hpa"]  = serialized(String(pres, 2));

    String output;
    serializeJson(doc, output);
    return output;
}

/* ---- Send via CoAP and measure ---- */
void send_coap(float temp, float hum, float pres) {
    String payload = build_payload(temp, hum, pres);

    uint8_t packet[512];
    int pkt_len = build_coap_post(packet, sizeof(packet),
                                   COAP_PATH,
                                   (const uint8_t*)payload.c_str(),
                                   payload.length());
    if (pkt_len < 0) {
        Serial.println("[CoAP] Packet too large");
        return;
    }

    unsigned long start_us = micros();

    udp.beginPacket(COAP_SERVER, COAP_PORT);
    udp.write(packet, pkt_len);
    udp.endPacket();

    /* Wait for ACK (up to 2 seconds) */
    bool ack_received = false;
    unsigned long timeout = millis() + 2000;
    while (millis() < timeout) {
        int reply_len = udp.parsePacket();
        if (reply_len > 0) {
            uint8_t reply[64];
            udp.read(reply, sizeof(reply));
            /* Check for ACK type (0x60 = Ver=1, Type=ACK, TKL=0) */
            if ((reply[0] & 0x30) == 0x20) {
                ack_received = true;
                break;
            }
        }
        delay(1);
    }

    unsigned long elapsed_us = micros() - start_us;

    Serial.printf("[CoAP] %s | %d bytes (packet: %d) | %lu us | %s\n",
                  ack_received ? "ACK" : "TIMEOUT",
                  payload.length(), pkt_len,
                  elapsed_us,
                  payload.c_str());
}

/* ---- Wi-Fi connect ---- */
void wifi_connect() {
    Serial.printf("Connecting to %s", WIFI_SSID);
    WiFi.begin(WIFI_SSID, WIFI_PASS);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.printf("\nConnected, IP: %s\n", WiFi.localIP().toString().c_str());
}

/* ---- Setup ---- */
void setup() {
    Serial.begin(115200);
    delay(1000);

    Wire.begin(21, 22);
    if (!bme.begin(0x76)) {
        Serial.println("BME280 not found, check wiring");
        while (1) delay(1000);
    }
    Serial.println("BME280 initialized");

    wifi_connect();
    udp.begin(COAP_PORT + 1);  /* Local port for receiving ACKs */
}

/* ---- Loop ---- */
void loop() {
    float temp = bme.readTemperature();
    float hum  = bme.readHumidity();
    float pres = bme.readPressure() / 100.0F;

    send_coap(temp, hum, pres);

    delay(10000);
}

import asyncio
import aiocoap
import aiocoap.resource as resource
import json
from datetime import datetime

class SensorResource(resource.Resource):
    """Handles POST requests with sensor data."""

    async def render_post(self, request):
        try:
            data = json.loads(request.payload.decode("utf-8"))
            ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
            print(f"[{ts}] CoAP POST from {data.get('device_id', 'unknown')}:")
            print(f"  Temperature: {data.get('temperature_c')} C")
            print(f"  Humidity:    {data.get('humidity_pct')} %")
            print(f"  Pressure:    {data.get('pressure_hpa')} hPa")
            print(f"  Payload size: {len(request.payload)} bytes")
            print()
        except json.JSONDecodeError:
            print(f"Invalid JSON: {request.payload}")

        return aiocoap.Message(
            code=aiocoap.CHANGED,
            payload=b'{"status":"ok"}'
        )

async def main():
    root = resource.Site()
    root.add_resource(["sensor", "bme280"], SensorResource())

    await aiocoap.Context.create_server_context(root, bind=("0.0.0.0", 5683))
    print("CoAP server listening on port 5683")
    await asyncio.get_event_loop().create_future()  # Run forever

if __name__ == "__main__":
    asyncio.run(main())

#include <WiFi.h>
#include <HTTPClient.h>
#include <Wire.h>
#include <Adafruit_BME280.h>
#include <ArduinoJson.h>

/* ---- Configuration ---- */
const char* WIFI_SSID   = "YourSSID";
const char* WIFI_PASS   = "YourPassword";
const char* HTTP_URL    = "http://192.168.1.100:8000/api/sensor";
const char* DEVICE_ID   = "esp32-proto-bench";

/* ---- Objects ---- */
Adafruit_BME280 bme;

/* ---- Build JSON payload ---- */
String build_payload(float temp, float hum, float pres) {
    JsonDocument doc;
    doc["device_id"]     = DEVICE_ID;
    doc["timestamp_ms"]  = millis();
    doc["temperature_c"] = serialized(String(temp, 2));
    doc["humidity_pct"]  = serialized(String(hum, 2));
    doc["pressure_hpa"]  = serialized(String(pres, 2));

    String output;
    serializeJson(doc, output);
    return output;
}

/* ---- Send via HTTP POST and measure ---- */
void send_http(float temp, float hum, float pres) {
    HTTPClient http;
    String payload = build_payload(temp, hum, pres);

    unsigned long start_us = micros();

    http.begin(HTTP_URL);
    http.addHeader("Content-Type", "application/json");

    int httpCode = http.POST(payload);
    String response = http.getString();

    unsigned long elapsed_us = micros() - start_us;

    Serial.printf("[HTTP] %d | %d bytes | %lu us | %s\n",
                  httpCode,
                  payload.length(),
                  elapsed_us,
                  payload.c_str());

    http.end();
}

/* ---- Wi-Fi connect ---- */
void wifi_connect() {
    Serial.printf("Connecting to %s", WIFI_SSID);
    WiFi.begin(WIFI_SSID, WIFI_PASS);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.printf("\nConnected, IP: %s\n", WiFi.localIP().toString().c_str());
}

/* ---- Setup ---- */
void setup() {
    Serial.begin(115200);
    delay(1000);

    Wire.begin(21, 22);
    if (!bme.begin(0x76)) {
        Serial.println("BME280 not found, check wiring");
        while (1) delay(1000);
    }
    Serial.println("BME280 initialized");

    wifi_connect();
}

/* ---- Loop ---- */
void loop() {
    float temp = bme.readTemperature();
    float hum  = bme.readHumidity();
    float pres = bme.readPressure() / 100.0F;

    send_http(temp, hum, pres);

    delay(10000);
}

from fastapi import FastAPI, Request
from datetime import datetime
import uvicorn

app = FastAPI()

@app.post("/api/sensor")
async def receive_sensor_data(request: Request):
    data = await request.json()
    ts = datetime.now().strftime("%H:%M:%S.%f")[:-3]
    print(f"[{ts}] HTTP POST from {data.get('device_id', 'unknown')}:")
    print(f"  Temperature: {data.get('temperature_c')} C")
    print(f"  Humidity:    {data.get('humidity_pct')} %")
    print(f"  Pressure:    {data.get('pressure_hpa')} hPa")
    content_length = request.headers.get("content-length", "unknown")
    print(f"  Content-Length: {content_length} bytes")
    print()
    return {"status": "ok"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

#include <WiFi.h>
#include <WiFiUdp.h>
#include <HTTPClient.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <Adafruit_BME280.h>
#include <ArduinoJson.h>

/* ---- Configuration ---- */
const char* WIFI_SSID     = "YourSSID";
const char* WIFI_PASS     = "YourPassword";
const char* DEVICE_ID     = "esp32-proto-bench";

/* MQTT */
const char* MQTT_SERVER   = "192.168.1.100";
const int   MQTT_PORT     = 1883;
const char* MQTT_USER     = "esp32";
const char* MQTT_PASS     = "changeme";
const char* MQTT_TOPIC    = "site/lab/bench1/esp32/bme280";

/* CoAP */
const char* COAP_SERVER   = "192.168.1.100";
const int   COAP_PORT     = 5683;
const char* COAP_PATH     = "sensor/bme280";

/* HTTP */
const char* HTTP_URL      = "http://192.168.1.100:8000/api/sensor";

/* ---- Objects ---- */
WiFiClient   wifiClient;
PubSubClient mqttClient(wifiClient);
WiFiUDP      udp;
Adafruit_BME280 bme;

/* ---- Timing results ---- */
struct BenchResult {
    const char* protocol;
    int payload_bytes;
    int wire_bytes;  /* Total bytes on the wire (estimated) */
    unsigned long rtt_us;
    bool success;
};

uint16_t coap_msg_id = 0;

/* ---- Build JSON payload ---- */
String build_payload(float temp, float hum, float pres) {
    JsonDocument doc;
    doc["device_id"]     = DEVICE_ID;
    doc["timestamp_ms"]  = millis();
    doc["temperature_c"] = serialized(String(temp, 2));
    doc["humidity_pct"]  = serialized(String(hum, 2));
    doc["pressure_hpa"]  = serialized(String(pres, 2));

    String output;
    serializeJson(doc, output);
    return output;
}

/* ---- MQTT bench ---- */
BenchResult bench_mqtt(const String& payload) {
    BenchResult r = {"MQTT", (int)payload.length(), 0, 0, false};

    if (!mqttClient.connected()) {
        mqttClient.setServer(MQTT_SERVER, MQTT_PORT);
        mqttClient.connect(DEVICE_ID, MQTT_USER, MQTT_PASS);
    }
    mqttClient.loop();

    /* MQTT overhead: 2-byte fixed header + topic length + 2 bytes topic len field */
    r.wire_bytes = 2 + 2 + strlen(MQTT_TOPIC) + payload.length();

    unsigned long start = micros();
    r.success = mqttClient.publish(MQTT_TOPIC, payload.c_str());
    r.rtt_us = micros() - start;

    return r;
}

/* ---- CoAP bench ---- */
BenchResult bench_coap(const String& payload) {
    BenchResult r = {"CoAP", (int)payload.length(), 0, 0, false};

    uint8_t packet[512];
    int pos = 0;

    /* CoAP header */
    packet[pos++] = 0x41;  /* CON, TKL=1 */
    packet[pos++] = 0x02;  /* POST */
    packet[pos++] = (coap_msg_id >> 8) & 0xFF;
    packet[pos++] = coap_msg_id & 0xFF;
    coap_msg_id++;
    packet[pos++] = 0xAB;  /* Token */

    /* Uri-Path: "sensor" (delta=11, len=6) */
    packet[pos++] = (11 << 4) | 6;
    memcpy(&packet[pos], "sensor", 6);
    pos += 6;

    /* Uri-Path: "bme280" (delta=0, len=6) */
    packet[pos++] = (0 << 4) | 6;
    memcpy(&packet[pos], "bme280", 6);
    pos += 6;

    /* Content-Format: application/json (delta=1, len=1, val=50) */
    packet[pos++] = (1 << 4) | 1;
    packet[pos++] = 50;

    /* Payload marker + payload */
    packet[pos++] = 0xFF;
    memcpy(&packet[pos], payload.c_str(), payload.length());
    pos += payload.length();

    r.wire_bytes = pos + 8;  /* +8 for UDP header */

    unsigned long start = micros();

    udp.beginPacket(COAP_SERVER, COAP_PORT);
    udp.write(packet, pos);
    udp.endPacket();

    /* Wait for ACK */
    unsigned long timeout = millis() + 2000;
    while (millis() < timeout) {
        int reply_len = udp.parsePacket();
        if (reply_len > 0) {
            uint8_t reply[64];
            udp.read(reply, sizeof(reply));
            if ((reply[0] & 0x30) == 0x20) {
                r.success = true;
                break;
            }
        }
        delay(1);
    }

    r.rtt_us = micros() - start;
    return r;
}

/* ---- HTTP bench ---- */
BenchResult bench_http(const String& payload) {
    BenchResult r = {"HTTP", (int)payload.length(), 0, 0, false};

    HTTPClient http;

    unsigned long start = micros();

    http.begin(HTTP_URL);
    http.addHeader("Content-Type", "application/json");
    int code = http.POST(payload);
    http.getString();  /* Read response to complete the transaction */

    r.rtt_us = micros() - start;
    r.success = (code == 200);

    /* Estimate HTTP overhead: method + URL + headers + payload */
    r.wire_bytes = payload.length() + 350;  /* ~350 bytes of HTTP headers */

    http.end();
    return r;
}

/* ---- Print results ---- */
void print_results(BenchResult results[], int count) {
    Serial.println("\n========== PROTOCOL COMPARISON ==========");
    Serial.printf("%-8s | %-8s | %-10s | %-10s | %s\n",
                  "Proto", "Payload", "Wire(est)", "RTT(us)", "Status");
    Serial.println("---------+----------+------------+------------+--------");

    for (int i = 0; i < count; i++) {
        Serial.printf("%-8s | %-8d | %-10d | %-10lu | %s\n",
                      results[i].protocol,
                      results[i].payload_bytes,
                      results[i].wire_bytes,
                      results[i].rtt_us,
                      results[i].success ? "OK" : "FAIL");
    }
    Serial.println("==========================================\n");
}

/* ---- Wi-Fi connect ---- */
void wifi_connect() {
    Serial.printf("Connecting to %s", WIFI_SSID);
    WiFi.begin(WIFI_SSID, WIFI_PASS);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.printf("\nConnected, IP: %s\n", WiFi.localIP().toString().c_str());
}

/* ---- Setup ---- */
void setup() {
    Serial.begin(115200);
    delay(1000);

    Wire.begin(21, 22);
    if (!bme.begin(0x76)) {
        Serial.println("BME280 not found, check wiring");
        while (1) delay(1000);
    }
    Serial.println("BME280 initialized");

    wifi_connect();
    udp.begin(5684);  /* Local port for CoAP ACKs */
}

/* ---- Loop ---- */
void loop() {
    float temp = bme.readTemperature();
    float hum  = bme.readHumidity();
    float pres = bme.readPressure() / 100.0F;

    String payload = build_payload(temp, hum, pres);
    Serial.printf("Sensor: %.2f C, %.2f %%, %.2f hPa\n", temp, hum, pres);

    BenchResult results[3];
    results[0] = bench_mqtt(payload);
    results[1] = bench_coap(payload);
    results[2] = bench_http(payload);

    print_results(results, 3);

    delay(15000);  /* Run bench every 15 seconds */
}

Sensor: 23.45 C, 48.12 %, 1013.25 hPa

========== PROTOCOL COMPARISON ==========
Proto    | Payload  | Wire(est)  | RTT(us)    | Status
---------+----------+------------+------------+--------
MQTT     | 128      | 163        | 1842       | OK
CoAP     | 128      | 157        | 3215       | OK
HTTP     | 128      | 478        | 28463      | OK
==========================================

#define BENCH_ITERATIONS 100

void run_statistical_bench() {
    unsigned long mqtt_times[BENCH_ITERATIONS];
    unsigned long coap_times[BENCH_ITERATIONS];
    unsigned long http_times[BENCH_ITERATIONS];

    for (int i = 0; i < BENCH_ITERATIONS; i++) {
        float temp = bme.readTemperature();
        float hum  = bme.readHumidity();
        float pres = bme.readPressure() / 100.0F;
        String payload = build_payload(temp, hum, pres);

        BenchResult r_mqtt = bench_mqtt(payload);
        mqtt_times[i] = r_mqtt.rtt_us;

        delay(100);  /* Small gap between protocols */

        BenchResult r_coap = bench_coap(payload);
        coap_times[i] = r_coap.rtt_us;

        delay(100);

        BenchResult r_http = bench_http(payload);
        http_times[i] = r_http.rtt_us;

        delay(500);
    }

    /* Sort each array and print statistics */
    /* (Implement a simple insertion sort for each array) */
    Serial.println("Benchmark complete. Process the arrays for statistics.");
}

# Single office building
office/hq/3/server-room/esp32-01/temperature
office/hq/3/server-room/esp32-01/humidity
office/hq/3/server-room/esp32-01/pressure
office/hq/3/lobby/esp32-02/occupancy

# Agricultural deployment
farm/greenhouse-a/zone1/soil-node-01/moisture
farm/greenhouse-a/zone1/soil-node-01/temperature
farm/greenhouse-a/zone2/soil-node-02/moisture
farm/outdoor/weather-station/wind_speed

# Industrial floor
factory/plant-1/line-3/motor-07/vibration
factory/plant-1/line-3/motor-07/temperature
factory/plant-1/line-3/plc-01/cycle_count

{
    "device_id": "esp32-proto-bench",
    "timestamp_ms": 1741612800000,
    "temperature_c": 23.45,
    "humidity_pct": 48.12,
    "pressure_hpa": 1013.25
}

{
    "device_id": "esp32-proto-bench",
    "firmware_version": "1.2.0",
    "timestamp_ms": 1741612800000,
    "uptime_s": 86400,
    "wifi_rssi": -62,
    "free_heap": 124000,
    "temperature_c": 23.45,
    "humidity_pct": 48.12,
    "pressure_hpa": 1013.25
}