LoRa Mesh Networking: Multi-Hop & Deployment

1. Pengenalan LoRa Mesh Networking

LoRa Mesh Networking adalah pendekatan jaringan di mana perangkat LoRa tidak hanya berkomunikasi langsung dengan gateway, tetapi juga dapat saling berkomunikasi satu sama lain dan meneruskan data (relay) melalui perangkat lain hingga mencapai tujuan. Ini sangat berbeda dengan model LoRaWAN tradisional yang menggunakan topologi star.

Dalam skenario LoRaWAN biasa, semua end device harus berada dalam jangkauan langsung gateway. Jika suatu area terlalu luas atau terhalang medan (pegunungan, hutan, gedung), coverage menjadi terbatas. LoRa Mesh menyelesaikan masalah ini dengan memanfaatkan perangkat sebagai relay node yang meneruskan data secara berantai (multi-hop).

Mengapa LoRa Mesh?

Kelebihan dan Kekurangan LoRa Mesh

2. Topologi Mesh vs Star

Untuk memahami LoRa Mesh, kita perlu membandingkannya dengan topologi star yang digunakan LoRaWAN konvensional. Setiap topologi memiliki trade-off tersendiri.

STAR TOPOLOGY (LoRaWAN)          MESH TOPOLOGY (LoRa Mesh)
═══════════════════════          ══════════════════════════

      ┌───┐                           ┌───┐
      │ GW│                           │ A │
      └─┬─┘                          /└─┬─┘
       /|\                           /   │
      / | \                         /    │
     /  |  \                       /     │
  ┌───┐┌───┐┌───┐            ┌───┐    ┌───┐
  │ N1││ N2││ N3│            │ B │────│ C │
  └───┘└───┘└───┘            └─┬─┘    └─┬─┘
                                │        │
                              ┌───┐    ┌───┐
                              │ D │────│ E │
                              └───┘    └───┘

  • N1, N2, N3 harus dalam     • Data bisa sampai ke GW
    jangkauan langsung GW         melalui B→A atau C→A
  • Jika GW mati, semua         • Jika node A mati, data
    komunikasi terhenti           bisa lewat B→C→...→GW lain
  • Jangkauan terbatas          • Jangkauan bisa sangat luas

Jenis Topologi Mesh

Perbandingan Karakteristik

3. Protokol Routing Mesh

Routing protocol menentukan bagaimana data menemukan jalur terbaik dari node sumber ke node tujuan. Dalam LoRa Mesh, routing protocol harus mempertimbangkan keterbatasan daya, bandwidth rendah, dan dinamika jaringan.

Kategori Routing Protocol

1. Proactive Routing (Table-Driven)

Setiap node selalu memelihara tabel routing yang berisi jalur ke semua node lain. Tabel diperbarui secara periodik meskipun tidak ada traffic.

2. Reactive Routing (On-Demand)

Rute hanya dicari saat diperlukan. Menghemat bandwidth tapi menambah latensi saat pertama kali mengirim.

3. Hybrid Routing

Kombinasi proactive dan reactive. Contoh: ZRP (Zone Routing Protocol) — proaktif dalam zona lokal, reaktif antar zona.

4. Routing Berdasarkan Posisi

Keputusan routing berdasarkan koordinat GPS node. Node meneruskan paket ke node yang paling dekat dengan tujuan. Cocok untuk LoRa karena tidak perlu tabel routing besar.

Greedy Position-Based Routing
═════════════════════════════

  Source (S) ingin mengirim ke Destination (D)

  ┌───┐         ┌───┐         ┌───┐
  │ S │─────────│ A │─────────│   │
  └─┬─┘         └─┬─┘         └───┘
    │              │
    │         ┌────┘
    ▼         ▼
  ┌───┐     ┌───┐         ┌───┐
  │ B │─────│ C │─────────│ D │  ← Tujuan
  └───┘     └───┘         └───┘

  S melihat tetangga: A dan B
  → B lebih dekat ke D → kirim ke B
  B melihat tetangga: C dan A
  → C lebih dekat ke D → kirim ke C
  C melihat tetangga: D dan B
  → D adalah tujuan → kirim ke D

  Path: S → B → C → D (3 hop)

4. Komunikasi Multi-Hop

Multi-hop communication adalah inti dari LoRa Mesh. Data dikirim dari satu node ke node lain secara berantai sampai mencapai tujuan. Setiap node yang meneruskan data disebut relay node atau forwarder.

Cara Kerja Multi-Hop

