Wifi 测试

打开WIFI用例：zephyr\samples\net\wifi\shell

1. prj.conf 配置末尾里加：

#DNS 解析
CONFIG_DNS_RESOLVER=y
CONFIG_DNS_RESOLVER_ADDITIONAL_QUERIES=1

2. 编译

west build -b esp32s3_devkitc/esp32s3/procpu samples\net\wifi\shell -p

3. 连接usb线和esp32开发板下载程序，COM6改为自己端口。

west flash --runner esp32 --esp-device COM6

4. 打开手机热点.注意改为2.4GHz。

5. 打开串口终端输入

   注：下面”Ultra”改为热点名称，”12345678″对应热点密码

# shell 扫描:
wifi scan

# 连接：
wifi connect -s  "Ultra" -p "12345678" -k 1

# 查询
net iface

# Ping:
net ping 8.8.8.8

# dns解析：
net dns www.baidu.com
net ping 解析出来的dns

LOG 输出：

uart:~wifi scan
Scan requested

Num  | SSID                             (len) | Chan (Band)   | RSSI | Security             | BSSID             | MFP
1    | Ultra                            5     | 6    (2.4GHz) | -28  | WPA2-PSK             | FA:28:CC:F9:FF:44 | Disable
2    | 71002                            5     | 11   (2.4GHz) | -41  | UNKNOWN              | D8:09:7F:08:04:A8 | Disable
3    | 71002                            5     | 11   (2.4GHz) | -47  | UNKNOWN              | D8:09:7F:9D:64:0B | Disable
4    | ChinaNet-i2Nu                    13    | 1    (2.4GHz) | -61  | UNKNOWN              | 18:AA:CA:1B:3E:09 | Disable
5    | ChinaNet-123                     12    | 11   (2.4GHz) | -61  | WPA2-PSK             | 84:F5:EB:28:7D:66 | Disable
6    | HUAWEI902                        9     | 1    (2.4GHz) | -70  | WPA2-PSK             | 62:D5:AB:EA:4C:8D | Disable
7    | xiaohuzi                         8     | 11   (2.4GHz) | -70  | WPA2-PSK             | E0:24:81:42:34:D8 | Disable
8    | 901楼上                        9     | 3    (2.4GHz) | -71  | UNKNOWN              | 98:BB:99:55:32:99 | Disable
9    | 1322                             4     | 1    (2.4GHz) | -72  | UNKNOWN              | A2:D3:7D:46:5D:DB | Disable
10   | CMCC-YDJ                         8     | 10   (2.4GHz) | -73  | UNKNOWN              | 74:5E:68:6C:E5:60 | Disable
11   | @PHICOMM_FA                      11    | 3    (2.4GHz) | -82  | UNKNOWN              | 2C:15:E1:22:6C:FC | Disable
12   | 熊猫大侠2.4G                 16    | 3    (2.4GHz) | -84  | UNKNOWN              | 68:77:DA:6D:04:DB | Disable
Scan request done
uart:~ wifi connect -s  "Ultra" -p "12345678" -k 1
Connection requested
Connected
[00:00:40.662,000] <inf> net_dhcpv4: Received: 192.168.129.218
uart:~net iface
Default interface: 1


Interface wlan0 (0x3fc96080) (WiFi) [1]
===============================
Link addr : 30:ED:A0:BD:D4:8C
MTU       : 1500
Flags     : AUTO_START,IPv4
Device    : wifi (0x3c087338)
Status    : oper=UP, admin=UP, carrier=ON
Ethernet capabilities supported:
Ethernet PHY device: <none> (0)
IPv4 unicast addresses (max 1):
        192.168.129.218/255.255.255.0 DHCP preferred
IPv4 multicast addresses (max 2):
        224.0.0.1
IPv4 gateway : 192.168.129.247
DHCPv4 lease time : 3599
DHCPv4 renew time : 1799
DHCPv4 server     : 192.168.129.247
DHCPv4 requested  : 192.168.129.218
DHCPv4 state      : bound
DHCPv4 attempts   : 1
DHCPv4 state      : bound
uart:~ net ping 8.8.8.8
PING 8.8.8.8
28 bytes from 8.8.8.8 to 192.168.129.218: icmp_seq=1 ttl=110 time=84 ms
28 bytes from 8.8.8.8 to 192.168.129.218: icmp_seq=2 ttl=110 time=292 ms
28 bytes from 8.8.8.8 to 192.168.129.218: icmp_seq=3 ttl=110 time=111 ms
uart:~net dns www.baidu.com
Query for 'www.baidu.com' sent.
dns: 39.156.70.239
dns: 39.156.70.46
dns: All results received
uart:~ net ping 39.156.70.239
PING 39.156.70.239
28 bytes from 39.156.70.239 to 192.168.129.218: icmp_seq=1 ttl=51 time=95 ms
28 bytes from 39.156.70.239 to 192.168.129.218: icmp_seq=2 ttl=51 time=312 ms
28 bytes from 39.156.70.239 to 192.168.129.218: icmp_seq=3 ttl=51 time=332 ms

MQTT 远程控制 LED

开源连接：https://github.com/heiweilu/zephyr/tree/main/samples/boards/espressif/apps/mqtt_led

背景

• 设备: ESP32S3 DevKitC
• 功能定位: 通过 MQTT 控制 WS2812 LED（命令下发）并周期上报状态（设备→云）
• 网络: Wi-Fi (STA, DHCPv4)

术语

• Broker (代理服务器): MQTT 服务端，负责主题路由与消息分发 (示例: broker.emqx.io, test.mosquitto.org)
• 客户端工具: 如 MQTTX / mosquitto_pub/sub，用于测试与调试（并不是 Broker）
• 主题 (Topic): 分层的字符串路径，区分命令与状态
• QoS: 消息服务质量等级 (0/1/2)，当前示例使用 QoS0（最快，无确认）

已完成

1. Wi-Fi 自动连接，可访问外网
2. LED 可控
3. 基础 MQTT 连接 / 订阅 / 发布 / 重连
4. 支持灵活配置 Broker (Host, Port)
5. 订阅命令主题: (默认: esp32s3/led/cmd)
6. 发布状态主题: (默认: esp32s3/led/status)
7. 支持命令格式:
   • 预设: red / green / blue / off
   • 自定义: R,G,B (0-255)
8. 周期发布当前颜色 JSON: {"r":<R>,"g":<G>,"b":<B>}

9. 健壮的断网/断 Broker 自动重连 (指数或固定回退)

流程图

main.c

/*
 * Copyright (c) 2025 Hei Weilu
 * SPDX-License-Identifier: Apache-2.0
 */
#include <errno.h>
#include <string.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <zephyr/device.h>
#include <zephyr/drivers/led_strip.h>
#include <zephyr/net/net_if.h>
#include <zephyr/net/net_mgmt.h>
#include <zephyr/net/mqtt.h>
#include <zephyr/net/socket.h>
#include <zephyr/random/random.h>
#include <zephyr/net/dhcpv4.h>
#include <zephyr/net/net_ip.h>
#include <zephyr/net/wifi_mgmt.h>

LOG_MODULE_REGISTER(main, LOG_LEVEL_INF);

/* LED strip (from overlay alias led-strip) */
#define STRIP_NODE DT_ALIAS(led_strip)
#if DT_NODE_HAS_PROP(STRIP_NODE, chain_length)
#define STRIP_NUM_PIXELS DT_PROP(STRIP_NODE, chain_length)
#else
#define STRIP_NUM_PIXELS 1
#endif

static const struct device *strip = DEVICE_DT_GET(STRIP_NODE);
static struct led_rgb pixels[STRIP_NUM_PIXELS];

/* Network events */
#define L4_EVENT_MASK (NET_EVENT_L4_CONNECTED | NET_EVENT_L4_DISCONNECTED | NET_EVENT_IPV4_ADDR_ADD)
static struct net_mgmt_event_callback l4_cb;
static K_SEM_DEFINE(net_ok, 0, 1);

/* MQTT */
static struct mqtt_client client;
static struct sockaddr_storage broker;
static uint8_t rx_buffer[1024];
static uint8_t tx_buffer[1024];
static uint8_t payload_buf[256];
static bool mqtt_connected_flag;

#ifndef CONFIG_APP_MQTT_BROKER_HOST
#define CONFIG_APP_MQTT_BROKER_HOST "broker.emqx.io"
#endif
#ifndef CONFIG_APP_MQTT_BROKER_PORT
#define CONFIG_APP_MQTT_BROKER_PORT 1883
#endif

#define MQTT_SUB_TOPIC "esp32s3/led/cmd"
#define MQTT_PUB_TOPIC "esp32s3/led/status"

/* Wi-Fi auto connection configuration */
#define WIFI_SSID "Ultra"
#define WIFI_PSK  "12345678"

/* Helper: set all LEDs */
static void set_led_color(uint8_t r, uint8_t g, uint8_t b)
{
    for (size_t i = 0; i < STRIP_NUM_PIXELS; i++) {
        pixels[i].r = r;
        pixels[i].g = g;
        pixels[i].b = b;
    }
    if (led_strip_update_rgb(strip, pixels, STRIP_NUM_PIXELS) < 0) {
        LOG_ERR("LED update failed");
    }
}

/* Network event handler */
static void wifi_event_handler(struct net_mgmt_event_callback *cb, uint64_t mgmt_event,
                   struct net_if *iface)
{
    ARG_UNUSED(cb);
    ARG_UNUSED(iface);

    if (mgmt_event == NET_EVENT_IPV4_ADDR_ADD) {
        LOG_INF("IPv4 acquired");
        k_sem_give(&net_ok);
    } else if (mgmt_event == NET_EVENT_L4_CONNECTED) {
        LOG_INF("L4 connected");
        k_sem_give(&net_ok);
    } else if (mgmt_event == NET_EVENT_L4_DISCONNECTED) {
        LOG_INF("L4 disconnected");
    }
}

/* MQTT event handler */
static void mqtt_event_handler(struct mqtt_client *const c, const struct mqtt_evt *evt)
{
    int rc;

    switch (evt->type) {
    case MQTT_EVT_CONNACK:
        if (evt->result != 0) {
            LOG_ERR("MQTT connect failed %d", evt->result);
            break;
        }
        mqtt_connected_flag = true;
        LOG_INF("MQTT connected");
        /* Subscribe */
        {
            struct mqtt_topic topic = {.topic = {.utf8 = (uint8_t *)MQTT_SUB_TOPIC,
                                 .size = strlen(MQTT_SUB_TOPIC)},
                           .qos = MQTT_QOS_0_AT_MOST_ONCE};
            const struct mqtt_subscription_list sub_list = {
                .list = &topic, .list_count = 1, .message_id = 1};
            rc = mqtt_subscribe(c, &sub_list);
            if (rc) {
                LOG_ERR("Subscribe failed %d", rc);
            } else {
                LOG_INF("Subscribe sent for topic: %s", MQTT_SUB_TOPIC);
            }
        }
        break;
    case MQTT_EVT_SUBACK:
        LOG_INF("SUBACK received, message_id=%u", evt->param.suback.message_id);
        break;
    case MQTT_EVT_DISCONNECT:
        mqtt_connected_flag = false;
        LOG_INF("MQTT disconnected");
        break;
    case MQTT_EVT_PUBLISH: {
        const struct mqtt_publish_param *p = &evt->param.publish;
        uint32_t len = MIN(p->message.payload.len, sizeof(payload_buf) - 1);

        memset(payload_buf, 0, sizeof(payload_buf));
        mqtt_read_publish_payload(c, payload_buf, len);
        payload_buf[len] = '\0';
        LOG_INF("RX %.*s => %s", p->message.topic.topic.size, p->message.topic.topic.utf8,
            payload_buf);
        /* Commands: red green blue off OR R,G,B */
        if (!strcmp((char *)payload_buf, "red")) {
            set_led_color(0x40, 0, 0);
        } else if (!strcmp((char *)payload_buf, "green")) {
            set_led_color(0, 0x40, 0);
        } else if (!strcmp((char *)payload_buf, "blue")) {
            set_led_color(0, 0, 0x40);
        } else if (!strcmp((char *)payload_buf, "off")) {
            set_led_color(0, 0, 0);
        } else {
            unsigned int r, g, b;

            if (sscanf((char *)payload_buf, "%u,%u,%u", &r, &g, &b) == 3) {
                set_led_color(r & 0xFF, g & 0xFF, b & 0xFF);
            } else {
                LOG_WRN("Unknown command");
            }
        }
        break;
    }
    default:
        break;
    }
}

