IoT LiDAR untuk Estimasi Volume Material Secara Real-Time: Konsep, Arsitektur & Implementasi

Industri yang mengelola material curah (bulk material) — seperti pertambangan, logistik pelabuhan, dan konstruksi — selalu menghadapi tantangan yang sama: bagaimana mengukur volume material secara akurat, cepat, dan tanpa mengganggu operasional?

Metode konvensional seperti survei topografi manual atau timbangan statis memiliki keterbatasan: lambat, membutuhkan tenaga kerja, dan rentan terhadap human error. Di sinilah IoT LiDAR hadir sebagai solusi.

Apa Itu LiDAR dan Mengapa IoT?

LiDAR (Light Detection and Ranging) adalah teknologi penginderaan jarak jauh yang memancarkan pulsa laser dan mengukur waktu pantulannya untuk membentuk 3D point cloud dari objek atau permukaan.

Ketika LiDAR diintegrasikan ke dalam ekosistem IoT (Internet of Things), sensor tidak hanya menghasilkan data — tetapi juga:

• Mengirim data secara otomatis ke cloud atau edge server
• Memicu alert jika volume melampaui threshold
• Memberi insight real-time melalui dashboard tanpa intervensi manual

Bayangkan sebuah sensor yang terpasang di atas conveyor belt atau stockpile area, secara kontinu memindai permukaan material dan menghitung volumenya — 24/7, tanpa operator.

Use Case: Monitoring Volume Stockpile Secara Otomatis

Salah satu penerapan paling relevan adalah monitoring volume stockpile di area penyimpanan material curah. Berikut skenarionya:

Arsitektur Sistem End-to-End

Berikut adalah arsitektur tipikal untuk sistem IoT LiDAR volume estimation:

flowchart TD
    subgraph EDGE["Edge Layer"]
        A["LiDAR Sensorn(2D/3D)"] --> B["Edge Gatewayn(Raspberry Pi / Jetson)"]
        B --> C["Point CloudnPre-processing"]
    end

    subgraph CLOUD["Cloud / Server Layer"]
        C -->|MQTT / HTTP| D["Message Brokern(MQTT Broker / Kafka)"]
        D --> E["Volume CalculationnEngine"]
        E --> F[("Time-Series DBn(InfluxDB / TimescaleDB)")]
        F --> G["REST APInService"]
    end

    subgraph APP["Application Layer"]
        G --> H["Web Dashboardn(React / Grafana)"]
        G --> I["Mobile App"]
        G --> J["Alert Systemn(Email / Telegram)"]
    end

    style EDGE fill:#e8f5e9,stroke:#43a047
    style CLOUD fill:#e3f2fd,stroke:#1e88e5
    style APP fill:#fff3e0,stroke:#fb8c00

Penjelasan Layer

1. Edge Layer

• Sensor LiDAR (misal: SICK LMS1xx, Velodyne Puck) menghasilkan point cloud
• Edge gateway melakukan pre-processing: filtering noise, cropping ROI (Region of Interest), dan konversi ke format standar

2. Cloud / Server Layer

• Data dikirim via MQTT untuk efisiensi bandwidth
• Volume Calculation Engine melakukan komputasi volumetrik dari point cloud
• Hasil disimpan di time-series database untuk historical analysis

3. Application Layer

• Dashboard menampilkan volume real-time, trend, dan perbandingan terhadap target/plan
• Alert system mengirim notifikasi jika volume melebihi kapasitas atau di bawah threshold

Sequence Diagram: Alur Pengukuran Volume

Berikut sequence diagram yang menggambarkan interaksi antar komponen saat satu siklus pengukuran volume terjadi:

sequenceDiagram
    autonumber
    participant S as LiDAR Sensor
    participant EG as Edge Gateway
    participant MB as MQTT Broker
    participant VE as Volume Engine
    participant DB as TimescaleDB
    participant API as REST API
    participant UI as Web Dashboard
    participant AL as Alert System

    rect rgb(232, 245, 233)
        Note over S, EG: Edge Layer
        S->>EG: Raw point cloud (x,y,z)
        EG->>EG: Noise filtering & ROI cropping
        EG->>EG: Downsample & format conversion
    end

    rect rgb(227, 242, 253)
        Note over MB, DB: Cloud / Server Layer
        EG->>MB: Publish topic "lidar/stockpile-01/scan"
        MB->>VE: Forward point cloud payload
        VE->>VE: Grid interpolation
        VE->>VE: Riemann Sum → volume (m³)
        VE->>VE: Calculate confidence score
        VE->>DB: INSERT volume_measurements
        DB-->>VE: ACK stored
    end

    rect rgb(255, 243, 224)
        Note over API, AL: Application Layer
        UI->>API: GET /api/v1/volume/latest?sensor=STOCKPILE-01
        API->>DB: SELECT latest measurement
        DB-->>API: volume_m3, confidence_pct, measured_at
        API-->>UI: JSON response
        UI->>UI: Render gauge + trend chart
    end

    rect rgb(255, 235, 238)
        Note over VE, AL: Alert Flow (conditional)
        VE->>VE: Check threshold rules
        alt volume > capacity_max
            VE->>AL: Trigger OVER_CAPACITY alert
            AL->>AL: Send Telegram + Email notification
        else volume < minimum_threshold
            VE->>AL: Trigger LOW_STOCK alert
            AL->>AL: Send Telegram + Email notification
        end
    end

Penjelasan Alur

1. Scan & Pre-process — Sensor LiDAR mengirim raw point cloud ke edge gateway, yang melakukan filtering, cropping ROI, dan downsampling
2. Publish & Compute — Data dikirim via MQTT ke Volume Engine yang melakukan grid interpolation dan kalkulasi Riemann Sum
3. Store & Serve — Hasil disimpan di TimescaleDB dan disajikan ke dashboard melalui REST API
4. Alert — Jika volume melampaui threshold (over capacity atau low stock), sistem mengirim notifikasi otomatis

Pipeline Perhitungan Volume dari Point Cloud

Proses inti dari sistem ini adalah mengubah raw point cloud menjadi angka volume (m³). Berikut tahapannya:

Step 1 — Akuisisi & Filtering

import numpy as np

# Simulasi raw point cloud (x, y, z)
raw_points = np.random.rand(10000, 3) * [10, 5, 3]  # area 10x5m, tinggi max 3m

# Statistical Outlier Removal (SOR)
from sklearn.neighbors import NearestNeighbors

def remove_outliers(points, k=20, std_ratio=2.0):
    nn = NearestNeighbors(n_neighbors=k)
    nn.fit(points)
    distances, _ = nn.kneighbors(points)
    mean_dist = distances.mean(axis=1)
    threshold = mean_dist.mean() + std_ratio * mean_dist.std()
    return points[mean_dist < threshold]

filtered_points = remove_outliers(raw_points)

Step 2 — Surface Reconstruction (Grid-based)

from scipy.interpolate import griddata

# Buat grid 2D
grid_res = 0.1  # 10cm resolution
x_grid = np.arange(0, 10, grid_res)
y_grid = np.arange(0, 5, grid_res)
xx, yy = np.meshgrid(x_grid, y_grid)

# Interpolasi Z (tinggi) ke grid
zz = griddata(
    filtered_points[:, :2],  # x, y
    filtered_points[:, 2],   # z
    (xx, yy),
    method='linear'
)

Step 3 — Volume Calculation (Riemann Sum)

# Volume = sum of (grid_cell_area * height)
cell_area = grid_res ** 2  # 0.01 m²
zz_clean = np.nan_to_num(zz, nan=0.0)

volume_m3 = np.sum(zz_clean * cell_area)
print(f"Estimated Volume: {volume_m3:.2f} m³")

Faktor yang Mempengaruhi Akurasi

Beberapa faktor kritis yang mempengaruhi kualitas estimasi volume:

1. Resolusi sensor — Semakin tinggi resolusi (points/second), semakin detail surface reconstruction
2. Mounting angle & coverage — Posisi pemasangan sensor menentukan blind spot dan area coverage
3. Kondisi lingkungan — Debu, hujan, dan perubahan suhu dapat mempengaruhi pantulan laser
4. Grid resolution — Trade-off antara akurasi dan computational cost
5. Kalibrasi baseline — Permukaan referensi (ground plane) harus dikalibrasi dengan benar

Data Model untuk Time-Series Storage

Struktur penyimpanan hasil pengukuran di time-series database:

CREATE TABLE volume_measurements (
    measurement_id   BIGSERIAL PRIMARY KEY,
    sensor_id        VARCHAR(50)   NOT NULL,
    location_code    VARCHAR(20)   NOT NULL,
    measured_at      TIMESTAMPTZ   NOT NULL,
    volume_m3        NUMERIC(12,4) NOT NULL,
    point_count      INTEGER,
    grid_resolution  NUMERIC(5,3),
    confidence_pct   NUMERIC(5,2),  -- akurasi estimasi
    material_type    VARCHAR(50),
    created_at       TIMESTAMPTZ   DEFAULT NOW()
);

-- Index untuk query dashboard
CREATE INDEX idx_vol_sensor_time 
    ON volume_measurements (sensor_id, measured_at DESC);

-- Hypertable (TimescaleDB)
SELECT create_hypertable('volume_measurements', 'measured_at');

Contoh Query Analisis

Rata-rata volume per jam (trend harian)

SELECT 
    time_bucket('1 hour', measured_at) AS hour_bucket,
    location_code,
    AVG(volume_m3)   AS avg_volume,
    MIN(volume_m3)   AS min_volume,
    MAX(volume_m3)   AS max_volume,
    COUNT(*)         AS sample_count
FROM volume_measurements
WHERE measured_at >= NOW() - INTERVAL '24 hours'
  AND sensor_id = 'LIDAR-STOCKPILE-01'
GROUP BY hour_bucket, location_code
ORDER BY hour_bucket;

Deteksi anomali — volume drop tiba-tiba

WITH volume_lag AS (
    SELECT 
        measured_at,
        volume_m3,
        LAG(volume_m3) OVER (ORDER BY measured_at) AS prev_volume
    FROM volume_measurements
    WHERE sensor_id = 'LIDAR-STOCKPILE-01'
      AND measured_at >= NOW() - INTERVAL '6 hours'
)
SELECT *,
    (volume_m3 - prev_volume) AS delta_volume,
    ROUND((volume_m3 - prev_volume) / NULLIF(prev_volume, 0) * 100, 2) AS pct_change
FROM volume_lag
WHERE ABS(volume_m3 - prev_volume) / NULLIF(prev_volume, 0) > 0.15  -- >15% change
ORDER BY measured_at;

Dashboard Metrics yang Direkomendasikan

Untuk monitoring operasional, minimal tampilkan:

• 📊 Volume real-time — gauge/card yang menampilkan volume terkini
• 📈 Volume trend (24h) — line chart per jam untuk melihat pola in/out
• ⚠️ Capacity utilization — persentase volume terhadap kapasitas maksimum area
• 🔔 Alert log — riwayat alert threshold breach
• 📉 Daily comparison — bar chart volume harian vs plan/target

Kesimpulan

Teknologi IoT LiDAR memberikan kemampuan non-contact, real-time volume estimation yang sulit dicapai dengan metode konvensional. Dengan arsitektur edge-cloud yang tepat dan pipeline point cloud yang teroptimasi, organisasi dapat:

• ✅ Mengurangi ketergantungan pada pengukuran manual
• ✅ Mendapatkan data volume secara near-real-time untuk decision making
• ✅ Mendeteksi anomali lebih cepat (pencurian material, equipment malfunction)
• ✅ Mengintegrasikan data volume dengan sistem ERP/MES yang sudah ada

Artikel ini ditulis berdasarkan pengalaman implementasi dan riset teknologi sensor industri. Semua kode bersifat ilustratif dan dapat diadaptasi sesuai kebutuhan.