1. Node Sumber mengirim paket data ke node tetangga terdekat yang dipilih oleh routing protocol
2. Relay Node menerima paket, memeriksa apakah dirinya tujuan. Jika bukan, ia meneruskan ke node berikutnya
3. Proses berulang hingga paket sampai di Node Tujuan (atau gateway)
4. Setiap hop menambahkan TTL (Time To Live) untuk mencegah infinite loop

Tantangan Multi-Hop di LoRa

Optimasi Multi-Hop

// ============================================
// Optimasi Multi-Hop: Kompresi Payload
// ============================================

// Sebelum kompresi (14 bytes):
struct SensorData {
    float temperature;   // 4 bytes
    float humidity;      // 4 bytes
    uint32_t timestamp;  // 4 bytes
    uint16_t battery;    // 2 bytes
};

// Setelah kompresi (8 bytes):
struct CompressedData {
    int16_t temperature; // 2 bytes (x100, range -327.68 to 327.67°C)
    uint16_t humidity;   // 2 bytes (x100, range 0-655.35%)
    uint16_t timestamp;  // 2 bytes (offset dari base time, resolusi 1 menit)
    uint16_t battery;    // 2 bytes (x1000, range 0-65.535V)
};

// Penghematan: 14 bytes → 8 bytes = 43% lebih kecil
// Lebih kecil = lebih cepat transmit = lebih hemat daya
// = lebih banyak kapasitas untuk multi-hop relay

5. Self-Healing Network

Salah satu keunggulan terbesar LoRa Mesh adalah kemampuan self-healing — jaringan secara otomatis mendeteksi node yang gagal dan mencari jalur alternatif tanpa intervensi manual.

Mekanisme Self-Healing

1. Neighbor Discovery: Setiap node secara periodik mengirim beacon/hello packet ke tetangga
2. Link Quality Monitoring: Node memantau RSSI dan delivery ratio ke setiap tetangga
3. Failure Detection: Jika node tetangga tidak merespons dalam periode tertentu, dianggap gagal
4. Route Recalculation: Routing protocol menghitung ulang jalur tanpa melibatkan node yang gagal
5. Convergence: Semua node memperbarui tabel routing dan jaringan kembali stabil

SELF-HEALING: Node Failure Recovery
════════════════════════════════════

  Normal Operation:
  ┌───┐    ┌───┐    ┌───┐    ┌───┐
  │ A │────│ B │────│ C │────│ GW│  ← Path normal
  └───┘    └───┘    └───┘    └───┘

  Node B Gagal:
  ┌───┐    ┌───┐    ┌───┐    ┌───┐
  │ A │────│ B │╳╳╳╳│ C │────│ GW│
  └───┘    └───┘    └───┘    └───┘
                  ▲
                  GAGAL!

  Self-Healing: A menemukan jalur alternatif
  ┌───┐              ┌───┐    ┌───┐
  │ A │──────────────│ C │────│ GW│  ← Path baru
  └───┘              └───┘    └───┘
    │                 ▲
    └── Atau via D ───┘
       ┌───┐
       │ D │  ← Relay alternatif
       └───┘

  Recovery time: 10-60 detik (tergantung protocol)

Parameter Self-Healing

6. Implementasi LoRa Mesh

Framework dan Library

Implementasi dengan Meshtastic

# ============================================
# Setup LoRa Mesh dengan Meshtastic
# Hardware: Heltec WiFi LoRa 32 V3 / T-Beam
# ============================================

# 1. Install Meshtastic CLI
pip install meshtastic

# 2. Flash firmware ke perangkat
# Download firmware dari https://meshtastic.org/downloads
# Flash menggunakan web flasher atau ESPTool:

esptool.py --port /dev/ttyUSB0 write_flash \
  0x10000 firmware.bin

# 3. Konfigurasi via CLI
# Set region (Indonesia = AS923)
meshtastic --set lora.region AS923

# Set device sebagai Router
meshtastic --set device.role ROUTER

# Set nama node
meshtastic --set device.user.shortname "Node01"
meshtastic --set device.user.longname "Mesh Router 01"

# Set channel (shared key)
meshtastic --ch-set psk "SuperSecretKey123" --ch-index 0

# Set GPS (jika ada)
meshtastic --set position.gps_enabled true
meshtastic--set position.position_broadcast_secs 300

# 4. Cek status semua node yang terdeteksi
meshtastic --nodes

# 5. Kirim pesan text
meshtastic --sendtext "Hello from Node01!"

# 6. Kirim ke node spesifik
meshtastic --dest "!a1b2c3d4" --sendtext "Ping!"

# 7. Monitor log realtime
meshtastic --seriallog stdout

Implementasi Custom Mesh (Arduino)

