ThingsBoard IoT Platform: Panduan Lengkap

1. Apa Itu ThingsBoard?

ThingsBoard adalah platform IoT open-source yang menyediakan solusi lengkap untuk device management, data collection, processing, dan visualisasi. Platform ini mendukung berbagai protokol IoT seperti MQTT, CoAP, HTTP, dan SNMP, sehingga sangat fleksibel untuk berbagai use case IoT.

Salah satu keunggulan ThingsBoard dibanding platform IoT lainnya adalah fitur rule chains — sistem processing data visual berbasis node yang memungkinkan kamu membangun logika kompleks tanpa menulis kode. Kamu juga bisa membuat dashboard interaktif yang sangat kaya fitur dengan widget yang sudah tersedia.

Fitur Utama ThingsBoard

Fitur	Deskripsi
Device Management	Registrasi, autentikasi, dan manajemen perangkat IoT
Data Collection	Menerima telemetry dan attributes dari device
Rule Engine	Processing data visual berbasis node (rule chains)
Dashboards	Dashboard interaktif dengan 30+ widget types
RPC	Remote control perangkat (one-way dan two-way)
Alarm Management	Deteksi, manajemen, dan eskalasi alarm
Multi-tenancy	Dukungan multi-tenant dengan isolasi data
REST API & WebSocket	API lengkap untuk integrasi dengan sistem lain

ThingsBoard vs Platform IoT Lainnya

Aspek	ThingsBoard	Losant	Blynk
Open Source	Ya (CE)	Tidak	Tidak
Self-hosted	Ya	Tidak (cloud only)	Tidak
Rule Engine	Visual (sangat fleksibel)	Visual + code	Simple automations
Widget Library	30+ widget	50+ block	15+ widget
Protokol	MQTT, CoAP, HTTP, SNMP	MQTT, HTTP	MQTT, HTTP
Target User	Enterprise, developer	Enterprise	Hobbyist, maker

2. Instalasi & Konfigurasi

Docker Compose Setup

# docker-compose.yml untuk ThingsBoard CE
version: "3.8"
services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: thingsboard
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
    volumes:
      - postgres-data:/var/lib/postgresql/data
    restart: unless-stopped

  tb:
    image: thingsboard/tb-postgres:3.6.4
    depends_on:
      - postgres
    ports:
      - "8080:9090"
      - "1883:1883"
      - "5683:5683/udp"
    environment:
      TB_QUEUE_TYPE: in-memory
      SPRING_DATASOURCE_URL: jdbc:postgresql://postgres:5432/thingsboard
      SPRING_DATASOURCE_USERNAME: postgres
      SPRING_DATASOURCE_PASSWORD: postgres
    volumes:
      - tb-data:/data
      - tb-logs:/var/log/thingsboard
    restart: unless-stopped

volumes:
  postgres-data:
  tb-data:
  tb-logs:

Setelah docker compose up, akses ThingsBoard di http://localhost:8080. Login default: sysadmin@thingsboard.org / sysadmin.

Konfigurasi Awal

1. Login sebagai sysadmin dan buat tenant baru
2. Buat customer (opsional, untuk multi-tenant)
3. Buat device profiles untuk tipe device berbeda
4. Registrasi device pertama
5. Konfigurasi MQTT broker settings (port 1883 default)

3. Device Management

ThingsBoard menyediakan sistem device management yang lengkap. Setiap device merepresentasikan perangkat IoT fisik yang terhubung ke platform.

Membuat Device

1. Buka Devices → + (Add Device)
2. Isi nama device: sensor-suhu-01
3. Pilih device profile: default
4. Isi label dan description (opsional)
5. Klik Add
6. Salin Access Token dari device credentials

Mengirim Telemetry via MQTT

# Mengirim telemetry via MQTT dengan access token
mosquitto_pub -h localhost -p 1883 \
  -t "v1/devices/me/telemetry" \
  -u "YOUR_ACCESS_TOKEN" \
  -m '{"temperature": 25.6, "humidity": 65}'

# Mengirim client attributes
mosquitto_pub -h localhost -p 1883 \
  -t "v1/devices/me/attributes" \
  -u "YOUR_ACCESS_TOKEN" \
  -m '{"firmware_version": "2.1.0", "model": "ESP32-S3"}'

# Mengirim server attributes (via API)
curl -X POST "http://localhost:8080/api/v1/YOUR_ACCESS_TOKEN/attributes" \
  -H "Content-Type: application/json" \
  -d '{"firmware_version": "2.1.0"}'

ESP32 Firmware untuk ThingsBoard

// ESP32 + ThingsBoard via MQTT
#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include <DHT.h>

#define WIFI_SSID "your-wifi"
#define WIFI_PASS "your-password"
#define TB_SERVER "192.168.1.100"
#define TB_PORT 1883
#define TB_TOKEN "YOUR_DEVICE_ACCESS_TOKEN"

WiFiClient wifiClient;
PubSubClient client(wifiClient);
DHT dht(4, DHT11);

void connectWiFi() {
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("WiFi connected!");
}

