mqtt_app.c

Go to the documentation of this file.

 
#include "mqtt_app.h"
 
#include <stdio.h>
 
#include "esp_check.h"
#include "esp_crt_bundle.h"
#include "esp_log.h"
#include "esp_mac.h"
#include "mqtt_client.h"
 
static const char *TAG = "mqtt_app";
 
#define MQTT_BROKER_URI         "mqtts://microtec-lab.ru:8883"
 
#define MQTT_USERNAME           "ozlocks_mqtt"
#define MQTT_PASSWORD           "Tr0cK's_57$Y74"
 
#define MQTT_CLIENT_ID_PREFIX   "ozl-mb"
 
static esp_mqtt_client_handle_t s_mqtt_client;
static bool s_mqtt_connected;
static char s_client_id[24];
 
static void build_client_id(void)
{
    uint8_t mac[6];
    esp_read_mac(mac, ESP_MAC_ETH);
    snprintf(s_client_id, sizeof(s_client_id),
             MQTT_CLIENT_ID_PREFIX "-%02X%02X%02X%02X%02X%02X",
             mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
    ESP_LOGI(TAG, "Client ID: %s", s_client_id);
}
 
const char *mqtt_app_get_client_id(void)
{
    if (s_client_id[0] == '\0') {
        build_client_id();
    }
    return s_client_id;
}
 
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 = event_data;
    // esp_mqtt_client_handle_t client = event->client;
 
    switch ((esp_mqtt_event_id_t)event_id) {
    case MQTT_EVENT_CONNECTED:
        s_mqtt_connected = true;
        ESP_LOGI(TAG, "Connected to broker");
        break;
 
    case MQTT_EVENT_DISCONNECTED:
        s_mqtt_connected = false;
        ESP_LOGI(TAG, "Disconnected from broker");
        break;
 
    case MQTT_EVENT_PUBLISHED:
        ESP_LOGD(TAG, "Message published, msg_id=%d", event->msg_id);
        break;
 
    case MQTT_EVENT_ERROR:
        ESP_LOGE(TAG, "MQTT error");
        if (event->error_handle->error_type == MQTT_ERROR_TYPE_TCP_TRANSPORT) {
            ESP_LOGE(TAG, "Transport error: esp_tls=%d, tls_stack=%d, sock_errno=%d",
                     event->error_handle->esp_tls_last_esp_err,
                     event->error_handle->esp_tls_stack_err,
                     event->error_handle->esp_transport_sock_errno);
        }
        break;
 
    default:
        break;
    }
}
 
esp_err_t mqtt_app_start(void)
{
    if (s_mqtt_client != NULL) {
        ESP_LOGW(TAG, "MQTT client already running");
        return ESP_OK;
    }
 
    mqtt_app_get_client_id();
 
    esp_mqtt_client_config_t mqtt_cfg = {
        .broker.address.uri = MQTT_BROKER_URI,
        .broker.verification.crt_bundle_attach = esp_crt_bundle_attach,
        .credentials.client_id = s_client_id,
        .credentials.username = MQTT_USERNAME,
        .credentials.authentication.password = MQTT_PASSWORD,
    };
 
    s_mqtt_client = esp_mqtt_client_init(&mqtt_cfg);
    ESP_RETURN_ON_FALSE(s_mqtt_client, ESP_ERR_NO_MEM, TAG, "mqtt init failed");
 
    ESP_RETURN_ON_ERROR(esp_mqtt_client_register_event(s_mqtt_client, ESP_EVENT_ANY_ID,
                                                       mqtt_event_handler, NULL),
                        TAG, "event register failed");
 
    ESP_RETURN_ON_ERROR(esp_mqtt_client_start(s_mqtt_client), TAG, "mqtt start failed");
 
    ESP_LOGI(TAG, "Connecting to %s, client_id=%s, user=%s",
             MQTT_BROKER_URI, s_client_id, MQTT_USERNAME);
    return ESP_OK;
}
 
esp_err_t mqtt_app_stop(void)
{
    if (s_mqtt_client == NULL) {
        return ESP_OK;
    }
 
    ESP_LOGI(TAG, "Stopping MQTT client");
    esp_mqtt_client_stop(s_mqtt_client);
    esp_mqtt_client_destroy(s_mqtt_client);
    s_mqtt_client = NULL;
    s_mqtt_connected = false;
 
    return ESP_OK;
}
 
bool mqtt_app_is_connected(void)
{
    return s_mqtt_connected;
}
 
esp_err_t mqtt_app_publish(const char *topic, const char *data, int qos, int retain)
{
    if (!s_mqtt_connected || s_mqtt_client == NULL) {
        return ESP_ERR_INVALID_STATE;
    }
 
    int msg_id = esp_mqtt_client_publish(s_mqtt_client, topic, data, 0, qos, retain);
    if (msg_id < 0) {
        return ESP_FAIL;
    }
 
    ESP_LOGI(TAG, "Published to %s: %s", topic, data);
    return ESP_OK;
}