Raspberry Pi untuk IoT: Panduan Lengkap dari Setup Hingga Proyek

# Akses Raspberry Pi dari komputer lain via SSH
ssh pi@raspberrypi.local

# Atau gunakan IP address langsung
ssh pi@192.168.1.100

# Password default: raspberry (HARUS diubah!)
# Pada versi baru, password di-set saat flashing via Imager

# Update daftar paket
sudo apt update && sudo apt upgrade -y

# Install paket dasar untuk IoT
sudo apt install -y python3-pip python3-venv git curl

# Install library GPIO untuk Python
pip3 install RPi.GPIO gpiozero

# Install paho-mqtt untuk MQTT client
pip3 install paho-mqtt

# Install Flask untuk web server
pip3 install flask

# Verifikasi semua terinstal
python3 --version
pip3 --version

# Jalankan Raspberry Pi Configuration Tool
sudo raspi-config

# Navigasi: Interface Options → I2C → Enable
# Navigasi: Interface Options → SPI → Enable
# Navigasi: Interface Options → SSH → Enable
# Navigasi: Interface Options → Serial Port → 
#   Login shell over serial: No
#   Serial port hardware enabled: Yes
# Reboot setelah perubahan
sudo reboot

#!/usr/bin/env python3
# Program LED Blink di Raspberry Pi
# IoTHub - https://iothub.id

import RPi.GPIO as GPIO
import time

# Konfigurasi GPIO
LED_PIN = 17  # GPIO 17 (fisik pin 11)
GPIO.setmode(GPIO.BCM)       # Gunakan penomoran BCM
GPIO.setup(LED_PIN, GPIO.OUT) # Set sebagai output

print("LED Blink dimulai! Tekan Ctrl+C untuk berhenti.")

try:
    while True:
        GPIO.output(LED_PIN, GPIO.HIGH)  # Nyalakan LED
        print("LED ON")
        time.sleep(1)

        GPIO.output(LED_PIN, GPIO.LOW)   # Matikan LED
        print("LED OFF")
        time.sleep(1)

except KeyboardInterrupt:
    print("\nProgram dihentikan.")

finally:
    GPIO.cleanup()  # Selalu bersihkan GPIO saat selesai

#!/usr/bin/env python3
# Membaca status tombol dari GPIO
# IoTHub - https://iothub.id

import RPi.GPIO as GPIO
import time

TOMBOL_PIN = 27   # GPIO 27 (fisik pin 13)
LED_PIN = 17      # GPIO 17 (fisik pin 11)

GPIO.setmode(GPIO.BCM)
GPIO.setup(TOMBOL_PIN, GPIO.IN, pull_up_down=GPIO.PUD_UP)
GPIO.setup(LED_PIN, GPIO.OUT)

print("Tahan tombol untuk menyalakan LED. Tekan Ctrl+C untuk berhenti.")

try:
    while True:
        # Tombol aktif-low (pressed = LOW)
        if GPIO.input(TOMBOL_PIN) == GPIO.LOW:
            print("Tombol DITEKAN → LED ON")
            GPIO.output(LED_PIN, GPIO.HIGH)
        else:
            print("Tombol LEPAS → LED OFF")
            GPIO.output(LED_PIN, GPIO.LOW)
        time.sleep(0.1)

except KeyboardInterrupt:
    print("\nProgram dihentikan.")

finally:
    GPIO.cleanup()

#!/usr/bin/env python3
# Membaca Sensor Suhu & Kelembaban DHT22
# IoTHub - https://iothub.id

# Install: pip3 install adafruit-circuitpython-dht
# Jalankan: sudo python3 baca_dht22.py (butuh akses GPIO)

import adafruit_dht
import board
import time

# Inisialisasi sensor DHT22 pada GPIO4
dht = adafruit_dht.DHT22(board.D4)

print("=== Pembaca Sensor DHT22 ===")
print("Membaca data setiap 5 detik...")

try:
    while True:
        try:
            suhu = dht.temperature
            kelembaban = dht.humidity

            if suhu is not None and kelembaban is not None:
                print(f"Suhu       : {suhu:.1f} °C")
                print(f"Kelembaban : {kelembaban:.1f} %")

                # Hitung Heat Index sederhana
                if suhu > 27 and kelembaban > 40:
                    heat_index = (
                        suhu + (kelembaban - 40) * 0.1
                    )
                    print(f"Indeks Panas: {heat_index:.1f} °C")
                print("---")
            else:
                print("[WARN] Gagal membaca data sensor")

        except RuntimeError as e:
            print(f"[ERROR] {e}")

        time.sleep(5)

except KeyboardInterrupt:
    print("\nPembacaan dihentikan.")
finally:
    dht.exit()

#!/usr/bin/env python3
# Membaca Jarak dengan Sensor Ultrasonic HC-SR04
# IoTHub - https://iothub.id

import RPi.GPIO as GPIO
import time

# Konfigurasi Pin
TRIG_PIN = 23   # GPIO 23 (fisik pin 16) - Trigger
ECHO_PIN = 24   # GPIO 24 (fisik pin 18) - Echo

GPIO.setmode(GPIO.BCM)
GPIO.setup(TRIG_PIN, GPIO.OUT)
GPIO.setup(ECHO_PIN, GPIO.IN)

def baca_jarak():
    """Mengukur jarak dalam cm."""
    # Kirim pulse trigger
    GPIO.output(TRIG_PIN, GPIO.HIGH)
    time.sleep(0.00001)  # 10 microdetik
    GPIO.output(TRIG_PIN, GPIO.LOW)

    # Tunggu echo
    awal_waktu = time.time()
    while GPIO.input(ECHO_PIN) == GPIO.LOW:
        awal_waktu = time.time()

    akhir_waktu = time.time()
    while GPIO.input(ECHO_PIN) == GPIO.HIGH:
        akhir_waktu = time.time()

    # Hitung jarak
    # Kecepatan suara = 34300 cm/s
    # Waktu bolak-balik dibagi 2
    durasi = akhir_waktu - awal_waktu
    jarak = (durasi * 34300) / 2

    return round(jarak, 2)

print("=== Sensor Ultrasonic HC-SR04 ===")
print("Arahkan sensor ke objek. Tekan Ctrl+C untuk berhenti.\n")

try:
    while True:
        jarak = baca_jarak()
        if 2 <= jarak <= 400:
            print(f"Jarak terukur: {jarak} cm")
        else:
            print("[INFO] Objek di luar jangkauan sensor")
        time.sleep(0.5)

except KeyboardInterrupt:
    print("\nPembacaan dihentikan.")

finally:
    GPIO.cleanup()

# Install Mosquitto broker dan client
sudo apt install -y mosquitto mosquitto-clients

# Aktifkan Mosquitto agar berjalan otomatis
sudo systemctl enable mosquitto
sudo systemctl start mosquitto

# Verifikasi layanan berjalan
sudo systemctl status mosquitto

# Test manual dengan Mosquitto client
# Terminal 1: Subscriber
mosquitto_sub -h localhost -t "iot/sensor/#"

# Terminal 2: Publisher (kirim test message)
mosquitto_pub -h localhost -t "iot/sensor/dht22" -m '{"suhu":29.5,"kelembaban":72}'

#!/usr/bin/env python3
# MQTT Subscriber untuk Raspberry Pi
# IoTHub - https://iothub.id

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

# Konfigurasi MQTT
BROKER_HOST = "localhost"   # Atau IP broker eksternal
BROKER_PORT = 1883
TOPIC = "iot/sensor/#"      # Wildcard: terima semua topik sensor

# Callback saat terhubung ke broker
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print(f"[{timestamp()}] Terhubung ke MQTT Broker!")
        client.subscribe(TOPIC)
        print(f"[{timestamp()}] Subscribe ke topik: {TOPIC}")
    else:
        print(f"[{timestamp()}] Gagal koneksi, kode error: {rc}")

