esp32测试连接emqx 发送主题 温度

    #include <stdio.h>
    #include <string.h>
    #include <inttypes.h>
    #include "esp_random.h"

    #include "freertos/FreeRTOS.h"
    #include "freertos/task.h"
    #include "freertos/event_groups.h"

    #include "esp_system.h"
    #include "esp_event.h"
    #include "esp_log.h"
    #include "nvs_flash.h"
    #include "esp_netif.h"
    #include "esp_wifi.h"
    #include "esp_timer.h"

    #include "mqtt_client.h"

    static const char *TAG = "EMQX_PUB";

    // ===== wifi信息一定要正确，emqx里面客户授权的用户名密码（已填好）=====
    #define WIFI_SSID      "SYL2F"
    #define WIFI_PASS      "88888888"

    #define MQTT_URI       "mqtt://122.51.216.154:1883"
    #define CLIENT_ID      "esp32_01"

    #define MQTT_USERNAME  "esp32"
    #define MQTT_PASSWORD  "123456"

    // 发布主题：devices/<clientid>/temp 订阅主题就是：devices/esp32_01/temp
    static char g_topic[128];

    static EventGroupHandle_t s_wifi_event_group;
    static const int WIFI_CONNECTED_BIT = BIT0;

    static esp_mqtt_client_handle_t s_mqtt = NULL;
    static bool s_mqtt_connected = false;

    static void wifi_event_handler(void *arg, esp_event_base_t event_base,
                                   int32_t event_id, void *event_data)
    {
        if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
            ESP_LOGI(TAG, "WiFi STA start, connecting...");
            esp_wifi_connect();
        } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
            ESP_LOGW(TAG, "WiFi disconnected, reconnecting...");
            xEventGroupClearBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
            esp_wifi_connect();
        } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
            ip_event_got_ip_t *event = (ip_event_got_ip_t *)event_data;
            ESP_LOGI(TAG, "Got IP: " IPSTR, IP2STR(&event->ip_info.ip));
            xEventGroupSetBits(s_wifi_event_group, WIFI_CONNECTED_BIT);
        }
    }

    static void wifi_init_sta(void)
    {
        s_wifi_event_group = xEventGroupCreate();

        ESP_ERROR_CHECK(esp_netif_init());
        ESP_ERROR_CHECK(esp_event_loop_create_default());
        esp_netif_create_default_wifi_sta();

        wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
        ESP_ERROR_CHECK(esp_wifi_init(&cfg));

        ESP_ERROR_CHECK(esp_event_handler_instance_register(
            WIFI_EVENT, ESP_EVENT_ANY_ID, &wifi_event_handler, NULL, NULL));
        ESP_ERROR_CHECK(esp_event_handler_instance_register(
            IP_EVENT, IP_EVENT_STA_GOT_IP, &wifi_event_handler, NULL, NULL));

        wifi_config_t wifi_config = { 0 };
        strncpy((char *)wifi_config.sta.ssid, WIFI_SSID, sizeof(wifi_config.sta.ssid));
        strncpy((char *)wifi_config.sta.password, WIFI_PASS, sizeof(wifi_config.sta.password));

        // 可选：如果你路由器兼容性一般，可以加上下面这行限制认证模式
        // wifi_config.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;

        ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
        ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &wifi_config));
        ESP_ERROR_CHECK(esp_wifi_start());

        ESP_LOGI(TAG, "wifi_init_sta finished (ssid=%s).", WIFI_SSID);
    }

    static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
    {
        esp_mqtt_event_handle_t event = (esp_mqtt_event_handle_t)event_data;

        switch ((esp_mqtt_event_id_t)event_id) {
        case MQTT_EVENT_CONNECTED:
            s_mqtt_connected = true;
            ESP_LOGI(TAG, "MQTT connected (clientid=%s, user=%s)", CLIENT_ID, MQTT_USERNAME);
            break;

        case MQTT_EVENT_DISCONNECTED:
            s_mqtt_connected = false;
            ESP_LOGW(TAG, "MQTT disconnected");
            break;

        case MQTT_EVENT_ERROR:
            s_mqtt_connected = false;
            ESP_LOGE(TAG, "MQTT error");
            if (event->error_handle) {
                ESP_LOGE(TAG, "esp-tls last error: 0x%x", event->error_handle->esp_tls_last_esp_err);
                ESP_LOGE(TAG, "tls stack error:    0x%x", event->error_handle->esp_tls_stack_err);
                ESP_LOGE(TAG, "sock errno:         %d",  event->error_handle->esp_transport_sock_errno);
            }
            break;

        default:
            break;
        }
    }

    static void mqtt_start(void)
    {
        esp_mqtt_client_config_t cfg = {
            .broker.address.uri = MQTT_URI,
            .credentials.client_id = CLIENT_ID,
            .credentials.username = MQTT_USERNAME,
            .credentials.authentication.password = MQTT_PASSWORD,

            // 可选：如果网络差可以把 keepalive 调大一点
            .session.keepalive = 60,
            // .network.timeout_ms = 10000, // 有些版本字段名不同，先不强制
        };

        s_mqtt = esp_mqtt_client_init(&cfg);
        ESP_ERROR_CHECK(esp_mqtt_client_register_event(s_mqtt, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL));
        ESP_ERROR_CHECK(esp_mqtt_client_start(s_mqtt));
    }

    static float fake_temperature_c(void)
    {
        // 用硬件随机数模拟：20.00~29.99
        uint32_t r = esp_random() % 1000;
        return 20.0f + (float)r / 100.0f;
    }

    void app_main(void)
    {
        ESP_ERROR_CHECK(nvs_flash_init());

        snprintf(g_topic, sizeof(g_topic), "devices/%s/temp", CLIENT_ID);
        ESP_LOGI(TAG, "Publish topic: %s", g_topic);
        ESP_LOGI(TAG, "MQTT URI: %s", MQTT_URI);

        wifi_init_sta();

        // 等待 WiFi 连上
        xEventGroupWaitBits(s_wifi_event_group, WIFI_CONNECTED_BIT, pdFALSE, pdTRUE, portMAX_DELAY);
        ESP_LOGI(TAG, "WiFi connected, starting MQTT...");

        mqtt_start();

        while (1) {
            if (s_mqtt && s_mqtt_connected) {
                float t = fake_temperature_c();
                int64_t ms = esp_timer_get_time() / 1000;

                char payload[128];
                int n = snprintf(payload, sizeof(payload),
                                 "{\"deviceId\":\"%s\",\"tempC\":%.2f,\"ms\":%" PRId64 "}",
                                 CLIENT_ID, t, ms);

                int msg_id = esp_mqtt_client_publish(s_mqtt, g_topic, payload, n, 1, 0);
                ESP_LOGI(TAG, "PUB id=%d %s -> %s", msg_id, g_topic, payload);
            } else {
                ESP_LOGW(TAG, "MQTT not connected yet, waiting...");
            }

            vTaskDelay(pdMS_TO_TICKS(2000));
        }
    }