void connectMQTT() {
  while (!client.connected()) {
    if (client.connect("ESP32_Sensor", TB_TOKEN, NULL)) {
      Serial.println("Connected to ThingsBoard!");
      client.subscribe("v1/devices/me/rpc/request/+");
    } else {
      delay(5000);
    }
  }
}

void sendTelemetry() {
  float temp = dht.readTemperature();
  float hum = dht.readHumidity();
  
  StaticJsonDocument<200> doc;
  doc["temperature"] = temp;
  doc["humidity"] = hum;
  doc["battery"] = analogRead(34) * 3.3 / 4095 * 100;
  
  char buffer[200];
  serializeJson(doc, buffer);
  client.publish("v1/devices/me/telemetry", buffer);
  Serial.println("Telemetry sent!");
}

void setup() {
  Serial.begin(115200);
  dht.begin();
  connectWiFi();
  client.setServer(TB_SERVER, TB_PORT);
  connectMQTT();
}

void loop() {
  if (!client.connected()) connectMQTT();
  client.loop();
  
  static unsigned long lastSend = 0;
  if (millis() - lastSend > 5000) {
    sendTelemetry();
    lastSend = millis();
  }
}

Device Profiles

Profile	Kegunaan	Protokol
default	Device umum, format telemetry bebas	MQTT/HTTP
sensor	Sensor environment (suhu, kelembaban)	MQTT
gateway	IoT gateway yang mewakili banyak child device	MQTT
smart-meter	Smart meter energi/air/gas	CoAP/HTTP
tracker	GPS tracker dengan location telemetry	MQTT

4. Dashboards & Widget

ThingsBoard memiliki sistem dashboard yang sangat powerful. Dashboard dibangun dari widget yang masing-masing terhubung ke satu atau lebih device. Kamu bisa membuat dashboard real-time yang menampilkan data sensor, kontrol perangkat, dan monitoring alarm.

Membuat Dashboard

1. Buka Dashboards → + (Create New Dashboard)
2. Berikan nama: Smart Environment Monitoring
3. Klik Add
4. Buka dashboard → klik Edit (ikon pensil)
5. Klik + (Add Widget)
6. Pilih widget dari library (misalnya: Digital Gauge → Temperature)
7. Hubungkan widget ke device sebagai data source
8. Atur posisi dan ukuran widget
9. Simpan dashboard

Widget yang Umum Digunakan

Widget	Kegunaan	Kategori
Digital/Analog Gauge	Menampilkan nilai sensor (suhu, tekanan)	Gauges
Time Series Chart	Grafik data historis	Charts
Map (OpenStreetMap)	Lokasi device di peta	Maps
Switch Control	Toggle ON/OFF perangkat via RPC	Control
LED Indicator	Indikator status (hijau/merah)	Status
Alarm Widget	Daftar alarm aktif	Alarm
HTML Card	Custom HTML/Markdown	Cards
Table Widget	Tabel data terbaru	Tables

Dashboard State & Entity Alias

# Entity Alias memungkinkan widget terhubung ke device dinamis
# Contoh alias:
# - "All Sensors": tipe "All" → semua device dengan profile "sensor"
# - "Selected Device": tipe "Device" → device spesifik
# - "Device by Name": tipe "Entity Name" → filter berdasarkan nama

# Dashboard State: halaman terpisah dalam satu dashboard
# Contoh:
# - State "main": overview semua device
# - State "device-detail": detail device spesifik (saat diklik)
# - State "alarm-panel": panel alarm management

5. Rule Chains & Processing

Rule Chain adalah fitur paling powerful di ThingsBoard. Setiap data yang masuk (telemetry, attributes, RPC, alarm) diproses melalui rule chain yang terdiri dari node-node yang saling terhubung.

Node Types

Node	Fungsi
Input	Titik masuk: message dari device, asset, atau API
Filter	Filter berdasarkan tipe message, originator type, atau script
Transform	Ubah data: script, enrichment, generator
Action	Aksi: create alarm, send email, create notification
External	Integrasi: REST API call, Kafka, MQTT, RPC
Output	Output: save telemetry, save attributes, log

Contoh Rule Chain: Alert Suhu Tinggi

# Rule Chain: "Temperature Alert Processing"

# 1. Input Node: "Message Type Switch"
#    → Route berdasarkan tipe: POST_TELEMETRY_REQUEST

# 2. Filter Node: "Device Type Filter"
#    → Script: msg.temperature !== undefined

# 3. Filter Node: "Temperature Threshold"
#    → Script: return msg.temperature > 35;

# 4. Transform Node: "Create Alarm Data"
#    → Script:
#    var alarm = {
#      type: "HIGH_TEMPERATURE",
#      severity: msg.temperature > 40 ? "CRITICAL" : "WARNING",
#      status: "ACTIVE_UNACK",
#      propagate: true
#    };
#    return {msg: alarm, metadata: metadata, msgType: "POST_TELEMETRY_REQUEST"};

# 5. Action Node: "Create/Update Alarm"
#    → Alarm Type: "${alarmType}"
#    → Severity: "${severity}"

# 6. External Node: "Send Notification"
#    → URL: https://api.telegram.org/bot{token}/sendMessage
#    → Method: POST
#    → Body: {"chat_id": "{chatId}", "text": "Suhu tinggi: ${temperature}°C"}

# 7. Output Node: "Save Telemetry"
#    → Save original telemetry ke database

6. RPC (Remote Procedure Calls)

RPC memungkinkan kamu mengirim perintah dari ThingsBoard ke device. Ada dua jenis: One-Way RPC (fire and forget) dan Two-Way RPC (dengan response dari device).

One-Way RPC

# Kirim perintah ke device (tanpa response)
curl -X POST "http://localhost:8080/api/plugins/rpc/oneway/$DEVICE_ID" \
  -H "X-Authorization: Bearer $JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "method": "setGpio",
    "params": {"pin": 4, "value": 1}
  }'

Two-Way RPC

# Kirim perintah dan dapatkan response
curl -X POST "http://localhost:8080/api/plugins/rpc/twoway/$DEVICE_ID" \
  -H "X-Authorization: Bearer $JWT_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "method": "getSensorConfig",
    "params": {"sensor": "temperature"}
  }'

# Response dari device:
# {"interval": 5000, "unit": "celsius", "threshold": 40}

ESP32: Handling RPC

// Callback untuk RPC request
void onRpcMessage(const char* topic, byte* payload, unsigned int length) {
  StaticJsonDocument<512> doc;
  deserializeJson(doc, payload);
  
  String method = doc["method"].as<String>();
  int requestId = doc["id"].as<int>();
  
  if (method == "setGpio") {
    int pin = doc["params"]["pin"];
    int value = doc["params"]["value"];
    digitalWrite(pin, value);
    
    // Kirim response (two-way RPC)
    String responseTopic = "v1/devices/me/rpc/response/" + String(requestId);
    client.publish(responseTopic.c_str(), "{\"success\": true}");
  }
  
  if (method == "getSensorConfig") {
    String responseTopic = "v1/devices/me/rpc/response/" + String(requestId);
    String response = "{\"interval\": 5000, \"unit\": \"celsius\"}";
    client.publish(responseTopic.c_str(), response.c_str());
  }
}

7. Telemetry & Data Storage

ThingsBoard menyimpan telemetry data di database (PostgreSQL atau Cassandra untuk scale besar). Setiap data point terdiri dari key (nama metrik), value (nilai), dan timestamp.

Tipe Data di ThingsBoard

Tipe	Penyimpanan	Contoh
Telemetry (Time Series)	Database + Latest Values	temperature=25.6
Client Attributes	Dikirim oleh device	firmware="2.1.0"
Server Attributes	Dikirim oleh server/API	installation_date="2024-01-01"
Shared Attributes	Bisa dibaca oleh device dan server	config_interval=10

Data Retention & Aggregation

# Konfigurasi data retention di thingsboard.yml:
database:  ts_max_records_per_customer: 1000000
database:  ts_max_records_per_device: 50000

# Untuk versi Professional:
# - Automatic data aggregation (1 jam, 1 hari)
# - Data TTL per tipe data
# - Cassandra/TimescaleDB backend untuk performa lebih baik

# API untuk mengambil telemetry:
GET /api/plugins/telemetry/{entityType}/{entityId}/values/timeseries?keys=temp,humidity&startTs=1719600000000&endTs=1719603600000&interval=60000&agg=AVG

8. MQTT Gateway Integration

ThingsBoard Gateway memungkinkan kamu menghubungkan device yang tidak bisa langsung berkomunikasi dengan ThingsBoard (misalnya device dengan protokol Modbus, BLE, atau OPC-UA) melalui satu gateway node.

Konfigurasi MQTT Gateway

// tb-gateway.yml — MQTT connector config
{
  "id": "mqtt-default",
  "type": "Mqtt",
  "name": "MQTT Broker Connector",
  "configuration": {
    "host": "mqtt-broker",
    "port": 1883,
    "clientId": "TB_Gateway_001",
    "security": {
      "type": "basic",
      "username": "gateway_user",
      "password": "gateway_pass"
    },
    "mapping": [
      {
        "topicFilter": "sensors/+/data",
        "converter": {
          "type": "json",
          "deviceNameJsonExpression": "${serialNumber}",
          "deviceTypeJsonExpression": "sensor",
          "timeout": 60000,
          "attributes": [
            {"type": "string", "key": "model", "value": "${model}"}
          ],
          "timeseries": [
            {"type": "double", "key": "temperature", "value": "${temp}"},
            {"type": "double", "key": "humidity", "value": "${hum}"}
          ]
        }
      }
    ],
    "connectRequests": [
      {"topicFilter": "sensors/+/connect", "deviceNameJsonExpression": "${serialNumber}"}
    ],
    "disconnectRequests": [
      {"topicFilter": "sensors/+/disconnect", "deviceNameJsonExpression": "${serialNumber}"}
    ]
  }
}

9. Quiz: Uji Pemahamanmu!

Setelah membaca tutorial di atas, jawablah 5 pertanyaan berikut untuk menguji pemahamanmu tentang ThingsBoard: