📨 MQTT Protocol: Panduan Lengkap

# QoS 0 — Data sensor periodik (hilang sesekali tidak masalah)
# Contoh: pembacaan suhu setiap 5 detik
mosquitto_pub -t "sensor/suhu" -m "25.5" -q 0

# QoS 1 — Notifikasi alarm (harus sampai, duplikat tidak masalah)
# Contoh: notifikasi kebakaran
mosquitto_pub -t "alarm/kebakaran" -m "LANTAI3_API" -q 1

# QoS 2 — Data kritis (harus tepat sekali)
# Contoh: pembayaran atau perintah aktuator kritis
mosquitto_pub -t "cmd/pembayaran" -m '{"amount":100000}' -q 2

# Penting: QoS di sisi publisher dan subscriber BISA BERBEDA
# Broker mengirim dengan QoS MINIMUM dari keduanya
#
# Publisher QoS 2 + Subscriber QoS 1 → Broker mengirim QoS 1
# Publisher QoS 1 + Subscriber QoS 2 → Broker mengirim QoS 1
# Publisher QoS 1 + Subscriber QoS 1 → Broker mengirim QoS 1

import paho.mqtt.client as mqtt
import json
import time

def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("Terhubung ke broker MQTT")
        # Subscribe dengan QoS berbeda
        client.subscribe("sensor/suhu", qos=0)      # QoS 0
        client.subscribe("alarm/#", qos=1)           # QoS 1
        client.subscribe("cmd/kritis", qos=2)        # QoS 2
    else:
        print(f"Gagal koneksi, kode: {rc}")

def on_message(client, userdata, msg):
    print(f"[QoS {msg.qos}] {msg.topic}: {msg.payload.decode()}")

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.connect("broker.hivemq.com", 1883, 60)

# Publish dengan QoS yang sesuai
client.publish("sensor/suhu", "25.5", qos=0)       # Data sensor
client.publish("alarm/kebakaran", "API!", qos=1)    # Alarm
client.publish("cmd/kritis", json.dumps({
    "action": "emergency_stop",
    "device": "conveyor_01"
}), qos=2)  # Perintah kritis

client.loop_forever()

# Publish dengan retain flag (-r)
mosquitto_pub -t "sensor/suhu" -m "25.5" -r
mosquitto_pub -t "sensor/lembab" -m "65" -r
mosquitto_pub -t "device/status" -m "online" -r

# Subscriber yang baru bergabung langsung menerima data terakhir
mosquitto_sub -t "sensor/#" -v
# Output:
# sensor/suhu 25.5       ← diterima langsung (retain)
# sensor/lembab 65       ← diterima langsung (retain)
# device/status online   ← diterima langsung (retain)

# Hapus retained message dengan payload kosong
mosquitto_pub -t "sensor/suhu" -m "" -r
# Topik "sensor/suhu" sekarang tidak punya retained message

# ⚠️ Setiap topik hanya punya SATU retained message
# Publish baru dengan retain akan MENGGANTIKAN retained sebelumnya

import paho.mqtt.client as mqtt

client = mqtt.Client(client_id="sensor_gedung1_lantai1")

# Set Last Will sebelum connect
client.will_set(
    topic="device/sensor_gedung1_lantai1/status",
    payload="offline",
    qos=1,
    retain=True  # Simpan sebagai retained message
)

def on_connect(client, userdata, flags, rc):
    print("Terhubung!")
    # Publish status online setelah connect
    client.publish(
        "device/sensor_gedung1_lantai1/status",
        "online",
        qos=1,
        retain=True
    )

def on_disconnect(client, userdata, rc):
    if rc != 0:
        print("Koneksi terputus secara tidak terduga!")
        # Broker akan otomatis publish LWT "offline"

client.on_connect = on_connect
client.on_disconnect = on_disconnect

# Last Will + Retain = Sistem monitoring yang robust!
# Ketika device mati:
#   1. Broker mendeteksi koneksi terputus
#   2. Broker publish LWT "offline" ke topic status
#   3. Semua subscriber langsung tahu device offline
#   4. Subscriber baru yang subscribe juga langsung tahu

client.connect("broker.hivemq.com", 1883, keepalive=60)
client.loop_forever()

import paho.mqtt.client as mqtt

# Parameter koneksi MQTT
client = mqtt.Client(
    client_id="sensor_001",        # ID unik per device
    clean_session=True,            # True = session baru setiap connect
    protocol=mqtt.MQTTv311         # Versi protokol
)

# Clean Session = True (default)
# - Broker tidak menyimpan subscription dan QoS messages
# - Cocok untuk device yang tidak peduli pesan yang terlewat
# - Lebih hemat resource broker

# Clean Session = False
# - Broker menyimpan subscription dan pending messages
# - Saat reconnect, device langsung menerima pesan yang terlewat
# - Cocok untuk device yang HARUS menerima semua pesan
# - Membutuhkan client_id yang sama

client = mqtt.Client(
    client_id="sensor_001",
    clean_session=False    # Persistent session
)

# Keep Alive
# Interval (detik) di mana client mengirim PINGREQ ke broker
# Jika broker tidak menerima PINGREQ dalam 1.5x keepalive,
# broker menganggap client offline dan mengirim LWT
client.connect(
    host="broker.example.com",
    port=1883,
    keepalive=60  # Ping setiap 60 detik
)

# Username & Password
client.username_pw_set("sensor_user", "secure_password123")

# Reconnect otomatis
client.reconnect_delay_set(
    min_delay=1,       # Delay minimum 1 detik
    max_delay=120      # Delay maksimum 120 detik
)

# Connect dengan TLS/SSL
client.tls_set(
    ca_certs="ca.crt",
    certfile="client.crt",
    keyfile="client.key"
)
client.connect("broker.example.com", 8883, 60)  # Port 8883 = MQTTS

# Generate self-signed certificates (untuk testing)
# 1. Generate CA key dan certificate
openssl genrsa -out ca.key 2048
openssl req -new -x509 -days 365 -key ca.key -out ca.crt \
    -subj "/CN=MQTT CA"

# 2. Generate server key dan CSR
openssl genrsa -out server.key 2048
openssl req -new -key server.key -out server.csr \
    -subj "/CN=mqtt.example.com"

# 3. Sign server certificate dengan CA
openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key \
    -CAcreateserial -out server.crt -days 365

# 4. Generate client key dan certificate
openssl genrsa -out client.key 2048
openssl req -new -key client.key -out client.csr \
    -subj "/CN=sensor_001"
openssl x509 -req -in client.csr -CA ca.crt -CAkey ca.key \
    -CAcreateserial -out client.crt -days 365

# Mosquitto TLS config
# /etc/mosquitto/conf.d/tls.conf
listener 8883
cafile /etc/mosquitto/certs/ca.crt
certfile /etc/mosquitto/certs/server.crt
keyfile /etc/mosquitto/certs/server.key
require_certificate true
use_identity_as_username true

# /etc/mosquitto/acl.conf

# Admin bisa akses semua topic
user admin
topic readwrite #

# Sensor hanya bisa publish ke topic sendiri
user sensor_001
topic write device/sensor_001/#

# Dashboard bisa subscribe ke semua data sensor
user dashboard
topic read device/+/data
topic read device/+/status

# Lampu controller bisa publish dan subscribe topic lampu
user lampu_ctrl
topic readwrite lampu/#

# Anonymous access (disable untuk produksi)
# topic read $SYS/#

#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

// WiFi credentials
const char* ssid = "WiFi-Rumah";
const char* password = "password123";

// MQTT Broker
const char* mqtt_server = "192.168.1.100";
const int mqtt_port = 1883;
const char* mqtt_user = "sensor_001";
const char* mqtt_pass = "secure_pass";

// Topics
const char* topic_suhu = "gedung1/lantai1/ruang1/suhu";
const char* topic_lembab = "gedung1/lantai1/ruang1/lembab";
const char* topic_status = "gedung1/lantai1/ruang1/status";
const char* topic_cmd_lampu = "gedung1/lantai1/ruang1/cmd/lampu";
const char* topic_cmd_ac = "gedung1/lantai1/ruang1/cmd/ac";

// DHT Sensor
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

// LED dan Relay
#define LED_LAMPU 2
#define RELAY_AC 5

WiFiClient espClient;
PubSubClient client(espClient);
unsigned long lastPublish = 0;
const long publishInterval = 5000; // Publish setiap 5 detik

void setup_wifi() {
    delay(10);
    Serial.println("Menghubungkan ke WiFi...");
    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }

    Serial.println("");
    Serial.println("WiFi terhubung!");
    Serial.print("IP Address: ");
    Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) {
    String message = "";
    for (int i = 0; i < length; i++) {
        message += (char)payload[i];
    }

    Serial.printf("Pesan diterima [%s]: %s\n", topic, message.c_str());

    // Handle perintah lampu
    if (String(topic) == topic_cmd_lampu) {
        if (message == "ON") {
            digitalWrite(LED_LAMPU, HIGH);
            client.publish("gedung1/lantai1/ruang1/lampu/status",
                          "ON", true); // retain
            Serial.println("Lampu: ON");
        } else if (message == "OFF") {
            digitalWrite(LED_LAMPU, LOW);
            client.publish("gedung1/lantai1/ruang1/lampu/status",
                          "OFF", true); // retain
            Serial.println("Lampu: OFF");
        }
    }

    // Handle perintah AC
    if (String(topic) == topic_cmd_ac) {
        int targetTemp = message.toInt();
        float currentTemp = dht.readTemperature();
        if (!isnan(currentTemp)) {
            if (currentTemp > targetTemp) {
                digitalWrite(RELAY_AC, HIGH); // AC ON
                client.publish("gedung1/lantai1/ruang1/ac/status",
                              "ON", true);
            } else {
                digitalWrite(RELAY_AC, LOW);  // AC OFF
                client.publish("gedung1/lantai1/ruang1/ac/status",
                              "OFF", true);
            }
        }
    }
}

void reconnect() {
    while (!client.connected()) {
        Serial.print("Menghubungkan ke MQTT Broker...");

        // Client ID unik + Last Will + Clean Session
        if (client.connect(
            "sensor_gedung1_lantai1_ruang1",  // client_id
            mqtt_user,                         // username
            mqtt_pass,                         // password
            topic_status,                      // will topic
            1,                                 // will QoS
            true,                              // will retain
            "offline"                          // will message
        )) {
            Serial.println(" TERHUBUNG!");

            // Publish status online (retained)
            client.publish(topic_status, "online", true);

            // Subscribe ke perintah kontrol (QoS 1)
            client.subscribe(topic_cmd_lampu, 1);
            client.subscribe(topic_cmd_ac, 1);

            Serial.println("Subscribe ke topik kontrol...");
        } else {
            Serial.printf(" GAGAL (rc=%d). Coba lagi 5 detik...\n",
                         client.state());
            delay(5000);
        }
    }
}

void setup() {
    Serial.begin(115200);
    pinMode(LED_LAMPU, OUTPUT);
    pinMode(RELAY_AC, OUTPUT);
    dht.begin();

    setup_wifi();
    client.setServer(mqtt_server, mqtt_port);
    client.setCallback(callback);
}

void loop() {
    if (!client.connected()) {
        reconnect();
    }
    client.loop();

    unsigned long now = millis();
    if (now - lastPublish > publishInterval) {
        lastPublish = now;

        float suhu = dht.readTemperature();
        float lembab = dht.readHumidity();

        if (!isnan(suhu) && !isnan(lembab)) {
            // Publish data sensor (QoS 0, retained)
            char suhuStr[8], lembabStr[8];
            dtostrf(suhu, 1, 2, suhuStr);
            dtostrf(lembab, 1, 2, lembabStr);

            client.publish(topic_suhu, suhuStr, true);   // retained
            client.publish(topic_lembab, lembabStr, true); // retained

            Serial.printf("Published: Suhu=%s°C, Lembab=%s%%\n",
                         suhuStr, lembabStr);

            // Alert jika suhu tinggi (QoS 1)
            if (suhu > 35.0) {
                client.publish("alarm/suhu_tinggi",
                    "{\"device\":\"gedung1_lantai1_ruang1\","
                    "\"temp\":35.5,\"threshold\":35}",
                    1);  // QoS 1
            }
        }
    }
}

