Protocolos de comunicación: HTTP vs MQTT

#include <WiFi.h>
#include <HTTPClient.h>
#include <DHT.h>
#include <ArduinoJson.h>

// Configuración WiFi
const char* ssid = "TU_RED_WIFI";
const char* password = "TU_PASSWORD";

// Configuración servidor
const char* serverURL = "http://192.168.1.100:5000/api/sensor-data";

// Configuración DHT11
#define DHT_PIN 4
#define DHT_TYPE DHT11
DHT dht(DHT_PIN, DHT_TYPE);

// Variables de control
unsigned long lastSend = 0;
const long sendInterval = 30000; // Enviar cada 30 segundos

void setup() {
    Serial.begin(115200);
    dht.begin();
    
    // Conectar WiFi
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println("\nWiFi conectado!");
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());
}

void loop() {
    unsigned long now = millis();
    if (now - lastSend > sendInterval) {
        lastSend = now;
        sendSensorDataHTTP();
    }
    
    delay(1000);
}

void sendSensorDataHTTP() {
    if (WiFi.status() == WL_CONNECTED) {
        HTTPClient http;
        http.begin(serverURL);
        http.addHeader("Content-Type", "application/json");
        
        // Leer datos del sensor
        float temperature = dht.readTemperature();
        float humidity = dht.readHumidity();
        
        // Verificar lecturas válidas
        if (isnan(temperature) || isnan(humidity)) {
            Serial.println("Error leyendo DHT11!");
            return;
        }
        
        // Crear JSON payload
        StaticJsonDocument<200> doc;
        doc["device_id"] = "ESP32_HTTP_001";
        doc["temperature"] = temperature;
        doc["humidity"] = humidity;
        doc["timestamp"] = millis();
        doc["protocol"] = "HTTP";
        
        String jsonString;
        serializeJson(doc, jsonString);
        
        // Enviar POST request
        int httpResponseCode = http.POST(jsonString);
        
        if (httpResponseCode > 0) {
            String response = http.getString();
            Serial.printf("HTTP Response: %d\n", httpResponseCode);
            Serial.printf("Response: %s\n", response.c_str());
            Serial.printf("Datos enviados - Temp: %.2f°C, Humedad: %.2f%%\n", 
                         temperature, humidity);
        } else {
            Serial.printf("Error HTTP: %d\n", httpResponseCode);
        }
        
        http.end();
    } else {
        Serial.println("WiFi desconectado!");
    }
}
            

from flask import Flask, request, jsonify
import json
import sqlite3
from datetime import datetime
import logging

app = Flask(__name__)

# Configurar logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Inicializar base de datos
def init_db():
    conn = sqlite3.connect('iot_data.db')
    c = conn.cursor()
    c.execute('''CREATE TABLE IF NOT EXISTS sensor_readings
                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
                  timestamp DATETIME,
                  device_id TEXT,
                  temperature REAL,
                  humidity REAL,
                  protocol TEXT)''')
    conn.commit()
    conn.close()

def save_reading(device_id, temperature, humidity, protocol="HTTP"):
    conn = sqlite3.connect('iot_data.db')
    c = conn.cursor()
    c.execute('''INSERT INTO sensor_readings 
                 (timestamp, device_id, temperature, humidity, protocol)
                 VALUES (?, ?, ?, ?, ?)''',
              (datetime.now(), device_id, temperature, humidity, protocol))
    conn.commit()
    conn.close()

@app.route('/api/sensor-data', methods=['POST'])
def receive_sensor_data():
    try:
        # Obtener datos JSON del request
        data = request.get_json()
        
        if not data:
            return jsonify({"error": "No JSON data received"}), 400
        
        # Validar campos requeridos
        required_fields = ['device_id', 'temperature', 'humidity']
        for field in required_fields:
            if field not in data:
                return jsonify({"error": f"Missing field: {field}"}), 400
        
        # Extraer datos
        device_id = data['device_id']
        temperature = float(data['temperature'])
        humidity = float(data['humidity'])
        protocol = data.get('protocol', 'HTTP')
        
        # Validar rangos de datos
        if not (-40 <= temperature <= 85):
            return jsonify({"error": "Temperature out of range"}), 400
        
        if not (0 <= humidity <= 100):
            return jsonify({"error": "Humidity out of range"}), 400
        
        # Guardar en base de datos
        save_reading(device_id, temperature, humidity, protocol)
        
        # Log de la recepción
        logger.info(f"Data received from {device_id}: T={temperature}°C, H={humidity}%")
        
        # Respuesta exitosa
        response = {
            "status": "success",
            "message": "Data received successfully",
            "device_id": device_id,
            "timestamp": datetime.now().isoformat(),
            "data_received": {
                "temperature": temperature,
                "humidity": humidity,
                "protocol": protocol
            }
        }
        
        return jsonify(response), 200
        
    except ValueError as e:
        logger.error(f"Value error: {e}")
        return jsonify({"error": "Invalid data format"}), 400
    
    except Exception as e:
        logger.error(f"Unexpected error: {e}")
        return jsonify({"error": "Internal server error"}), 500

@app.route('/api/latest-readings', methods=['GET'])
def get_latest_readings():
    try:
        conn = sqlite3.connect('iot_data.db')
        c = conn.cursor()
        c.execute('''SELECT timestamp, device_id, temperature, humidity, protocol
                     FROM sensor_readings
                     ORDER BY timestamp DESC
                     LIMIT 50''')
        
        readings = []
        for row in c.fetchall():
            readings.append({
                "timestamp": row[0],
                "device_id": row[1],
                "temperature": row[2],
                "humidity": row[3],
                "protocol": row[4]
            })
        
        conn.close()
        return jsonify({"readings": readings}), 200
        
    except Exception as e:
        logger.error(f"Error fetching readings: {e}")
        return jsonify({"error": "Failed to fetch readings"}), 500

@app.route('/health', methods=['GET'])
def health_check():
    return jsonify({
        "status": "healthy",
        "timestamp": datetime.now().isoformat(),
        "service": "IoT Data Receiver"
    })

if __name__ == '__main__':
    init_db()
    app.run(host='0.0.0.0', port=5000, debug=True)