ESP32 Forum

Posted: **Thu Jun 17, 2021 3:41 am**

Code: [Select all] [Expand/Collapse]

[#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
#include "esp_log.h"
#include "esp_err.h"
 
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "freertos/event_groups.h"
#include "driver/gpio.h"
 
#include "lwip/err.h"
#include "lwip/sockets.h"
#include "lwip/sys.h"
#include "lwip/dns.h"
#include "lwip/netdb.h"
 
#include "mqtt_client.h"
 
#define LOG_TAG     "MQTT"
 
esp_mqtt_client_handle_t mqtt_client = NULL;
 
static void mqtt_event_handler(void* arg, esp_event_base_t event_base,
                               int32_t event_id, void* event_data )
{
    printf("event ID %d\n", event_id );
 
    switch(event_id )
    {
        case MQTT_EVENT_CONNECTED:
            printf("MQTT_EVENT_CONNECTED\n" );
            
            esp_mqtt_client_subscribe(mqtt_client, "Test_1", 2 );
            esp_mqtt_client_subscribe(mqtt_client, "Test_2", 1 );
            esp_mqtt_client_subscribe(mqtt_client, "Picture", 2 );
 
        break;
 
        case MQTT_EVENT_DISCONNECTED:
            printf("MQTT_EVENT_DISCONNECTED\n" );
 
            // esp_mqtt_client_reconnect(mqtt_client );
        break;
 
        case MQTT_EVENT_SUBSCRIBED:
            printf("MQTT_EVENT_SUBSCRIBED\n" );
            // printf("MQTT_EVENT_SUBSCRIBED, msg_id=%d", msg_id);
 
        break;
 
        case MQTT_EVENT_UNSUBSCRIBED:
            printf("MQTT_EVENT_DISCONNECTED\n" );
        break;
 
        case MQTT_EVENT_PUBLISHED:
            printf("MQTT_EVENT_PUBLISHED\n" );
 
        break;
 
        case MQTT_EVENT_DATA:
            printf("MQTT_EVENT_DATA\n" );
 
            // printf("topic length:%d data length:%d\n",event->topic_len,event->data_len);
 
            // printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
            // printf("DATA=%.*s\r\n", event->data_len, event->data);
        break;
 
        case MQTT_EVENT_ERROR:
            printf("MQTT_EVENT_ERROR (%s)\n", (char *)event_data);
        break;
 
        default:
            printf("Other event id:%d\n", event_id );
        break;
    }
 
}
 
void esp_mqtt_app_start(void * arg )
{
    const esp_mqtt_client_config_t mqtt_client_cfg = {
            .host = "127.0.0.1",
            .port= 1883,
        };
 
    mqtt_client = esp_mqtt_client_init(&mqtt_client_cfg );
 
    esp_mqtt_client_register_event(mqtt_client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
 
    /**
     * 
    */
    esp_mqtt_client_start(mqtt_client);
 
    for ( ;; )
    {
        esp_mqtt_client_publish(mqtt_client, "Test_1", "1234567890", 0, 2, 0 );
 
        vTaskDelay(2000/portTICK_RATE_MS);
    }
}/Codebox][Codebox=c file=Untitled.c]/* GPIO Example
 
   This example code is in the Public Domain (or CC0 licensed, at your option.)
 
   Unless required by applicable law or agreed to in writing, this
   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
   CONDITIONS OF ANY KIND, either express or implied.
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/queue.h"
#include "freertos/event_groups.h"
#include "driver/gpio.h"
 
/**
 * 2021-06-03
 */
#include "driver/spi_master.h"
#include "driver/rtc_cntl.h"
#include "soc/rtc.h"
#include "driver/adc.h"
 
#include "nvs_flash.h"
#include "esp_wifi.h"
#include "esp_wpa2.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "esp_smartconfig.h"
 
#include "esp_partition.h"
 
#include "epd_gdeh.h"
 
#include "mqtt_client.h"
/**
 * User modefied by 2021-05-27
 */
static EventGroupHandle_t       s_wifi_event_group  = NULL;
 
#define SPI_MOSI_IO_NUM  4
#define SPI_MISO_IO_NUM  -1
#define SPI_SCLK_IO_NUM  16
 
extern void gweh_test(void);
extern void esp_mqtt_app_start(void * arg);
 
void usr_spi_tran_cb(spi_transaction_t *trans)
{
    /**
     * dc = Data / Cmd
    */
    int dc = (int)trans->user;
 
    gpio_set_level(SPI_DC_IO_NUM, dc );
    return;
}
 
spi_bus_config_t buscfg = {
    .mosi_io_num = SPI_MOSI_IO_NUM,
    .miso_io_num = SPI_MISO_IO_NUM,
    .sclk_io_num = SPI_SCLK_IO_NUM,
    .quadhd_io_num = -1,
    .quadwp_io_num = -1,
    .max_transfer_sz = 100
};
 
rtc_cpu_freq_config_t rtc_freq_cfg = {
    .source = RTC_CPU_FREQ_SRC_8M,
    .source_freq_mhz = 8000000,
    .div = 8,
    .freq_mhz = 1000000
};
 
spi_device_handle_t usr_spi_handler = NULL;
 
spi_device_interface_config_t usr_spi_dev_cfg = {
    .flags = SPI_DEVICE_3WIRE|SPI_DEVICE_HALFDUPLEX,
    .command_bits = 0,
    .address_bits = 0,
    .mode = 0,
    .duty_cycle_pos = 0,
    .cs_ena_pretrans= 10,
    .clock_speed_hz = SPI_MASTER_FREQ_8M,
    .input_delay_ns = 0,
    .spics_io_num   = SPI_CS_IO_NUM,
    .queue_size     = 7,
    .pre_cb         = usr_spi_tran_cb
};
 
uint8_t temp_spi_data;
/* Send a command to the LCD. Uses spi_device_polling_transmit, which waits
 * until the transfer is complete.
 *
 * Since command transactions are usually small, they are handled in polling
 * mode for higher speed. The overhead of interrupt transactions is more than
 * just waiting for the transaction to complete.
 */
void lcd_cmd(const uint8_t cmd)
{
    esp_err_t ret;
    spi_transaction_t t;
    memset(&t, 0, sizeof(t));       //Zero out the transaction
 
    temp_spi_data = cmd;
 
    t.length=8;                     //Command is 8 bits
    t.tx_buffer=&temp_spi_data;     //The data is the cmd itself
    t.user=(void*)0;                //D/C needs to be set to 0
    ret=spi_device_polling_transmit(usr_spi_handler, &t);  //Transmit!
    assert(ret==ESP_OK);            //Should have had no issues.
}
 
/* Send data to the LCD. Uses spi_device_polling_transmit, which waits until the
 * transfer is complete.
 *
 * Since data transactions are usually small, they are handled in polling
 * mode for higher speed. The overhead of interrupt transactions is more than
 * just waiting for the transaction to complete.
 */
void lcd_data(const uint8_t data )
{
    esp_err_t ret;
    spi_transaction_t t;
 
    temp_spi_data = data;
 
    memset(&t, 0, sizeof(t));       //Zero out the transaction
    t.length    = 8;                //Len is in bytes, transaction length is in bits.
    t.tx_buffer = &temp_spi_data;   //Data
    t.user=(void*)1;                //D/C needs to be set to 1
    ret=spi_device_polling_transmit(usr_spi_handler, &t);  //Transmit!
    assert(ret==ESP_OK);            //Should have had no issues.
}
 
void ini_spi_test(void * arg )
{
    for ( ;; )
    {
        printf("Display Picture Start\n");
        gweh_test();
        printf("Display Picture End\n");
 
        vTaskDelay(60000/portTICK_RATE_MS);
    }
}
/* The event group allows multiple bits for each event,
   but we only care about one event - are we connected
   to the AP with an IP? */
static const int CONNECTED_BIT = BIT0;
static const int ESPTOUCH_DONE_BIT = BIT1;
 
void event_group_task(void * arg )
{
    static int   init_ok        = 0;
    EventBits_t  cur_event_flag = 0;
 
    ESP_ERROR_CHECK( esp_smartconfig_set_type(SC_TYPE_ESPTOUCH) );
    smartconfig_start_config_t cfg = SMARTCONFIG_START_CONFIG_DEFAULT();
    ESP_ERROR_CHECK( esp_smartconfig_start(&cfg) );
 
    for ( ;; )
    {
        cur_event_flag = xEventGroupWaitBits(s_wifi_event_group, 
                                            CONNECTED_BIT | ESPTOUCH_DONE_BIT,
                                            true, false, portMAX_DELAY );
 
        if (0x00 != (cur_event_flag&CONNECTED_BIT) )
        {
            printf("the device connected to AP\n");
        }
        else if (0x00 != (cur_event_flag&ESPTOUCH_DONE_BIT) )
        {
            printf("Config Done!");
 
            if (0x00 == init_ok )
            {
                init_ok = 1;
 
                xTaskCreate(esp_mqtt_app_start, "esp mqtt app", 2048, NULL, 10, NULL);
            }
 
            vTaskDelete(NULL );
        }
    }
}
 
static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void *event_data_arg )
{
    static uint8_t s_cnt   = 0;
    s_cnt++;
 
    if (WIFI_EVENT == event_base )
    {
        printf("------%d------ Wifi (%d) ", s_cnt, event_id);
 
        if (WIFI_EVENT_STA_START == event_id )
        {
            printf("WIFI_EVENT_STA_START\n" );
 
            xTaskCreate(event_group_task, "smartconfig_task", 4096, NULL, 3, NULL );
        }
        else if (WIFI_EVENT_STA_STOP == event_id )
        {
            printf("WIFI_EVENT_STA_STOP\n" );
        }
        else if (WIFI_EVENT_STA_CONNECTED == event_id )
        {
            printf("WIFI_EVENT_STA_CONNECTED\n" );
        }
        else if (WIFI_EVENT_SCAN_DONE == event_id )
        {
            printf("WIFI_EVENT_SCAN_DONE\n" );
        }
        else if (WIFI_EVENT_STA_DISCONNECTED == event_id )
        {
            printf("WIFI_EVENT_SCAN_DONE\n" );
            esp_wifi_connect();
        }
        else{
            printf("Unknow WIFI EVENT ID\n" );
        }
    }
    else if (IP_EVENT == event_base )
    {
        printf("------%d------ IP (%d) ", s_cnt, event_id);
 
        if (IP_EVENT_STA_GOT_IP == event_id )
        {
            /**
             * Device connect suceed.
            */
            printf("Unknow WIFI EVENT ID\n" );
        }
        else{
            printf("Unknow WIFI EVENT ID\n" );
        }
    }
    else if (SC_EVENT == event_base )
    {
        printf("------%d------ SC (%d) ", s_cnt, event_id);
 
        if (SC_EVENT_SCAN_DONE == event_id )
        {
            printf(" SCAN DONE(%d)\n", event_id );
        }
        else if (SC_EVENT_GOT_SSID_PSWD == event_id )
        {
            printf(" GOT SSID PSWD(%d)\n", event_id );
 
            smartconfig_event_got_ssid_pswd_t *evt = (smartconfig_event_got_ssid_pswd_t *)event_data_arg;
 
            wifi_config_t wifi_config;
            uint8_t ssid[33] = { 0 };
            uint8_t password[65] = { 0 };
 
            bzero(&wifi_config, sizeof(wifi_config_t) );
            memcpy(wifi_config.sta.ssid, evt->ssid, sizeof(wifi_config.sta.ssid) );
            memcpy(wifi_config.sta.password, evt->password, sizeof(wifi_config.sta.password) );
            wifi_config.sta.bssid_set = evt->bssid_set;
            if (true == wifi_config.sta.bssid_set ){
                memcpy(wifi_config.sta.bssid, evt->bssid, sizeof(wifi_config.sta.bssid) );
            }
 
            printf("Wifi ssid (%s)\n", wifi_config.sta.ssid);
            printf("Wifi password (%s)\n", wifi_config.sta.password);
            printf("Wifi bssid (%s)\n", wifi_config.sta.bssid);
 
            ESP_ERROR_CHECK(esp_wifi_disconnect() );
            ESP_ERROR_CHECK(esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_config ) );
            esp_wifi_connect();
 
            xEventGroupSetBits(s_wifi_event_group, CONNECTED_BIT );
        }
        else if (SC_EVENT_FOUND_CHANNEL == event_id )
        {
            printf(" FOUND CHANNEL(%d)\n", event_id );
        }
        else if (SC_EVENT_SEND_ACK_DONE == event_id )
        {
            printf(" ACK from DEVICE to ESPTOUCH (%d)\n", event_id );
            xEventGroupSetBits(s_wifi_event_group, ESPTOUCH_DONE_BIT );
        }
        else{
            printf(" Unknow SC Message (%d)\n", event_id );
        }
    }
    else{
        printf("Unknow EVENT BASE\n" );
    }
}
 