/* Resolve broker: try IPv4 literal first; if not, attempt DNS (AF_INET). */
static int resolve_broker(void)
{
    struct sockaddr_in *addr4 = (struct sockaddr_in *)&broker;

    memset(addr4, 0, sizeof(*addr4));
    addr4->sin_family = AF_INET;
    addr4->sin_port = htons(CONFIG_APP_MQTT_BROKER_PORT);

    /* 1) Try treat as IPv4 literal */
    if (inet_pton(AF_INET, CONFIG_APP_MQTT_BROKER_HOST, &addr4->sin_addr) == 1) {
        LOG_INF("Broker IPv4 literal %s:%d", CONFIG_APP_MQTT_BROKER_HOST,
            CONFIG_APP_MQTT_BROKER_PORT);
        return 0;
    }

#if defined(CONFIG_DNS_RESOLVER)
    /* 2) DNS lookup */
    struct addrinfo hints = {0};
    struct addrinfo *res = NULL;
    int err;
    char port_str[8];

    snprintk(port_str, sizeof(port_str), "%d", CONFIG_APP_MQTT_BROKER_PORT);
    hints.ai_family = AF_INET; /* Only IPv4 for now */
    hints.ai_socktype = SOCK_STREAM;
    err = getaddrinfo(CONFIG_APP_MQTT_BROKER_HOST, port_str, &hints, &res);

    if (err || !res) {
        LOG_ERR("DNS resolve failed (%d) for %s", err, CONFIG_APP_MQTT_BROKER_HOST);
        if (res) {
            freeaddrinfo(res);
        }
        return -EHOSTUNREACH;
    }
    struct sockaddr_in *resolved = (struct sockaddr_in *)res->ai_addr;

    addr4->sin_addr = resolved->sin_addr;
    freeaddrinfo(res);
    char ipbuf[NET_IPV4_ADDR_LEN];

    net_addr_ntop(AF_INET, &addr4->sin_addr, ipbuf, sizeof(ipbuf));
    LOG_INF("Broker DNS %s -> %s:%d", CONFIG_APP_MQTT_BROKER_HOST, ipbuf,
        CONFIG_APP_MQTT_BROKER_PORT);
    return 0;
#else
    LOG_ERR("CONFIG_APP_MQTT_BROKER_HOST must be IPv4 literal or enable CONFIG_DNS_RESOLVER");
    return -EINVAL;
#endif
}

/* MQTT client setup */
static void app_mqtt_client_prepare(void)
{
    mqtt_client_init(&client);
    client.broker = &broker;
    client.evt_cb = mqtt_event_handler;
    client.client_id.utf8 = (uint8_t *)"esp32s3-led";
    client.client_id.size = strlen((char *)client.client_id.utf8);
    client.user_name = NULL;
    client.password = NULL;
    client.protocol_version = MQTT_VERSION_3_1_0;
    client.transport.type = MQTT_TRANSPORT_NON_SECURE;
    client.rx_buf = rx_buffer;
    client.rx_buf_size = sizeof(rx_buffer);
    client.tx_buf = tx_buffer;
    client.tx_buf_size = sizeof(tx_buffer);
    client.keepalive = CONFIG_MQTT_KEEPALIVE;
}

/* MQTT client connect */
static int mqtt_connect_blocking(void)
{
    int rc = mqtt_connect(&client);

    if (rc) {
        LOG_ERR("mqtt_connect rc=%d", rc);
        return rc;
    }
    int attempts = 100; /* 100 * 50ms ~= 5s */

    while (!mqtt_connected_flag && attempts--) {
        mqtt_input(&client);
        mqtt_live(&client);
        k_msleep(50);
    }
    return mqtt_connected_flag ? 0 : -ETIMEDOUT;
}

static int mqtt_publish_status(void)
{
    char msg[64];

    snprintk(msg, sizeof(msg), "{\"r\":%u,\"g\":%u,\"b\":%u}", pixels[0].r, pixels[0].g,
         pixels[0].b);
    struct mqtt_publish_param param = {0};

    param.message.topic.topic.utf8 = (uint8_t *)MQTT_PUB_TOPIC;
    param.message.topic.topic.size = strlen(MQTT_PUB_TOPIC);
    param.message.topic.qos = MQTT_QOS_0_AT_MOST_ONCE;
    param.message.payload.data = msg;
    param.message.payload.len = strlen(msg);
    param.message_id = sys_rand16_get();
    param.dup_flag = 0;
    param.retain_flag = 0;
    return mqtt_publish(&client, &param);
}

/* Register callbacks for L4 events */
static void l4_register(void)
{
    net_mgmt_init_event_callback(&l4_cb, wifi_event_handler, L4_EVENT_MASK);
    net_mgmt_add_event_callback(&l4_cb);
}

