Uso seguro de MQTT con TLS/SSL

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

// ==================== CONFIGURACIÓN DE RED ====================
const char* ssid = "TU_WIFI_SSID";
const char* password = "TU_WIFI_PASSWORD";

// ==================== CONFIGURACIÓN MQTT SEGURO ====================
const char* mqtt_server = "mqtt.industrialiot.com";  
const int mqtt_port = 8883;  // Puerto seguro MQTT sobre TLS
const char* mqtt_username = "esp32_client";
const char* mqtt_password = "secure_password_2024";
const char* client_id = "ESP32_Factory_001";

// ==================== CERTIFICADOS TLS ====================
const char* ca_cert = \
"-----BEGIN CERTIFICATE-----\n" \
"MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF\n" \
"ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6\n" \
"... [certificado completo aquí] ...\n" \
"-----END CERTIFICATE-----\n";

// ==================== OBJETOS PRINCIPALES ====================
WiFiClientSecure espClient;
PubSubClient client(espClient);

// ==================== VARIABLES DE SENSORES ====================
float temperature = 0.0;
float humidity = 0.0;
unsigned long lastSensorRead = 0;
const unsigned long sensorInterval = 30000; // 30 segundos

// ==================== CONFIGURACIÓN INICIAL ====================
void setup() {
    Serial.begin(115200);
    Serial.println("🚀 ESP32 MQTT TLS/SSL Client v2.0");
    
    // Inicializar pines de sensores
    pinMode(2, OUTPUT); // LED indicador
    
    // Conectar a WiFi
    setupWiFi();
    
    // Configurar cliente MQTT seguro
    setupMQTTSecure();
    
    Serial.println("✅ Sistema iniciado correctamente");
}

// ==================== CONFIGURACIÓN WIFI ====================
void setupWiFi() {
    Serial.print("🌐 Conectando a WiFi: ");
    Serial.println(ssid);
    
    WiFi.begin(ssid, password);
    
    int attempts = 0;
    while (WiFi.status() != WL_CONNECTED && attempts < 20) {
        delay(1000);
        Serial.print(".");
        attempts++;
    }
    
    if (WiFi.status() == WL_CONNECTED) {
        Serial.println("\n✅ WiFi conectado!");
        Serial.print("📍 IP address: ");
        Serial.println(WiFi.localIP());
        Serial.print("📡 Signal strength: ");
        Serial.println(WiFi.RSSI());
    } else {
        Serial.println("\n❌ Error: No se pudo conectar a WiFi");
        ESP.restart();
    }
}

// ==================== CONFIGURACIÓN MQTT SEGURO ====================
void setupMQTTSecure() {
    Serial.println("🔐 Configurando conexión MQTT segura...");
    
    // Configurar certificado CA para validar servidor
    espClient.setCACert(ca_cert);
    
    // Opcional: Configurar certificado de cliente para autenticación mutua
    // espClient.setCertificate(client_cert);
    // espClient.setPrivateKey(client_key);
    
    // Configurar servidor MQTT
    client.setServer(mqtt_server, mqtt_port);
    client.setCallback(messageCallback);
    
    // Buffer más grande para mensajes JSON
    client.setBufferSize(1024);
    
    Serial.println("✅ Configuración MQTT completada");
}

// ==================== CALLBACK PARA MENSAJES RECIBIDOS ====================
void messageCallback(char* topic, byte* payload, unsigned int length) {
    Serial.print("📨 Mensaje recibido en tópico: ");
    Serial.println(topic);
    
    // Convertir payload a string
    String message = "";
    for (int i = 0; i < length; i++) {
        message += (char)payload[i];
    }
    
    Serial.print("💬 Mensaje: ");
    Serial.println(message);
    
    // Procesar comandos remotos
    processRemoteCommand(topic, message);
}

// ==================== PROCESAMIENTO DE COMANDOS REMOTOS ====================
void processRemoteCommand(String topic, String message) {
    if (topic.endsWith("/commands")) {
        JsonDocument doc;
        deserializeJson(doc, message);
        
        String command = doc["cmd"];
        if (command == "restart") {
            Serial.println("🔄 Comando de reinicio recibido");
            delay(1000);
            ESP.restart();
        }
        else if (command == "led_on") {
            digitalWrite(2, HIGH);
            Serial.println("💡 LED encendido por comando remoto");
        }
        else if (command == "led_off") {
            digitalWrite(2, LOW);
            Serial.println("💡 LED apagado por comando remoto");
        }
    }
}

// ==================== BUCLE PRINCIPAL ====================
void loop() {
    // Mantener conexión MQTT
    if (!client.connected()) {
        reconnectMQTT();
    }
    client.loop();
    
    // Leer sensores cada 30 segundos
    if (millis() - lastSensorRead > sensorInterval) {
        readSensors();
        publishSensorData();
        lastSensorRead = millis();
    }
    
    delay(100); // Pequeño delay para estabilidad
}

// ==================== RECONEXIÓN MQTT ====================
void reconnectMQTT() {
    Serial.println("🔄 Intentando reconexión MQTT...");
    
    while (!client.connected()) {
        Serial.print("🔌 Conectando a broker MQTT: ");
        Serial.println(mqtt_server);
        
        if (client.connect(client_id, mqtt_username, mqtt_password)) {
            Serial.println("✅ Conectado al broker MQTT!");
            
            // Suscribirse a tópicos de comandos
            String commandTopic = String("factory/esp32/") + client_id + "/commands";
            client.subscribe(commandTopic.c_str());
            Serial.println("📥 Suscrito a: " + commandTopic);
            
            // Publicar mensaje de conectividad
            publishConnectionStatus(true);
            
        } else {
            Serial.print("❌ Error de conexión MQTT, rc=");
            Serial.println(client.state());
            Serial.println("🔄 Reintentando en 5 segundos...");
            delay(5000);
        }
    }
}

// ==================== LECTURA DE SENSORES ====================
void readSensors() {
    // Simular lectura de sensores (reemplazar con código real)
    temperature = 22.5 + random(-50, 50) / 10.0; // Simular variación
    humidity = 65.0 + random(-100, 100) / 10.0;
    
    // Parpadear LED para indicar lectura
    digitalWrite(2, HIGH);
    delay(100);
    digitalWrite(2, LOW);
}

// ==================== PUBLICACIÓN DE DATOS ====================
void publishSensorData() {
    JsonDocument doc;
    
    // Crear payload JSON con datos del sensor
    doc["device_id"] = client_id;
    doc["timestamp"] = millis();
    doc["temperature"] = temperature;
    doc["humidity"] = humidity;
    doc["wifi_rssi"] = WiFi.RSSI();
    doc["free_heap"] = ESP.getFreeHeap();
    doc["uptime"] = millis() / 1000;
    
    String jsonString;
    serializeJson(doc, jsonString);
    
    // Publicar en múltiples tópicos
    String dataTopic = String("factory/sensors/") + client_id + "/data";
    
    if (client.publish(dataTopic.c_str(), jsonString.c_str(), true)) { // retained=true
        Serial.println("📤 Datos publicados: " + jsonString);
    } else {
        Serial.println("❌ Error al publicar datos");
    }
}

// ==================== PUBLICAR ESTADO DE CONEXIÓN ====================
void publishConnectionStatus(bool connected) {
    JsonDocument doc;
    doc["device_id"] = client_id;
    doc["connected"] = connected;
    doc["timestamp"] = millis();
    doc["ip_address"] = WiFi.localIP().toString();
    
    String jsonString;
    serializeJson(doc, jsonString);
    
    String statusTopic = String("factory/status/") + client_id;
    client.publish(statusTopic.c_str(), jsonString.c_str(), true);
    
    Serial.println(connected ? "🟢 Estado: Conectado" : "🔴 Estado: Desconectado");
}