static void init_wifi(void )
{
    ESP_ERROR_CHECK(nvs_flash_init() );
 
    //static esp_partition_t * s_user_partiton  = NULL;
    // uint8_t *               usr_test_buf     = calloc(0x100, sizeof(uint8_t));
    // if (NULL == usr_test_buf )
    // {
    //     printf("Not have enough space\n");
    //     return;
    // }
 
    // int ret = 0x00;
    // memset(usr_test_buf, 0x00, 0x100);
 
    // /**
    //  * 打印flash 中数据。对flash中数据进行读写操作。
    // */
    // s_user_partiton = esp_partition_find_first(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_PHY, "usr_data" );
 
    // if (NULL == s_user_partiton )
    // {
    //     printf("find (usr_data) Err \n");
    // }
    // else{
    //     printf("Partiton esp_partition_type_t: %d\n", s_user_partiton->type );
    //     printf("Partiton esp_partition_subtype_t: %d\n", s_user_partiton->subtype );
 
    //     printf("Partiton label: %s\n", s_user_partiton->label );
    //     printf("Partiton address: 0x%08x\n", s_user_partiton->address );
    //     printf("Partiton size: %d\n", s_user_partiton->size );
    // }
    
    // /**
    //  * Read Partition.
    // */
    // ret = esp_partition_read(s_user_partiton, 0x00, usr_test_buf, 0x100 );
    // if (ESP_OK != ret )
    // {   printf("Read partiton Err %d", ret ); }
    // printf("Read data:\n");
    // for (int i = 0; i < 0x100; i++ )
    // {
    //     printf("0x%02x ", usr_test_buf[i] );
 
    //     if (63 == i%64 )
    //     {
    //         printf("\n");
    //     }
    // }
    // printf("Read data end\n");
 
    // /**
    //  * Write Partition.
    // */
    // memset(usr_test_buf, 0xaa, 0x100);
 
    // ret = esp_partition_erase_range(s_user_partiton, 0x00, 0x1000);
    // if (ESP_OK != ret )
    // {   printf("Erase partiton Err %d\n", ret ); }
    // else
    // {   printf("Erase partiton OK\n");}
 
    // ret = esp_partition_write(s_user_partiton, 0x00, usr_test_buf, 0x100 );
    // if (ESP_OK != ret )
    // {   printf("Write partiton Err %d\n", ret ); }
 
    // memset(usr_test_buf, 0x00, 0x100 );
 
    // /**
    //  * Read Partition Again.
    // */
    // ret = esp_partition_read(s_user_partiton, 0x00, usr_test_buf, 0x100 );
    // if (ESP_OK != ret )
    // {   printf("Read partiton Err %d", ret ); }
 
    // printf("Read data Again:\n");
    // for (int i = 0; i < 0x100; i++ )
    // {
    //     printf("0x%02x ", usr_test_buf[i] );
 
    //     if (63 == i%64 )
    //     {
    //         printf("\n");
    //     }
    // }
    
    // printf("Read data again end\n");
 
    // ret = esp_partition_erase_range(s_user_partiton, 0x00, 0x1000);
    // if (ESP_OK != ret )
    // {   printf("Erase partiton Err %d\n", ret ); }
    // else
    // {   printf("Erase partiton OK\n");}
 
    // memset(usr_test_buf, 0x55, 0x100);
 
    // ret = esp_partition_write(s_user_partiton, 0x00, usr_test_buf, 0x100 );
    // if (ESP_OK != ret )
    // {   printf("Write partiton Err %d", ret ); }
 
    // free(usr_test_buf);
 
    ESP_ERROR_CHECK(esp_netif_init() );
    s_wifi_event_group = xEventGroupCreate();
    ESP_ERROR_CHECK(esp_event_loop_create_default() );
    esp_netif_t * sta_netif = esp_netif_create_default_wifi_sta();
    /**
     * assert 用于判断指针是否为0. 若不为0，打印相关信息。
    */
    assert(sta_netif );
 
    /**
     * wifi 初始化.
    */
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg ) );
 
    /**
     * 注册事件处理方法.
    */
    ESP_ERROR_CHECK(esp_event_handler_register(WIFI_EVENT, ESP_EVENT_ANY_ID,    event_handler, NULL) );
    ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT,   IP_EVENT_STA_GOT_IP, event_handler, NULL) );
    ESP_ERROR_CHECK(esp_event_handler_register(SC_EVENT,   ESP_EVENT_ANY_ID, event_handler, NULL) );
 
    /**
     * 设置wifi模式，启动wifi
    */
   ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA) );
   ESP_ERROR_CHECK(esp_wifi_start() );
}
/**
 * Brief:
 * This test code shows how to configure gpio and how to use gpio interrupt.
 *
 * GPIO status:
 * GPIO18: output
 * GPIO19: output
 * GPIO4:  input, pulled up, interrupt from rising edge and falling edge
 * GPIO5:  input, pulled up, interrupt from rising edge.
 *
 * Test:
 * Connect GPIO18 with GPIO4
 * Connect GPIO19 with GPIO5
 * Generate pulses on GPIO18/19, that triggers interrupt on GPIO4/5
 *
 */
 