/* Auto connect to Wi-Fi */
static int wifi_connect_auto(void)
{
    struct net_if *iface = net_if_get_default();
    struct wifi_connect_req_params wifi_params = {0};

    wifi_params.ssid = (uint8_t *)WIFI_SSID;
    wifi_params.ssid_length = strlen(WIFI_SSID);
    wifi_params.security = WIFI_SECURITY_TYPE_PSK; /* WPA/WPA2-PSK: need PSK */
    wifi_params.psk = (uint8_t *)WIFI_PSK;
    wifi_params.psk_length = strlen(WIFI_PSK);
    wifi_params.channel = WIFI_CHANNEL_ANY;    /* auto select channel */
    wifi_params.band = WIFI_FREQ_BAND_2_4_GHZ; /* 2.4 GHz band */
    wifi_params.mfp = WIFI_MFP_OPTIONAL;       /* Management Frame Protection */

    LOG_INF("Connecting to Wi-Fi SSID: %s", WIFI_SSID);

    return net_mgmt(NET_REQUEST_WIFI_CONNECT, iface, &wifi_params, sizeof(wifi_params));
}

int main(void)
{
    int rc;
    LOG_INF("MQTT LED sample start");

    if (!device_is_ready(strip)) {
        LOG_ERR("LED strip not ready");
        return 0;
    }
    set_led_color(0, 0, 0);

    /* Register callbacks for L4 events */
    l4_register();

    /* get default network interface */
    struct net_if *iface = net_if_get_default();

    if (!iface) {
        LOG_ERR("No default net_if");
        return 0;
    }
#if defined(CONFIG_NET_DHCPV4)
    net_dhcpv4_start(iface);
#endif

    /* Auto connect to Wi-Fi */
    int wifi_rc = wifi_connect_auto();

    if (wifi_rc) {
        LOG_ERR("Wi-Fi connect failed: %d", wifi_rc);
        return 0;
    }

    /* Hybrid wait: event semaphore OR polling IPv4 acquisition (timeout 60s) */
    int waited_ms = 0;

    while (true) {
        if (k_sem_take(&net_ok, K_NO_WAIT) == 0) {
            LOG_INF("Network ready (event)");
            break;
        }

        /* Get IPv4 address */
        const struct in_addr *a = net_if_ipv4_get_global_addr(iface, NET_ADDR_PREFERRED);

        if (!a) {
            a = net_if_ipv4_get_global_addr(iface, NET_ADDR_ANY);
        }
        if (a) {
            char ipbuf[NET_IPV4_ADDR_LEN];

            net_addr_ntop(AF_INET, a, ipbuf, sizeof(ipbuf));

            LOG_INF("Network ready (poll) IPv4=%s", ipbuf);
            break;
        }
        if (waited_ms >= 60000) {
            LOG_WRN("Timeout waiting network, continue anyway");
            break;
        }
        LOG_INF("Waiting for network...");
        k_msleep(1000);
        waited_ms += 1000;
    }

    if (resolve_broker()) {
        return 0;
    }

    app_mqtt_client_prepare();

retry_connect:
    LOG_INF("Connecting MQTT broker %s:%d", CONFIG_APP_MQTT_BROKER_HOST,
        CONFIG_APP_MQTT_BROKER_PORT);
    rc = mqtt_connect_blocking();
    if (rc) {
        LOG_ERR("MQTT connect failed rc=%d, retry in 3s", rc);
        k_msleep(3000);
        goto retry_connect;
    }

    uint32_t publish_counter = 0;

    for (;;) {
        int irc = mqtt_input(&client);

        if (irc && irc != -EAGAIN) {
            LOG_WRN("mqtt_input rc=%d", irc);
        }
        mqtt_live(&client);

        if (!mqtt_connected_flag) {
            LOG_WRN("Lost MQTT, reconnecting");
            mqtt_abort(&client);
            k_msleep(1000);
            goto retry_connect;
        }

        if ((publish_counter++ % 100) == 0) {
            rc = mqtt_publish_status();
            if (rc) {
                LOG_WRN("Status publish failed %d", rc);
            } else {
                LOG_DBG("Status published");
            }
        }
        k_msleep(50);
    }

    return 0;
}

可借鉴参考示例要点

1. zephyr/samples/net/secure_mqtt_sensor_actuator
   • L4 网络事件回调 + 信号量同步模式
   • k_work_delayable 实现周期任务（比轮询循环更节能）
   • 可扩展 TLS 支持结构
2. zephyr/samples/net/mqtt_publisher
   • 最小 MQTT 初始化流程参考（client 结构体填充）
3. zephyr/samples/net/mdns_responder
   • 若后续希望通过 mDNS 发布/发现 Broker 服务，可引入服务发现 (例如 _mqtt._tcp.local)
4. zephyr/samples/net/mqtt_sn_publisher
   • 展示 MQTT-SN 与标准 MQTT 区别，如需低功耗网关适配可参考主题映射思想

公共免费 Broker 方案

示例使用 EMQX: Host=broker.emqx.io, Port=1883

MQTTX 配置

broker配置

订阅配置

使用

配置wifi热点

编译下载

 west build -b esp32s3_devkitc/esp32s3/procpu .\samples\boards\espressif\apps\mqtt_led\ -p

 west flash --runner esp32 --esp-device COM9

esp32会定时发送LED的状态，如下图所示

在服务端控制ESP32的LED、格式为RGB，用逗号分隔，或直接发送blue、red、green、off。

串口终端输出

最后一条消息表示收到red的指令

ESP-ROM:esp32s3-20210327
Build:Mar 27 2021
rst:0x1 (POWERON),boot:0x8 (SPI_FAST_FLASH_BOOT)
SPIWP:0xee
mode:DIO, clock div:1
load:0x3fc92440,len:0x4e6c
load:0x40374000,len:0xe428
SHA-256 comparison failed:
Calculated: 779d3e7304a5ea1f3fc3912816b9d94a5536cd6ab88f1fa1cddca7ebdb2431b4
Expected: 0000000030cd0000000000000000000000000000000000000000000000000000
Attempting to boot anyway...
entry 0x4037cdcc
I (74) soc_init: ESP Simple boot
I (74) soc_init: compile time Oct  8 2025 23:37:29
W (74) soc_init: Unicore bootloader
I (74) soc_init: chip revision: v0.2
I (77) flash_init: Boot SPI Speed : 80MHz
I (81) flash_init: SPI Mode       : DIO
I (84) flash_init: SPI Flash Size : 8MB
I (88) boot: DRAM       : lma=00000020h vma=3fc92440h size=04e6ch ( 20076)
I (94) boot: IRAM       : lma=00004e94h vma=40374000h size=0e428h ( 58408)
I (100) boot: IRAM      : lma=000132c8h vma=00000000h size=0cd30h ( 52528)
I (106) boot: IRAM      : lma=00020000h vma=42000000h size=67c60h (425056)
I (112) boot: IRAM      : lma=00087c68h vma=00000000h size=08390h ( 33680)
I (118) boot: IRAM      : lma=00090000h vma=3c070000h size=189cch (100812)
I (125) boot: IROM      : lma=00020000h vma=42000000h size=67C5Eh (425054) map
I (131) boot: DROM      : lma=00090000h vma=3c070000h size=189D0h (100816) map
I (149) boot: libc heap size 206 kB.
I (149) spi_flash: detected chip: generic
I (149) spi_flash: flash io: dio
W (149) spi_flash: Detected size(16384k) larger than the size in the binary image header(8192k). Using the size in the binary image header.
uart:~[00:00:00.197,000] <dbg> ws2812_i2s: ws2812_i2s_init: Word clock: freq 100000 Hz period 10 us
uart:~ *** Booting Zephyr OS build v4.2.0-3625-gda1c22ff033c ***
uart:~[00:00:00.198,000] <inf> main: MQTT LED sample start
uart:~ uart:~[00:00:00.200,000] <inf> main: Connecting to Wi-Fi SSID: Ultra
uart:~ [00:00:00.233,000] <inf> main: Waiting for network...
uart:~uart:~ [00:00:01.233,000] <inf> main: Waiting for network...
uart:~uart:~ [00:00:02.233,000] <inf> main: Waiting for network...
uart:~[00:00:03.233,000] <inf> main: Waiting for network...
uart:~ uart:~[00:00:03.299,000] <inf> net_dhcpv4: Received: 192.168.129.218
uart:~ Connected
uart:~[00:00:04.234,000] <inf> main: Network ready (poll) IPv4=192.168.129.218
uart:~ [00:00:04.293,000] <inf> main: Broker DNS broker.emqx.io -> 34.243.217.54:1883
uart:~[00:00:04.293,000] <inf> main: Connecting MQTT broker broker.emqx.io:1883
uart:~ uart:~[00:00:04.787,000] <inf> net_mqtt: Connect completed
uart:~ [00:00:05.440,000] <inf> main: MQTT connected
uart:~[00:00:05.441,000] <inf> main: Subscribe sent for topic: esp32s3/led/cmd
uart:~ uart:~[00:00:05.843,000] <inf> main: SUBACK received, message_id=1
uart:~ uart:~[00:00:25.291,000] <inf> main: RX esp32s3/led/cmd => 148,0,211
uart:~ uart:~$ [00:00:32.862,000] <inf> main: RX esp32s3/led/cmd => red