text: #include <stdio.h>
  #include <stdio.h>
  #include <stdint.h>
  #include <stddef.h>
  #include <string.h>
  
  #include "esp_system.h"
  #include "esp_event.h"
  #include "esp_netif.h"
  
  #include "freertos/FreeRTOS.h"
  #include "freertos/task.h"
  #include "freertos/semphr.h"
  #include "freertos/queue.h"
  // #include "freertos/event_groups.h"
  
  #include "lwip/sockets.h"
  #include "lwip/dns.h"
  #include "lwip/netdb.h"
  // #include "lwip/err.h"
  // #include "lwip/sys.h"
  
  #include "esp_log.h"
  #include "mqtt_client.h"
  
  #include "Mqtt_app.h"
  
  static const char *TAG = "MQTT_app";
  
  extern SemaphoreHandle_t mqttConectionSemaphore;
  
  //The examples use MQTT configuration that you can set via project configuration menu
  #define EXAMPLE_BROKER_URL CONFIG_BROKER_URL
  #define EXAMPLE_ESP_ESP_MQTT_USER CONFIG_ESP_MQTT_USER
  #define EXAMPLE_ESP_MQTT_PASSWORD CONFIG_ESP_MQTT_PASSWORD
  
  
  static void log_error_if_nonzero(const char *message, int error_code)
  {
      if (error_code != 0) {
          ESP_LOGE(TAG, "Last error %s: 0x%x", message, error_code);
      }
  }
  
  /*
   * @brief Event handler registered to receive MQTT events
   *
   *  This function is called by the MQTT client event loop.
   *
   * @param handler_args user data registered to the event.
   * @param base Event base for the handler(always MQTT Base in this example).
   * @param event_id The id for the received event.
   * @param event_data The data for the event, esp_mqtt_event_handle_t.
   */
  static void mqtt_event_handler(void *handler_args, esp_event_base_t base, int32_t event_id, void *event_data)
  {
      ESP_LOGD(TAG, "Event dispatched from event loop base=%s, event_id=%d", base, event_id);
      esp_mqtt_event_handle_t event = event_data;
      esp_mqtt_client_handle_t client = event->client;
      int msg_id;
      switch ((esp_mqtt_event_id_t)event_id) {
      case MQTT_EVENT_CONNECTED:
          ESP_LOGI(TAG, "MQTT_EVENT_CONNECTED");
          msg_id = esp_mqtt_client_publish(client, "/topic_lsantos/qos1", "data_3", 0, 1, 0);
          ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
  
          msg_id = esp_mqtt_client_subscribe(client, "/topic_lsantos/qos0", 0);
          ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
  
          msg_id = esp_mqtt_client_subscribe(client, "/topic_lsantos/qos1", 1);
          ESP_LOGI(TAG, "sent subscribe successful, msg_id=%d", msg_id);
  
          msg_id = esp_mqtt_client_unsubscribe(client, "/topic_lsantos/qos1");
          ESP_LOGI(TAG, "sent unsubscribe successful, msg_id=%d", msg_id);
          break;
      case MQTT_EVENT_DISCONNECTED:
          ESP_LOGI(TAG, "MQTT_EVENT_DISCONNECTED");
          break;
  
      case MQTT_EVENT_SUBSCRIBED:
          ESP_LOGI(TAG, "MQTT_EVENT_SUBSCRIBED, msg_id=%d", event->msg_id);
          msg_id = esp_mqtt_client_publish(client, "/topic_lsantos/qos0", "data", 0, 0, 0);
          ESP_LOGI(TAG, "sent publish successful, msg_id=%d", msg_id);
          break;
      case MQTT_EVENT_UNSUBSCRIBED:
          ESP_LOGI(TAG, "MQTT_EVENT_UNSUBSCRIBED, msg_id=%d", event->msg_id);
          break;
      case MQTT_EVENT_PUBLISHED:
          ESP_LOGI(TAG, "MQTT_EVENT_PUBLISHED, msg_id=%d", event->msg_id);
          break;
      case MQTT_EVENT_DATA:
          ESP_LOGI(TAG, "MQTT_EVENT_DATA");
          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:
          ESP_LOGI(TAG, "MQTT_EVENT_ERROR");
          if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
              log_error_if_nonzero("reported from esp-tls", event->error_handle->esp_tls_last_esp_err);
              log_error_if_nonzero("reported from tls stack", event->error_handle->esp_tls_stack_err);
              log_error_if_nonzero("captured as transport's socket errno",  event->error_handle->esp_transport_sock_errno);
              ESP_LOGI(TAG, "Last errno string (%s)", strerror(event->error_handle->esp_transport_sock_errno));
  
          }
          break;
      default:
          ESP_LOGI(TAG, "Other event id:%d", event->event_id);
          break;
      }
  }
  
  void mqtt_app_start(void)
  {
      esp_mqtt_client_config_t mqtt_cfg = {
          .uri = EXAMPLE_BROKER_URL,
          .username = EXAMPLE_ESP_ESP_MQTT_USER,
          .password = EXAMPLE_ESP_MQTT_PASSWORD,
      };
  #if CONFIG_BROKER_URL_FROM_STDIN
      char line[128];
  
      if (strcmp(mqtt_cfg.uri, "FROM_STDIN") == 0) {
          int count = 0;
          printf("Please enter url of mqtt broker\n");
          while (count < 128) {
              int c = fgetc(stdin);
              if (c == '\n') {
                  line[count] = '\0';
                  break;
              } else if (c > 0 && c < 127) {
                  line[count] = c;
                  ++count;
              }
              vTaskDelay(10 / portTICK_PERIOD_MS);
          }
          mqtt_cfg.uri = line;
          printf("Broker url: %s\n", line);
      } else {
          ESP_LOGE(TAG, "Configuration mismatch: wrong broker url");
          abort();
      }
  #endif /* CONFIG_BROKER_URL_FROM_STDIN */
  
      esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg);
      /* The last argument may be used to pass data to the event handler, in this example mqtt_event_handler */
      esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
      //esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, client);
      esp_mqtt_client_start(client);
  }
  