#define GPIO_OUTPUT_IO_0    25
#define GPIO_OUTPUT_IO_1    26
#define GPIO_OUTPUT_PIN_SEL  ((1ULL<<GPIO_OUTPUT_IO_0) | (1ULL<<GPIO_OUTPUT_IO_1))
#define GPIO_INPUT_IO_0     2
#define GPIO_INPUT_IO_1     15
#define GPIO_INPUT_PIN_SEL  ((1ULL<<GPIO_INPUT_IO_0) | (1ULL<<GPIO_INPUT_IO_1))
#define ESP_INTR_FLAG_DEFAULT 0
 
static xQueueHandle gpio_evt_queue = NULL;
 
static void IRAM_ATTR gpio_isr_handler(void* arg)
{
    uint32_t gpio_num = (uint32_t) arg;
    xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL);
}
 
static void gpio_task_example(void* arg)
{
    uint32_t io_num;
    for(;;) {
        if(xQueueReceive(gpio_evt_queue, &io_num, portMAX_DELAY)) {
            printf("GPIO[%d] intr, val: %d\n", io_num, gpio_get_level(io_num));
        }
    }
}
 
void app_main(void)
{
    gpio_config_t io_conf;
    //disable interrupt
    io_conf.intr_type = GPIO_PIN_INTR_DISABLE;
    //set as output mode
    io_conf.mode = GPIO_MODE_OUTPUT;
    //bit mask of the pins that you want to set,e.g.GPIO18/19
    io_conf.pin_bit_mask = GPIO_OUTPUT_PIN_SEL;
    //disable pull-down mode
    io_conf.pull_down_en = 0;
    //disable pull-up mode
    io_conf.pull_up_en = 0;
    //configure GPIO with the given settings
    gpio_config(&io_conf);
 
    //interrupt of rising edge
    io_conf.intr_type = GPIO_PIN_INTR_POSEDGE;
    //bit mask of the pins, use GPIO4/5 here
    io_conf.pin_bit_mask = GPIO_INPUT_PIN_SEL;
    //set as input mode    
    io_conf.mode = GPIO_MODE_INPUT;
    //enable pull-up mode
    io_conf.pull_up_en = 1;
    gpio_config(&io_conf);
 
    //change gpio intrrupt type for one pin
    gpio_set_intr_type(GPIO_INPUT_IO_0, GPIO_INTR_ANYEDGE);
 
    gpio_set_direction(SPI_DC_IO_NUM,   GPIO_MODE_OUTPUT );
    gpio_set_direction(SPI_RST_IO_NUM,  GPIO_MODE_OUTPUT );
    gpio_set_direction(SPI_BUSY_IO_NUM, GPIO_MODE_INPUT );
 
    spi_bus_initialize(SPI2_HOST, &buscfg, 0 );
    ESP_ERROR_CHECK(spi_bus_add_device(SPI2_HOST, &usr_spi_dev_cfg, &usr_spi_handler) );
 
    //create a queue to handle gpio event from isr
    gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t));
    //start gpio task
    xTaskCreate(gpio_task_example, "gpio_task_example", 2048, NULL, 10, NULL);
 
    //install gpio isr service
    gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT);
    //hook isr handler for specific gpio pin
    gpio_isr_handler_add(GPIO_INPUT_IO_0, gpio_isr_handler, (void*) GPIO_INPUT_IO_0);
    //hook isr handler for specific gpio pin
    gpio_isr_handler_add(GPIO_INPUT_IO_1, gpio_isr_handler, (void*) GPIO_INPUT_IO_1);
 
    //remove isr handler for gpio number.
    gpio_isr_handler_remove(GPIO_INPUT_IO_0);
    //hook isr handler for specific gpio pin again
    gpio_isr_handler_add(GPIO_INPUT_IO_0, gpio_isr_handler, (void*) GPIO_INPUT_IO_0);
 
    init_wifi();
 
    xTaskCreate(ini_spi_test, "ini spi test\n", 4096, NULL, 3, NULL );
 
    int cnt = 0;
    while(1) {
        printf("cnt: %d\n", cnt++);
        vTaskDelay(1000 / portTICK_RATE_MS);
        gpio_set_level(GPIO_OUTPUT_IO_0, cnt % 2);
        gpio_set_level(GPIO_OUTPUT_IO_1, cnt % 2);
    }
}
 

GeSHi © Codebox Plus Extension

Code: [Select all] [Expand/Collapse]

E (861562) TRANS_TCP: [sock=54] delayed connect error: Connection reset by peer
E (861562) MQTT_CLIENT: Error transport connect

GeSHi © Codebox Plus Extension

使用ESP Touch连接wifi成功，但是不能连接EMQ远端MQTT服务器。

Posted: **Thu Jun 17, 2021 4:12 am**

你应该是要去连你 PC 上的 MQTT server，而非 127.0.0.1 吧。

Posted: **Thu Jun 17, 2021 5:08 am**

: MQTT.png (236.65 KiB) Viewed 4950 times

PC端的定义的MQTT Client 可以连接到MQTT Server.

Posted: **Thu Jun 17, 2021 5:33 am**

你先看下：https://baike.baidu.com/item/127.0.0.1

Posted: **Thu Jun 17, 2021 6:03 am**

Code: [Select all] [Expand/Collapse]

static void mqtt_event_handler(void* arg, esp_event_base_t event_base,
                               int32_t event_id, void* event_data )
{
    printf("event ID %d\n", event_id );
 
    switch(event_id )
    {
        case MQTT_EVENT_CONNECTED:
            if (0 == mqtt_state )
            {
                mqtt_state = 1;
            }
 
            printf("MQTT_EVENT_CONNECTED\n" );
            
            esp_mqtt_client_subscribe(mqtt_client, "Test_1", 2 );
            esp_mqtt_client_subscribe(mqtt_client, "Test_2", 1 );
            esp_mqtt_client_subscribe(mqtt_client, "Picture", 2 );
        break;
 
        case MQTT_EVENT_DISCONNECTED:
            if (0 != mqtt_state )
            {
                mqtt_state = 0;
            }
 
            printf("MQTT_EVENT_DISCONNECTED\n" );
        break;
 
        case MQTT_EVENT_SUBSCRIBED:
            printf("MQTT_EVENT_SUBSCRIBED\n" );
        break;
 
        case MQTT_EVENT_UNSUBSCRIBED:
            printf("MQTT_EVENT_DISCONNECTED\n" );
        break;
 
        case MQTT_EVENT_PUBLISHED:
            printf("MQTT_EVENT_PUBLISHED\n" );
        break;
 
        case MQTT_EVENT_DATA:
            printf("MQTT_EVENT_DATA\n" );
 
            // printf("topic length:%d data length:%d\n",event->topic_len,event->data_len);
 
            // printf("TOPIC=%.*s\r\n", event->topic_len, event->topic);
            // printf("DATA=%.*s\r\n", event->data_len, event->data);
        break;
 
        case MQTT_EVENT_ERROR:
            printf("MQTT_EVENT_ERROR (%s)\n", (char *)event_data);
        break;
 
        default:
            printf("Other event id:%d\n", event_id );
        break;
    }
}
esp_mqtt_client_register_event(mqtt_client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL)；

请问使用这个回调函数，如何获取数据信息呢？

Posted: **Thu Jun 17, 2021 8:27 am**

https://jeason.blog.csdn.net/article/details/116462207
通过参考这个博客，可以了解如何处理接收的数据。

ESP32 Forum

[已解决] 连接MQTT服务器异常

[已解决] 连接MQTT服务器异常

Re: 连接MQTT服务器异常

Re: 连接MQTT服务器异常

Re: 连接MQTT服务器异常

Re: 连接MQTT服务器异常

Re: [已解决] 连接MQTT服务器异常