405 lines
11 KiB
C
405 lines
11 KiB
C
#include "mqtt_manager.h"
|
|
#include "esp_log.h"
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
static const char *TAG = "MQTT_MANAGER";
|
|
|
|
// MQTT manager state
|
|
static bool is_initialized = false;
|
|
static mqtt_status_t current_status = MQTT_STATUS_DISCONNECTED;
|
|
static esp_mqtt_client_handle_t mqtt_client = NULL;
|
|
static mqtt_event_callback_t user_callback = NULL;
|
|
|
|
// MQTT event handler
|
|
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;
|
|
|
|
switch ((esp_mqtt_event_id_t)event_id)
|
|
{
|
|
case MQTT_EVENT_BEFORE_CONNECT:
|
|
ESP_LOGI(TAG, "MQTT connecting to broker...");
|
|
current_status = MQTT_STATUS_CONNECTING;
|
|
if (user_callback)
|
|
{
|
|
user_callback(current_status, NULL, NULL, 0);
|
|
}
|
|
break;
|
|
|
|
case MQTT_EVENT_CONNECTED:
|
|
ESP_LOGI(TAG, "MQTT connected to broker");
|
|
current_status = MQTT_STATUS_CONNECTED;
|
|
if (user_callback)
|
|
{
|
|
user_callback(current_status, NULL, NULL, 0);
|
|
}
|
|
break;
|
|
|
|
case MQTT_EVENT_DISCONNECTED:
|
|
ESP_LOGI(TAG, "MQTT disconnected from broker");
|
|
current_status = MQTT_STATUS_DISCONNECTED;
|
|
if (user_callback)
|
|
{
|
|
user_callback(current_status, NULL, NULL, 0);
|
|
}
|
|
break;
|
|
|
|
case MQTT_EVENT_PUBLISHED:
|
|
ESP_LOGD(TAG, "MQTT message published, msg_id=%d", event->msg_id);
|
|
break;
|
|
|
|
case MQTT_EVENT_DATA:
|
|
ESP_LOGD(TAG, "MQTT data received - Topic: %.*s, Data: %.*s",
|
|
event->topic_len, event->topic,
|
|
event->data_len, event->data);
|
|
if (user_callback)
|
|
{
|
|
// Null-terminate the topic and data for callback
|
|
char topic_str[256];
|
|
char data_str[512];
|
|
int topic_len = (event->topic_len < sizeof(topic_str) - 1) ? event->topic_len : sizeof(topic_str) - 1;
|
|
int data_len = (event->data_len < sizeof(data_str) - 1) ? event->data_len : sizeof(data_str) - 1;
|
|
|
|
memcpy(topic_str, event->topic, topic_len);
|
|
topic_str[topic_len] = '\0';
|
|
|
|
memcpy(data_str, event->data, data_len);
|
|
data_str[data_len] = '\0';
|
|
|
|
user_callback(current_status, topic_str, data_str, data_len);
|
|
}
|
|
break;
|
|
|
|
case MQTT_EVENT_ERROR:
|
|
ESP_LOGE(TAG, "MQTT error occurred, error_handle->error_type: %d", event->error_handle->error_type);
|
|
current_status = MQTT_STATUS_ERROR;
|
|
if (user_callback)
|
|
{
|
|
user_callback(current_status, NULL, NULL, 0);
|
|
}
|
|
break;
|
|
|
|
case MQTT_EVENT_SUBSCRIBED:
|
|
ESP_LOGD(TAG, "MQTT subscribed, msg_id=%d", event->msg_id);
|
|
break;
|
|
|
|
case MQTT_EVENT_UNSUBSCRIBED:
|
|
ESP_LOGD(TAG, "MQTT unsubscribed, msg_id=%d", event->msg_id);
|
|
break;
|
|
|
|
case MQTT_EVENT_DELETED:
|
|
ESP_LOGD(TAG, "MQTT client deleted");
|
|
break;
|
|
|
|
case MQTT_USER_EVENT:
|
|
case MQTT_EVENT_ANY:
|
|
default:
|
|
ESP_LOGD(TAG, "MQTT event: %d", event_id);
|
|
break;
|
|
}
|
|
}
|
|
|
|
esp_err_t mqtt_manager_init(const mqtt_config_t *config, mqtt_event_callback_t event_callback)
|
|
{
|
|
if (is_initialized)
|
|
{
|
|
ESP_LOGW(TAG, "MQTT manager already initialized");
|
|
return ESP_OK;
|
|
}
|
|
|
|
if (config == NULL || config->broker_url == NULL || config->client_id == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "Invalid MQTT configuration");
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Initializing MQTT manager");
|
|
ESP_LOGI(TAG, "MQTT Broker: %s:%d", config->broker_url, config->broker_port);
|
|
ESP_LOGI(TAG, "MQTT Client ID: %s", config->client_id);
|
|
|
|
user_callback = event_callback;
|
|
current_status = MQTT_STATUS_DISCONNECTED;
|
|
|
|
// Configure MQTT client
|
|
esp_mqtt_client_config_t mqtt_cfg = {
|
|
.broker.address.uri = config->broker_url,
|
|
.credentials.client_id = config->client_id,
|
|
.network.timeout_ms = config->network_timeout_ms > 0 ? config->network_timeout_ms : 10000,
|
|
.network.refresh_connection_after_ms = 20000,
|
|
.session.keepalive = config->keepalive > 0 ? config->keepalive : 60,
|
|
};
|
|
|
|
// Set port if specified
|
|
if (config->broker_port > 0)
|
|
{
|
|
mqtt_cfg.broker.address.port = config->broker_port;
|
|
}
|
|
|
|
// Set credentials if provided
|
|
if (config->username && strlen(config->username) > 0)
|
|
{
|
|
mqtt_cfg.credentials.username = config->username;
|
|
}
|
|
if (config->password && strlen(config->password) > 0)
|
|
{
|
|
mqtt_cfg.credentials.authentication.password = config->password;
|
|
}
|
|
|
|
if (config->ca_cert_pem && strlen(config->ca_cert_pem) > 0)
|
|
{
|
|
mqtt_cfg.broker.verification.certificate = config->ca_cert_pem;
|
|
}
|
|
|
|
// Initialize MQTT client
|
|
mqtt_client = esp_mqtt_client_init(&mqtt_cfg);
|
|
if (mqtt_client == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to initialize MQTT client");
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
// Register event handler
|
|
esp_err_t ret = esp_mqtt_client_register_event(mqtt_client, ESP_EVENT_ANY_ID, mqtt_event_handler, NULL);
|
|
if (ret != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to register MQTT event handler: %s", esp_err_to_name(ret));
|
|
esp_mqtt_client_destroy(mqtt_client);
|
|
mqtt_client = NULL;
|
|
return ret;
|
|
}
|
|
|
|
is_initialized = true;
|
|
ESP_LOGI(TAG, "MQTT manager initialized successfully");
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t mqtt_manager_start(void)
|
|
{
|
|
if (!is_initialized || mqtt_client == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "MQTT manager not initialized");
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Starting MQTT client");
|
|
esp_err_t ret = esp_mqtt_client_start(mqtt_client);
|
|
if (ret != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to start MQTT client: %s", esp_err_to_name(ret));
|
|
current_status = MQTT_STATUS_ERROR;
|
|
return ret;
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t mqtt_manager_stop(void)
|
|
{
|
|
if (!is_initialized || mqtt_client == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "MQTT manager not initialized");
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Stopping MQTT client");
|
|
current_status = MQTT_STATUS_DISCONNECTED;
|
|
|
|
esp_err_t ret = esp_mqtt_client_stop(mqtt_client);
|
|
if (ret != ESP_OK)
|
|
{
|
|
ESP_LOGE(TAG, "Failed to stop MQTT client: %s", esp_err_to_name(ret));
|
|
return ret;
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
mqtt_status_t mqtt_manager_get_status(void)
|
|
{
|
|
return current_status;
|
|
}
|
|
|
|
int mqtt_manager_publish(const char *topic, const char *data, int len, int qos, int retain)
|
|
{
|
|
if (!is_initialized || mqtt_client == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "MQTT manager not initialized");
|
|
return -1;
|
|
}
|
|
|
|
if (current_status != MQTT_STATUS_CONNECTED)
|
|
{
|
|
ESP_LOGW(TAG, "MQTT not connected, cannot publish");
|
|
return -1;
|
|
}
|
|
|
|
if (topic == NULL || data == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "Topic or data is NULL");
|
|
return -1;
|
|
}
|
|
|
|
int data_len = (len == 0) ? strlen(data) : len;
|
|
int msg_id = esp_mqtt_client_publish(mqtt_client, topic, data, data_len, qos, retain);
|
|
|
|
if (msg_id >= 0)
|
|
{
|
|
ESP_LOGD(TAG, "Published to topic '%s', msg_id=%d", topic, msg_id);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(TAG, "Failed to publish to topic '%s'", topic);
|
|
}
|
|
|
|
return msg_id;
|
|
}
|
|
|
|
int mqtt_manager_publish_string(const char *topic, const char *message, int qos, int retain)
|
|
{
|
|
return mqtt_manager_publish(topic, message, 0, qos, retain);
|
|
}
|
|
|
|
int mqtt_manager_publish_sensor_data(const char *topic, float temperature, float humidity, const char *device_id, int qos, int retain)
|
|
{
|
|
if (topic == NULL || device_id == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "Topic or device_id is NULL");
|
|
return -1;
|
|
}
|
|
|
|
char json_data[256];
|
|
int len = snprintf(json_data, sizeof(json_data),
|
|
"{\"temperature\":%.2f,\"humidity\":%.2f,\"device\":\"%s\"}",
|
|
temperature, humidity, device_id);
|
|
|
|
if (len >= sizeof(json_data))
|
|
{
|
|
ESP_LOGW(TAG, "JSON data truncated");
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Publishing sensor data - Temp: %.2f°C, Humidity: %.2f%%", temperature, humidity);
|
|
return mqtt_manager_publish(topic, json_data, 0, qos, retain);
|
|
}
|
|
|
|
int mqtt_manager_subscribe(const char *topic, int qos)
|
|
{
|
|
if (!is_initialized || mqtt_client == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "MQTT manager not initialized");
|
|
return -1;
|
|
}
|
|
|
|
if (current_status != MQTT_STATUS_CONNECTED)
|
|
{
|
|
ESP_LOGW(TAG, "MQTT not connected, cannot subscribe");
|
|
return -1;
|
|
}
|
|
|
|
if (topic == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "Topic is NULL");
|
|
return -1;
|
|
}
|
|
|
|
int msg_id = esp_mqtt_client_subscribe(mqtt_client, topic, qos);
|
|
|
|
if (msg_id >= 0)
|
|
{
|
|
ESP_LOGI(TAG, "Subscribed to topic '%s', msg_id=%d", topic, msg_id);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(TAG, "Failed to subscribe to topic '%s'", topic);
|
|
}
|
|
|
|
return msg_id;
|
|
}
|
|
|
|
int mqtt_manager_unsubscribe(const char *topic)
|
|
{
|
|
if (!is_initialized || mqtt_client == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "MQTT manager not initialized");
|
|
return -1;
|
|
}
|
|
|
|
if (current_status != MQTT_STATUS_CONNECTED)
|
|
{
|
|
ESP_LOGW(TAG, "MQTT not connected, cannot unsubscribe");
|
|
return -1;
|
|
}
|
|
|
|
if (topic == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "Topic is NULL");
|
|
return -1;
|
|
}
|
|
|
|
int msg_id = esp_mqtt_client_unsubscribe(mqtt_client, topic);
|
|
|
|
if (msg_id >= 0)
|
|
{
|
|
ESP_LOGI(TAG, "Unsubscribed from topic '%s', msg_id=%d", topic, msg_id);
|
|
}
|
|
else
|
|
{
|
|
ESP_LOGE(TAG, "Failed to unsubscribe from topic '%s'", topic);
|
|
}
|
|
|
|
return msg_id;
|
|
}
|
|
|
|
bool mqtt_manager_is_connected(void)
|
|
{
|
|
return current_status == MQTT_STATUS_CONNECTED;
|
|
}
|
|
|
|
esp_err_t mqtt_manager_reconnect(void)
|
|
{
|
|
if (!is_initialized || mqtt_client == NULL)
|
|
{
|
|
ESP_LOGE(TAG, "MQTT manager not initialized");
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Forcing MQTT reconnection");
|
|
|
|
// Stop and restart the client
|
|
esp_err_t ret = mqtt_manager_stop();
|
|
if (ret != ESP_OK)
|
|
{
|
|
return ret;
|
|
}
|
|
|
|
// Small delay before restarting
|
|
vTaskDelay(pdMS_TO_TICKS(1000));
|
|
|
|
return mqtt_manager_start();
|
|
}
|
|
|
|
esp_err_t mqtt_manager_deinit(void)
|
|
{
|
|
if (!is_initialized)
|
|
{
|
|
ESP_LOGW(TAG, "MQTT manager not initialized");
|
|
return ESP_OK;
|
|
}
|
|
|
|
ESP_LOGI(TAG, "Deinitializing MQTT manager");
|
|
|
|
// Stop client if running
|
|
if (mqtt_client != NULL)
|
|
{
|
|
esp_mqtt_client_stop(mqtt_client);
|
|
esp_mqtt_client_destroy(mqtt_client);
|
|
mqtt_client = NULL;
|
|
}
|
|
|
|
current_status = MQTT_STATUS_DISCONNECTED;
|
|
user_callback = NULL;
|
|
is_initialized = false;
|
|
|
|
ESP_LOGI(TAG, "MQTT manager deinitialized");
|
|
return ESP_OK;
|
|
} |