# Callback saat menerima pesan
def on_message(client, userdata, msg):
    topik = msg.topic
    payload = msg.payload.decode("utf-8")

    print(f"\n{'='*50}")
    print(f"[{timestamp()}] Pesan diterima!")
    print(f"  Topik  : {topik}")

    # Coba parse sebagai JSON
    try:
        data = json.loads(payload)
        print(f"  Data   :")
        for k, v in data.items():
            print(f"    {k}: {v}")
    except json.JSONDecodeError:
        print(f"  Data   : {payload}")

    print(f"{'='*50}")

def timestamp():
    return datetime.now().strftime("%H:%M:%S")

# Inisialisasi client
client = mqtt.Client(
    client_id="raspi-gateway-01",
    protocol=mqtt.MQTTv311
)

client.on_connect = on_connect
client.on_message = on_message

print("=== MQTT Subscriber Raspberry Pi ===")
print(f"Menghubungkan ke {BROKER_HOST}:{BROKER_PORT}...")

try:
    client.connect(BROKER_HOST, BROKER_PORT, keepalive=60)
    client.loop_forever()  # Loop tak hingga, handle pesan

except KeyboardInterrupt:
    print(f"\n[{timestamp()}] Disconnect dari broker.")
    client.disconnect()

except ConnectionRefusedError:
    print(f"[ERROR] Tidak bisa terhubung ke broker!")
    print("Pastikan Mosquitto berjalan: sudo systemctl start mosquitto")

#!/usr/bin/env python3
# Dashboard IoT dengan Flask
# IoTHub - https://iothub.id

from flask import Flask, jsonify, render_template_string
from datetime import datetime
import json

app = Flask(__name__)

# Penyimpanan sederhana di memori (untuk demo)
sensor_data = {
    "dht22": {"suhu": 0.0, "kelembaban": 0.0, "terakhir": "-"},
    "ultrasonic": {"jarak": 0.0, "terakhir": "-"}
}

# Template HTML Dashboard
DASHBOARD_HTML = """
<!DOCTYPE html>
<html lang="id">
<head>
    <title>Dashboard IoT - IoTHub</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <style>
        body { font-family: 'Segoe UI', sans-serif; background: #0f172a;
               color: #e2e8f0; margin: 0; padding: 20px; }
        h1 { text-align: center; color: #3ecf8e; margin-bottom: 30px; }
        .grid { display: grid; grid-template-columns: repeat(auto-fit,
                minmax(300px, 1fr)); gap: 20px; max-width: 900px;
                margin: 0 auto; }
        .card { background: #1e293b; border-radius: 12px; padding: 24px;
                border: 1px solid #334155; }
        .card h2 { margin-top: 0; color: #22d3ee; font-size: 1.1rem; }
        .value { font-size: 2.5rem; font-weight: 700; color: #3ecf8e;
                 margin: 10px 0; }
        .unit { font-size: 1rem; color: #94a3b8; }
        .meta { font-size: 0.85rem; color: #64748b; }
    </style>
</head>
<body>
    <h1>🏠 Dashboard IoT Raspberry Pi</h1>
    <div class="grid">
        <div class="card">
            <h2>🌡️ Sensor DHT22</h2>
            <div>
                <div class="value" id="suhu">--</div>
                <div class="unit">°C (Suhu)</div>
            </div>
            <div style="margin-top:15px">
                <div class="value" id="lembab">--</div>
                <div class="unit">% (Kelembaban)</div>
            </div>
            <div class="meta" id="waktu-dht"></div>
        </div>
        <div class="card">
            <h2>📏 Sensor Ultrasonic</h2>
            <div>
                <div class="value" id="jarak">--</div>
                <div class="unit">cm (Jarak)</div>
            </div>
            <div class="meta" id="waktu-ult"></div>
        </div>
    </div>
    <script>
        async function updateData() {
            const res = await fetch('/api/data');
            const data = await res.json();
            document.getElementById('suhu').textContent = data.dht22.suhu.toFixed(1);
            document.getElementById('lembab').textContent = data.dht22.kelembaban.toFixed(1);
            document.getElementById('waktu-dht').textContent = data.dht22.terakhir;
            document.getElementById('jarak').textContent = data.ultrasonic.jarak.toFixed(1);
            document.getElementById('waktu-ult').textContent = data.ultrasonic.terakhir;
        }
        setInterval(updateData, 2000);
        updateData();
    </script>
</body>
</html>
"""

@app.route("/")
def index():
    """Halaman utama dashboard."""
    return render_template_string(DASHBOARD_HTML)

@app.route("/api/data")
def api_data():
    """Endpoint API untuk data sensor (JSON)."""
    return jsonify(sensor_data)

@app.route("/api/update/suhu/<float:suhu>/<float:lembab>")
def update_suhu(suhu, lembab):
    """Endpoint untuk update data DHT22."""
    sensor_data["dht22"]["suhu"] = suhu
    sensor_data["dht22"]["kelembaban"] = lembab
    sensor_data["dht22"]["terakhir"] = datetime.now().strftime("%H:%M:%S")
    return jsonify({"status": "ok"})

@app.route("/api/update/jarak/<float:jarak>")
def update_jarak(jarak):
    """Endpoint untuk update data ultrasonic."""
    sensor_data["ultrasonic"]["jarak"] = jarak
    sensor_data["ultrasonic"]["terakhir"] = datetime.now().strftime("%H:%M:%S")
    return jsonify({"status": "ok"})

if __name__ == "__main__":
    print("Dashboard IoT berjalan di http://0.0.0.0:5000")
    app.run(host="0.0.0.0", port=5000, debug=True)

#!/usr/bin/env python3
# Handler Database SQLite untuk IoT
# IoTHub - https://iothub.id

import sqlite3
import json
from datetime import datetime, timedelta

DB_NAME = "iot_data.db"

def init_db():
    """Inisialisasi database dan buat tabel jika belum ada."""
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()

    # Tabel pembacaan sensor
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS sensor_readings (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            device_id TEXT NOT NULL,
            sensor_type TEXT NOT NULL,
            value_json TEXT NOT NULL,
            timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
        )
    """)

    # Tabel device yang terdaftar
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS devices (
            device_id TEXT PRIMARY KEY,
            device_name TEXT NOT NULL,
            location TEXT,
            last_seen DATETIME
        )
    """)

    # Index untuk query cepat berdasarkan waktu
    cursor.execute("""
        CREATE INDEX IF NOT EXISTS idx_timestamp
        ON sensor_readings(timestamp)
    """)

    conn.commit()
    conn.close()
    print("[DB] Database diinisialisasi.")

def simpan_reading(device_id, sensor_type, data_dict):
    """Simpan pembacaan sensor ke database."""
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()

    cursor.execute("""
        INSERT INTO sensor_readings (device_id, sensor_type, value_json)
        VALUES (?, ?, ?)
    """, (device_id, sensor_type, json.dumps(data_dict)))

    # Update last_seen di tabel devices
    cursor.execute("""
        INSERT INTO devices (device_id, device_name, last_seen)
        VALUES (?, ?, ?)
        ON CONFLICT(device_id)
        DO UPDATE SET last_seen = excluded.last_seen
    """, (device_id, f"Device {device_id}", datetime.now().isoformat()))

    conn.commit()
    conn.close()

def ambil_data_terakhir(device_id, sensor_type, limit=10):
    """Ambil data terakhir dari database."""
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()

    cursor.execute("""
        SELECT value_json, timestamp
        FROM sensor_readings
        WHERE device_id = ? AND sensor_type = ?
        ORDER BY timestamp DESC
        LIMIT ?
    """, (device_id, sensor_type, limit))

    results = []
    for row in cursor.fetchall():
        results.append({
            "data": json.loads(row[0]),
            "waktu": row[1]
        })

    conn.close()
    return results

def ambil_rata_rata_harian(device_id, sensor_type):
    """Hitung rata-rata harian dari data sensor."""
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()

    cursor.execute("""
        SELECT AVG(CAST(json_extract(value_json, '$.suhu') AS REAL))
        FROM sensor_readings
        WHERE device_id = ? AND sensor_type = ?
          AND timestamp >= date('now', '-1 day')
    """, (device_id, sensor_type))

    result = cursor.fetchone()
    conn.close()

    return round(result[0], 2) if result[0] else None

# === Contoh penggunaan ===
if __name__ == "__main__":
    init_db()

    # Simulasi data dari sensor
    simpan_reading("esp32-01", "dht22", {
        "suhu": 29.5, "kelembaban": 72.3
    })
    simpan_reading("esp32-01", "dht22", {
        "suhu": 29.8, "kelembaban": 71.0
    })
    simpan_reading("esp32-02", "ultrasonic", {
        "jarak": 23.45
    })

    # Ambil data terakhir
    data = ambil_data_terakhir("esp32-01", "dht22")
    print("\n=== Data Terakhir esp32-01 ===")
    for d in data:
        print(f"  {d['waktu']}: {d['data']}")

    # Hitung rata-rata
    avg = ambil_rata_rata_harian("esp32-01", "dht22")
    print(f"\nRata-rata suhu 24 jam terakhir: {avg} °C")

#!/usr/bin/env python3
# Gateway IoT Lengkap - Raspberry Pi
# Menggabungkan MQTT Subscriber + SQLite + Flask Dashboard
# IoTHub - https://iothub.id

import paho.mqtt.client as mqtt
import sqlite3
import json
import threading
from datetime import datetime
from flask import Flask, jsonify, render_template_string

# =============================================
# KONFIGURASI
# =============================================
MQTT_BROKER = "localhost"
MQTT_PORT = 1883
MQTT_TOPIC = "iot/sensor/#"
DB_FILE = "iot_gateway.db"
FLASK_PORT = 5000

# =============================================
# DATABASE HANDLER
# =============================================
def init_database():
    """Buat tabel database jika belum ada."""
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS readings (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            device_id TEXT,
            sensor_type TEXT,
            data TEXT,
            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
        )
    """)
    conn.commit()
    conn.close()

def simpan_data(device_id, sensor_type, data):
    """Simpan data sensor ke database."""
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute(
        "INSERT INTO readings (device_id, sensor_type, data) VALUES (?, ?, ?)",
        (device_id, sensor_type, json.dumps(data))
    )
    conn.commit()
    conn.close()

def ambil_semua_data(limit=50):
    """Ambil data terbaru dari database."""
    conn = sqlite3.connect(DB_FILE)
    cursor = conn.cursor()
    cursor.execute("""
        SELECT device_id, sensor_type, data, created_at
        FROM readings ORDER BY created_at DESC LIMIT ?
    """, (limit,))
    results = []
    for row in cursor.fetchall():
        results.append({
            "device": row[0],
            "tipe": row[1],
            "data": json.loads(row[2]),
            "waktu": row[3]
        })
    conn.close()
    return results

# =============================================
# MQTT SUBSCRIBER
# =============================================
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print(f"[MQTT] Terhubung ke broker!")
        client.subscribe(MQTT_TOPIC)
        print(f"[MQTT] Subscribe: {MQTT_TOPIC}")
    else:
        print(f"[MQTT] Error koneksi: {rc}")

def on_message(client, userdata, msg):
    """Handler saat pesan MQTT diterima."""
    try:
        topik = msg.topic
        data = json.loads(msg.payload.decode())

        # Ekstrak device_id dari topik: iot/sensor/{device_id}
        parts = topik.split("/")
        device_id = parts[2] if len(parts) > 2 else "unknown"

        # Tentukan tipe sensor dari data
        if "suhu" in data:
            sensor_type = "dht22"
        elif "jarak" in data:
            sensor_type = "ultrasonic"
        else:
            sensor_type = "generic"

        # Simpan ke database
        simpan_data(device_id, sensor_type, data)

        print(f"[{datetime.now():%H:%M:%S}] "
              f"Diterima: {device_id} | {sensor_type} | {data}")

    except Exception as e:
        print(f"[MQTT] Error memproses pesan: {e}")

def jalankan_mqtt():
    """Jalankan MQTT subscriber di thread terpisah."""
    client = mqtt.Client(
        client_id="rpi-gateway",
        protocol=mqtt.MQTTv311
    )
    client.on_connect = on_connect
    client.on_message = on_message
    client.connect(MQTT_BROKER, MQTT_PORT, keepalive=60)
    client.loop_forever()

# =============================================
# FLASK DASHBOARD
# =============================================
flask_app = Flask(__name__)

DASHBOARD_TEMPLATE = """
<!DOCTYPE html>
<html lang="id">
<head>
    <title>Gateway IoT Dashboard</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <style>
        * { box-sizing: border-box; margin: 0; padding: 0; }
        body { font-family: 'Segoe UI', sans-serif;
               background: #0a0f1a; color: #e2e8f0; padding: 20px; }
        h1 { text-align: center; color: #3ecf8e;
             margin-bottom: 10px; font-size: 1.8rem; }
        .subtitle { text-align: center; color: #64748b;
                    margin-bottom: 30px; font-size: 0.9rem; }
        table { width: 100%; max-width: 900px; margin: 0 auto;
                border-collapse: collapse; }
        th { background: #1e293b; color: #22d3ee; padding: 12px 16px;
             text-align: left; font-size: 0.85rem; }
        td { padding: 10px 16px; border-bottom: 1px solid #1e293b;
             font-size: 0.85rem; }
        tr:hover td { background: rgba(62,207,142,0.05); }
        .badge { background: #1e3a5f; color: #22d3ee; padding: 3px 8px;
                 border-radius: 12px; font-size: 0.75rem; }
    </style>
</head>
<body>
    <h1>🔌 Gateway IoT Dashboard</h1>
    <p class="subtitle">Raspberry Pi 4 — Data dari MQTT via Subscriber</p>
    <table>
        <thead>
            <tr>
                <th>Device ID</th>
                <th>Tipe Sensor</th>
                <th>Data</th>
                <th>Waktu</th>
            </tr>
        </thead>
        <tbody id="data-table"></tbody>
    </table>
    <script>
        async function loadData() {
            const res = await fetch('/api/readings');
            const data = await res.json();
            const tbody = document.getElementById('data-table');
            tbody.innerHTML = data.map(d => `
                <tr>
                    <td><span class="badge">${d.device}</span></td>
                    <td>${d.tipe}</td>
                    <td>${JSON.stringify(d.data)}</td>
                    <td>${d.waktu}</td>
                </tr>
            `).join('');
        }
        setInterval(loadData, 3000);
        loadData();
    </script>
</body>
</html>
"""

@flask_app.route("/")
def index():
    return render_template_string(DASHBOARD_TEMPLATE)

@flask_app.route("/api/readings")
def api_readings():
    data = ambil_semua_data(limit=20)
    return jsonify(data)

# =============================================
# MAIN - JALANKAN SEMUA LAYANAN
# =============================================
if __name__ == "__main__":
    print("=" * 50)
    print("  GATEWAY IoT RASPBERRY PI")
    print("  IoTHub - https://iothub.id")
    print("=" * 50)

    # Inisialisasi database
    init_database()
    print("[DB] Database siap.")

    # Jalankan MQTT di background thread
    mqtt_thread = threading.Thread(target=jalankan_mqtt, daemon=True)
    mqtt_thread.start()

    # Jalankan Flask di main thread
    print(f"[FLASK] Dashboard: http://0.0.0.0:{FLASK_PORT}")
    print("[GATEWAY] Semua layanan aktif! Ctrl+C untuk berhenti.\n")
    flask_app.run(host="0.0.0.0", port=FLASK_PORT, debug=False)

# Install semua dependensi
pip3 install paho-mqtt flask

# Pastikan Mosquitto berjalan
sudo systemctl start mosquitto

# Jalankan gateway (butuh akses GPIO → gunakan sudo)
sudo python3 gateway.py

# Output:
# ==================================================
#   GATEWAY IoT RASPBERRY PI
# ==================================================
# [DB] Database siap.
# [MQTT] Terhubung ke broker!
# [MQTT] Subscribe: iot/sensor/#
# [FLASK] Dashboard: http://0.0.0.0:5000
# [GATEWAY] Semua layanan aktif!
#
# [14:30:15] Diterima: esp32-01 | dht22 | {'suhu': 29.5, 'kelembaban': 72.3}
# [14:30:18] Diterima: esp32-02 | ultrasonic | {'jarak': 23.45}