// ============================================
// Custom LoRa Mesh - Simple Flooding Protocol
// Hardware: ESP32 + SX1276
// Library: RadioHead (RH_RF95 + RHMesh)
// ============================================

#include <SPI.h>
#include <RH_RF95.h>
#include <RHMesh.h>

// Konfigurasi
#define NODE_ID         1        // ID unik node ini (1-255)
#define GATEWAY_ID      10       // ID gateway node
#define MAX_HOP         5        // Maksimum hop count
#define BROADCAST_INTERVAL 60000 // Interval broadcast (ms)

// Pin LoRa
#define RFM95_CS    5
#define RFM95_RST   14
#define RFM95_INT   26
#define RF95_FREQ   920.0        // Frekuensi Indonesia

// Inisialisasi
RH_RF95 rf95(RFM95_CS, RFM95_INT);
RHMesh manager(rf95, NODE_ID);

// Tabel routing lokal
struct RouteEntry {
    uint8_t destId;
    uint8_t nextHop;
    uint8_t hopCount;
    int16_t rssi;
    unsigned long lastSeen;
};

RouteEntry routingTable[50];
uint8_t routeCount = 0;

// Mesh packet structure
struct MeshPacket {
    uint8_t sourceId;
    uint8_t destId;
    uint8_t hopCount;
    uint8_t maxHops;
    uint16_t sequenceNum;
    uint8_t dataType;      // 0=data, 1=route_discovery, 2=ack
    uint8_t payload[64];
    uint8_t payloadLen;
};

void setup() {
    Serial.begin(115200);
    Serial.printf("LoRa Mesh Node %d starting...\n", NODE_ID);

    // Reset LoRa module
    pinMode(RFM95_RST, OUTPUT);
    digitalWrite(RFM95_RST, LOW);
    delay(10);
    digitalWrite(RFM95_RST, HIGH);
    delay(10);

    if (!manager.init()) {
        Serial.println("LoRa init failed!");
        while(1);
    }

    rf95.setFrequency(RF95_FREQ);
    rf95.setTxPower(14, false);
    rf95.setSpreadingFactor(10);   // SF10 untuk range baik
    rf95.setSignalBandwidth(125000);
    rf95.setCodingRate4(5);        // 4/5

    Serial.println("Mesh node ready!");
}

void loop() {
    // 1. Cek incoming packet
    uint8_t buf[RH_MESH_MAX_MESSAGE_LEN];
    uint8_t len = sizeof(buf);
    uint8_t from;

    if (manager.recvfromAck(buf, &len, &from)) {
        MeshPacket* pkt = (MeshPacket*)buf;

        // Update routing table
        updateRoutingTable(pkt->sourceId, from,
                          pkt->hopCount, rf95.lastRssi());

        // Cek apakah untuk kita
        if (pkt->destId == NODE_ID) {
            handleIncomingPacket(pkt);
        }
        // Cek apakah perlu diteruskan
        else if (pkt->hopCount < pkt->maxHops) {
            forwardPacket(pkt);
        }
    }

    // 2. Periodic: kirim data sensor
    static unsigned long lastSend = 0;
    if (millis() - lastSend > BROADCAST_INTERVAL) {
        sendSensorData();
        lastSend = millis();
    }

    // 3. Periodic: route maintenance
    static unsigned long lastMaintenance = 0;
    if (millis() - lastMaintenance > 300000) { // 5 menit
        cleanRoutingTable();
        lastMaintenance = millis();
    }
}

void forwardPacket(MeshPacket* pkt) {
    uint8_t nextHop = findNextHop(pkt->destId);
    if (nextHop == 0) {
        // Tidak ada route, broadcast discovery
        broadcastRouteDiscovery(pkt->destId);
        return;
    }

    pkt->hopCount++;

    uint8_t err = manager.sendtoWait(
        (uint8_t*)pkt, sizeof(MeshPacket), nextHop
    );

    if (err == RH_ROUTER_ERROR_NONE) {
        Serial.printf("Forwarded to %d via %d (hop %d)\n",
                     pkt->destId, nextHop, pkt->hopCount);
    } else {
        Serial.printf("Forward failed: %d\n", err);
        // Invalidate route, try alternative
        invalidateRoute(pkt->destId, nextHop);
    }
}