// ✅ Payload yang BAIK — menggunakan JSON standar
{
    "device_id": "sensor_001",
    "timestamp": 1719484800,
    "data": {
        "temperature": 25.5,
        "humidity": 65.2,
        "pressure": 1013.25
    },
    "battery": 87,
    "rssi": -45,
    "version": "1.0"
}

// ❌ Payload yang BURUK — tidak terstruktur
// "25.5,65.2,1013.25"
// "suhu=25.5 lembab=65.2"
// "sensor 1: temp 25.5 humidity 65"

// Pertimbangkan CBOR (binary) untuk device dengan
// resource sangat terbatas — lebih kecil dari JSON

// Standarisasi payload di seluruh sistem Anda!
// Buat schema dan dokumentasikan formatnya

import paho.mqtt.client as mqtt
import json
import time
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("MQTT")

class RobustMQTTClient:
    def __init__(self, broker, port, client_id):
        self.client = mqtt.Client(client_id=client_id, clean_session=False)
        self.broker = broker
        self.port = port
        self.connected = False

        # Setup callbacks
        self.client.on_connect = self._on_connect
        self.client.on_disconnect = self._on_disconnect
        self.client.on_message = self._on_message

        # LWT
        self.client.will_set(
            f"device/{client_id}/status",
            json.dumps({"status": "offline", "ts": int(time.time())}),
            qos=1, retain=True
        )

        # Reconnect settings
        self.client.reconnect_delay_set(min_delay=1, max_delay=60)

    def _on_connect(self, client, userdata, flags, rc):
        if rc == 0:
            self.connected = True
            logger.info("Terhubung ke broker MQTT")
            # Publish online
            self.client.publish(
                f"device/{self.client._client_id.decode()}/status",
                json.dumps({"status": "online", "ts": int(time.time())}),
                qos=1, retain=True
            )
        else:
            logger.error(f"Gagal koneksi: rc={rc}")

    def _on_disconnect(self, client, userdata, rc):
        self.connected = False
        if rc != 0:
            logger.warning(f"Terputus tak terduga (rc={rc}), reconnecting...")

    def _on_message(self, client, userdata, msg):
        try:
            payload = json.loads(msg.payload.decode())
            logger.info(f"[{msg.topic}] {payload}")
        except json.JSONDecodeError:
            logger.warning(f"Invalid JSON: {msg.payload}")

    def connect(self):
        self.client.connect(self.broker, self.port, keepalive=60)
        self.client.loop_start()

    def publish(self, topic, data, qos=0):
        if self.connected:
            payload = json.dumps(data)
            result = self.client.publish(topic, payload, qos=qos)
            return result.rc == mqtt.MQTT_ERR_SUCCESS
        return False

# Penggunaan
client = RobustMQTTClient("broker.example.com", 1883, "sensor_001")
client.connect()
client.publish("sensor/suhu", {"value": 25.5, "unit": "celsius"}, qos=1)

# Test koneksi ke broker
telnet broker.example.com 1883

# Test dengan verbose output (-d = debug)
mosquitto_sub -h broker.example.com -t "test/#" -d -v

# Monitor semua pesan di broker (dengan auth)
mosquitto_sub -h localhost -t "#" -u admin -P password -v

# Test retain message
mosquitto_pub -t "test/retain" -m "hello" -r
mosquitto_sub -t "test/retain"  # Langsung menerima "hello"
mosquitto_pub -t "test/retain" -m "" -r  # Hapus retain

# Cek broker log
sudo tail -f /var/log/mosquitto/mosquitto.log

# Test TLS connection
mosquitto_sub -h broker.example.com -p 8883 \
    --cafile ca.crt --cert client.crt --key client.key \
    -t "test/#" -d