把传感器数据发到 MQTT，并让命令回到一盏灯

mosquitto -c broker-loopback.conf -v
# 另开终端，保持订阅器运行
mosquitto_sub -h 127.0.0.1 -p 18884 -t 'hixinwu/n04/#' -v
# 再一个终端发布明确的主机测试消息
mosquitto_pub -h 127.0.0.1 -p 18884 -t hixinwu/n04/test -m host-only

idf.py --version
idf.py set-target esp32s3
idf.py menuconfig
idf.py build
idf.py -p PORT flash monitor

mosquitto_pub -h LAN_IP -p 18884 -t hixinwu/n04/led/set -q 1 -m ON
mosquitto_pub -h LAN_IP -p 18884 -t hixinwu/n04/led/set -q 1 -m OFF
mosquitto_pub -h LAN_IP -p 18884 -t hixinwu/n04/led/set -q 1 -m toggle

// SPDX-License-Identifier: MIT
#include <string.h>
#include <inttypes.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_system.h"
#include "esp_timer.h"
#include "mqtt_client.h"
#include "sdkconfig.h"
#include "net.h"
#include "sensirion_hal_idf.h"
#include "sensirion_i2c_hal.h"
#include "sht4x_i2c.h"
static const char *TAG = "N04";
static const char *COMMAND_TOPIC = "hixinwu/n04/led/set";
static const char *STATE_TOPIC = "hixinwu/n04/led/state";
static const char *AVAILABILITY_TOPIC = "hixinwu/n04/availability";
static const char *TELEMETRY_TOPIC = "hixinwu/n04/telemetry";
static EventGroupHandle_t mqtt_flags;
static void publish_led(esp_mqtt_client_handle_t client) {
    esp_mqtt_client_publish(client, STATE_TOPIC, gpio_get_level(GPIO_NUM_4) ? "ON" : "OFF", 0, 1, 1);
}
static void mqtt_event(void *arg, esp_event_base_t base, int32_t id, void *data) {
    (void)arg; (void)base;
    esp_mqtt_event_handle_t event = data;
    if (id == MQTT_EVENT_CONNECTED) {
        xEventGroupSetBits(mqtt_flags, BIT0);
        ESP_LOGI(TAG, "MQTT_CONNECTED: subscribing to command on each connection");
        esp_mqtt_client_subscribe(event->client, COMMAND_TOPIC, 1);
        esp_mqtt_client_publish(event->client, AVAILABILITY_TOPIC, "online", 0, 1, 1);
        publish_led(event->client);
    } else if (id == MQTT_EVENT_DISCONNECTED) {
        xEventGroupClearBits(mqtt_flags, BIT0); ESP_LOGW(TAG, "MQTT_DISCONNECTED; SDK reconnect enabled");
    } else if (id == MQTT_EVENT_DATA) {
        const bool topic_ok = event->topic && event->topic_len == strlen(COMMAND_TOPIC) && !memcmp(event->topic, COMMAND_TOPIC, event->topic_len);
        // Bounded whole-message commands only. Never apply the first fragment of a longer message.
        const bool whole = event->current_data_offset == 0 && event->data_len == event->total_data_len && event->data_len <= 3;
        const bool turn_on = whole && event->data_len == 2 && !memcmp(event->data, "ON", 2);
        const bool turn_off = whole && event->data_len == 3 && !memcmp(event->data, "OFF", 3);
        if (topic_ok && !event->retain && (turn_on || turn_off)) {
            gpio_set_level(GPIO_NUM_4, turn_on); publish_led(event->client);
            ESP_LOGI(TAG, "LED gpio-digital-level=%s (not an optical measurement)", turn_on ? "ON" : "OFF");
        } else ESP_LOGW(TAG, "COMMAND_REJECTED: exact non-retained ON/OFF whole payload required");
    } else if (id == MQTT_EVENT_ERROR) ESP_LOGW(TAG, "MQTT_ERROR; inspect local broker and network, credentials are not logged");
}
void app_main(void) {
    gpio_reset_pin(GPIO_NUM_4); gpio_set_direction(GPIO_NUM_4, GPIO_MODE_INPUT_OUTPUT); gpio_set_level(GPIO_NUM_4, 0);
    mqtt_flags = xEventGroupCreate(); if (!mqtt_flags) { ESP_LOGE(TAG, "allocation failed"); return; }
    net_start(); sensirion_i2c_hal_init(); sht4x_init(0x44);
    ESP_LOGI(TAG, "IDF=%s SHT4x C driver=1.1.0 PID4885 SDA8/SCL9 100kHz; hardware unverified", esp_get_idf_version());
    const esp_mqtt_client_config_t config = {.broker.address.uri = CONFIG_DEMO_BROKER_URL, .credentials.client_id = "hixinwu-n04-demo", .session.last_will = {.topic = AVAILABILITY_TOPIC, .msg = "offline", .qos = 1, .retain = 1}, .network = {.timeout_ms = 3000, .reconnect_timeout_ms = 3000}};
    esp_mqtt_client_handle_t client = esp_mqtt_client_init(&config);
    if (!client) { ESP_LOGE(TAG, "MQTT init failed"); return; }
    ESP_ERROR_CHECK(esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event, NULL));
    bool started = false; uint32_t sequence = 0, failures = 0;
    for (;;) {
        if (!started && net_online()) { ESP_ERROR_CHECK(esp_mqtt_client_start(client)); started = true; }
        int32_t temp_milli = 0, humidity_milli = 0;
        int16_t result = demo_i2c_ready() ? sht4x_measure_high_precision(&temp_milli, &humidity_milli) : -1;
        char payload[256]; ++sequence;
        if (result == 0) {
            failures = 0;
            int32_t displayed_rh = humidity_milli < 0 ? 0 : humidity_milli > 100000 ? 100000 : humidity_milli;
            snprintf(payload, sizeof(payload), "{\"sequence\":%" PRIu32 ",\"uptime_ms\":%" PRIi64 ",\"valid\":true,\"temperature_c\":%.3f,\"humidity_raw_percent\":%.3f,\"humidity_percent\":%.3f}", sequence, esp_timer_get_time()/1000, temp_milli/1000.0, humidity_milli/1000.0, displayed_rh/1000.0);
        } else {
            ++failures;
            snprintf(payload, sizeof(payload), "{\"sequence\":%" PRIu32 ",\"valid\":false,\"temperature_c\":null,\"humidity_percent\":null,\"sensor_error\":%d}", sequence, result);
            ESP_LOGW(TAG, "SENSOR_ERROR=%d HAL=%s; current values invalid", result, esp_err_to_name(demo_i2c_last_error()));
            if (failures % 3 == 0 && demo_i2c_ready()) ESP_LOGW(TAG, "soft_reset result=%d", sht4x_soft_reset());
        }
        if (started && (xEventGroupGetBits(mqtt_flags) & BIT0)) {
            int message = esp_mqtt_client_publish(client, TELEMETRY_TOPIC, payload, 0, 1, 0);
            ESP_LOGI(TAG, "publish queued_id=%d valid=%u; queued/ack is not physical delivery proof", message, result == 0);
        } else ESP_LOGW(TAG, "LOCAL_ONLY sequence=%" PRIu32 " mqtt=offline; no app sample buffer; submitted SDK QoS1 may retry", sequence);
        vTaskDelay(pdMS_TO_TICKS(5000));
    }
}