void sendSensorData() {
    float temp = readTemperature();
    float hum = readHumidity();

    MeshPacket pkt;
    pkt.sourceId = NODE_ID;
    pkt.destId = GATEWAY_ID;
    pkt.hopCount = 0;
    pkt.maxHops = MAX_HOP;
    pkt.dataType = 0;

    // Encode sensor data ke payload
    int16_t tempInt = (int16_t)(temp * 100);
    uint16_t humInt = (uint16_t)(hum * 100);
    pkt.payload[0] = tempInt >> 8;
    pkt.payload[1] = tempInt & 0xFF;
    pkt.payload[2] = humInt >> 8;
    pkt.payload[3] = humInt & 0xFF;
    pkt.payloadLen = 4;

    forwardPacket(&pkt);
}

uint8_t findNextHop(uint8_t destId) {
    for (uint8_t i = 0; i < routeCount; i++) {
        if (routingTable[i].destId == destId) {
            return routingTable[i].nextHop;
        }
    }
    return 0; // No route found
}

void updateRoutingTable(uint8_t src, uint8_t from,
                        uint8_t hops, int16_t rssi) {
    for (uint8_t i = 0; i < routeCount; i++) {
        if (routingTable[i].destId == src) {
            // Update jika rute lebih baik (lebih sedikit hop)
            if (hops + 1 < routingTable[i].hopCount) {
                routingTable[i].nextHop = from;
                routingTable[i].hopCount = hops + 1;
                routingTable[i].rssi = rssi;
                routingTable[i].lastSeen = millis();
            }
            return;
        }
    }
    // Tambah entry baru
    if (routeCount < 50) {
        routingTable[routeCount].destId = src;
        routingTable[routeCount].nextHop = from;
        routingTable[routeCount].hopCount = hops + 1;
        routingTable[routeCount].rssi = rssi;
        routingTable[routeCount].lastSeen = millis();
        routeCount++;
    }
}

void cleanRoutingTable() {
    unsigned long now = millis();
    uint8_t writeIdx = 0;
    for (uint8_t i = 0; i < routeCount; i++) {
        if (now - routingTable[i].lastSeen < 900000) { // 15 menit timeout
            if (writeIdx != i) {
                routingTable[writeIdx] = routingTable[i];
            }
            writeIdx++;
        }
    }
    routeCount = writeIdx;
    Serial.printf("Route table cleaned, %d entries remain\n", routeCount);
}

7. Optimasi Jaringan Mesh

Optimasi Daya

Optimasi Kapasitas Jaringan

8. Deployment di Lapangan

Langkah Persiapan Deployment

1. Survey Lokasi: Petakan area, identifikasi titik-titik potensial untuk node, ukur jarak antar titik
2. Simulasi Coverage: Gunakan tools seperti Radio Mobile atau CloudRF untuk simulasi coverage
3. Penentuan Jumlah Node: Hitung kebutuhan node berdasarkan jarak, obstacle, dan density
4. Hardware Selection: Pilih perangkat sesuai kebutuhan (indoor/outdoor, solar/battery)
5. Prototyping: Uji skala kecil (5-10 node) sebelum full deployment
6. Installasi: Pasang node dengan mounting yang kokoh, antenna yang tepat
7. Testing & Commissioning: Uji semua jalur komunikasi, verifikasi data sampai ke server
8. Monitoring Setup: Pasang sistem monitoring untuk alert jika node mati

Pertimbangan Hardware untuk Deployment

9. Kasus Penggunaan LoRa Mesh

1. Monitoring Pertanian Terpencil

Di lahan pertanian yang luas tanpa infrastruktur internet, LoRa Mesh memungkinkan sensor tanah, kelembaban, dan cuaca saling berkomunikasi hingga ke posko utama melalui relay antar sensor.

2. Disaster Recovery Communication

Saat bencana alam (gempa, tsunami) dan infrastruktur komunikasi rusak, LoRa Mesh bisa menjadi jaringan komunikasi darurat yang cepat didirikan. Setiap node tidak memerlu koneksi internet.

3. Smart Forest / Anti-Illegal Logging

Sensor suara (chainsaw detection) dan sensor asap yang tersebar di hutan dapat membentuk mesh network untuk melaporkan aktivitas illegal logging atau kebakaran hutan ke pos jaga terdekat.

4. Mining & Pertambangan

Area tambang yang luas dan terpencil membutuhkan monitoring keselamatan (gas, longsor, suhu). LoRa Mesh memberikan coverage tanpa perlu infrastruktur cellular yang mahal.

5. Maritime / Nelayan

Di kepulauan Indonesia, nelayan di pulau kecil bisa saling berkomunikasi dan melaporkan posisi tangkapan menggunakan LoRa Mesh tanpa perlu BTS cellular.

10. Quiz: Uji Pemahamanmu!

Setelah membaca tutorial di atas, jawablah 5 pertanyaan berikut untuk menguji pemahamanmu tentang LoRa Mesh Networking: