🖥️ Edge Computing untuk IoT: Panduan Lengkap

#include <TensorFlowLite_ESP32.h>
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "tensorflow/lite/schema/schema_generated.h"

// Model yang sudah di-train dan di-convert ke TFLite Micro
#include "model_data.h"  // Hasil export dari TensorFlow

// Arena memory untuk TFLite
constexpr int kTensorArenaSize = 32 * 1024;  // 32KB
uint8_t tensor_arena[kTensorArenaSize];

const tflite::Model* model;
tflite::MicroInterpreter* interpreter;
TfLiteTensor* input;
TfLiteTensor* output;

void setup() {
    Serial.begin(115200);

    // Load model
    model = tflite::GetModel(model_data);
    static tflite::AllOpsResolver resolver;

    static tflite::MicroInterpreter static_interpreter(
        model, resolver, tensor_arena, kTensorArenaSize
    );
    interpreter = &static_interpreter;

    // Allocate tensors
    interpreter->AllocateTensors();

    // Get input/output tensors
    input = interpreter->input(0);
    output = interpreter->output(0);

    Serial.println("TinyML model loaded!");
    Serial.printf("Input size: %d\n", input->bytes);
    Serial.printf("Arena used: %d bytes\n", interpreter->arena_used_bytes());
}

void loop() {
    // Baca sensor (contoh: 3-axis accelerometer)
    float ax = readAccelX();  // -1.0 to 1.0
    float ay = readAccelY();
    float az = readAccelZ();

    // Normalisasi dan isi input tensor
    input->data.f[0] = ax;
    input->data.f[1] = ay;
    input->data.f[2] = az;

    // Jalankan inference
    unsigned long start = micros();
    interpreter->Invoke();
    unsigned long elapsed = micros() - start;

    // Baca hasil
    // Misal: 0=diam, 1=jalan, 2=lari, 3=jatuh
    int predicted_class = -1;
    float max_score = -1;
    for (int i = 0; i < output->bytes / sizeof(float); i++) {
        if (output->data.f[i] > max_score) {
            max_score = output->data.f[i];
            predicted_class = i;
        }
    }

    const char* labels[] = {"Diam", "Jalan", "Lari", "Jatuh"};
    Serial.printf("Activity: %s (%.2f) - Inference: %lu us\n",
                  labels[predicted_class], max_score, elapsed);

    // Edge action: trigger alarm jika "Jatuh"
    if (predicted_class == 3 && max_score > 0.8) {
        Serial.println("⚠️ FALL DETECTED! Sending alert...");
        // Kirim alert ke cloud (bukan raw sensor data!)
        mqtt_publish("alert/fall", "sensor_001");
    }

    delay(100);  // 10 Hz inference rate
}

import paho.mqtt.client as mqtt
import json, time, sqlite3
from threading import Thread

class IoTGateway:
    def __init__(self):
        # Local broker (ke device lokal)
        self.local = mqtt.Client("gateway-local")
        self.local.connect("localhost", 1883)

        # Cloud broker (ke AWS/Azure)
        self.cloud = mqtt.Client("gateway-cloud")
        self.cloud.tls_set("ca.crt", "client.crt", "client.key")
        self.cloud.connect("aws-iot-endpoint", 8883)

        # Local database
        self.db = sqlite3.connect('gateway.db')
        self.db.execute('''CREATE TABLE IF NOT EXISTS buffer
                          (ts REAL, topic TEXT, data TEXT, sent INT DEFAULT 0)''')

        # Rules engine
        self.rules = [
            {'topic': 'sensor/+/suhu', 'threshold': 35, 'action': 'alarm'},
            {'topic': 'sensor/+/suhu', 'threshold': 0, 'below': True, 'action': 'alarm'}
        ]

    def on_local_message(self, client, userdata, msg):
        """Terima data dari device lokal."""
        data = json.loads(msg.payload.decode())

        # Simpan ke buffer
        self.db.execute('INSERT INTO buffer VALUES (?, ?, ?, 0)',
                       (time.time(), msg.topic, json.dumps(data)))
        self.db.commit()

        # Evaluasi rules lokal
        self.evaluate_rules(msg.topic, data)

        # Agregasi dan kirim ke cloud
        self.forward_to_cloud(msg.topic, data)

    def evaluate_rules(self, topic, data):
        """Evaluasi rules di edge — tanpa cloud dependency!"""
        if 'suhu' in data and data['suhu'] > 35:
            # Trigger alarm LOKAL (buzzer, LED, relay)
            self.local.publish('cmd/alarm', json.dumps({
                'device': data.get('device_id'),
                'type': 'HIGH_TEMP',
                'value': data['suhu']
            }))

    def forward_to_cloud(self, topic, data):
        """Teruskan data ke cloud (dengan filter)."""
        cloud_topic = topic.replace('sensor/', 'devices/')
        self.cloud.publish(cloud_topic, json.dumps(data))

    def start(self):
        self.local.on_message = self.on_local_message
        self.local.subscribe("sensor/#")

        Thread(target=self.local.loop_forever).start()
        Thread(target=self.cloud.loop_forever).start()

        # Periodic sync
        while True:
            self.sync_buffered()
            time.sleep(60)

gateway = IoTGateway()
gateway.start()

# EDGE: ESP32 dengan accelerometer pada motor industri
# - Baca getaran 1000 Hz (vibration analysis)
# - Jalankan FFT (Fast Fourier Transform) di edge
# - Jalankan anomaly detection model (TFLite)
# - Jika anomaly terdeteksi → alert lokal + kirim ke cloud
#
# CLOUD: AWS/GCP
# - Terima anomaly events (bukan raw vibration data!)
# - Dashboard maintenance untuk seluruh pabrik
# - Train ulang model berdasarkan feedback teknisi
# - Push model baru ke edge device (OTA)
#
# PENGHEMATAN BANDWIDTH:
# Raw data: 1000 samples/sec × 4 bytes = 4 KB/s per device
# Dengan 100 devices = 400 KB/s = 34 GB/hari!
# Edge analytics: ~1 event/menit × 200 bytes = 12 KB/jam
# Penghematan: 99.97%!

# EDGE (per lahan):
# - Raspberry Pi Gateway + multiple ESP32 sensors
# - Soil moisture, temperature, humidity, light, pH
# - Edge rules: if soil_moisture < 30% → activate irrigation
# - Edge rules: if temp > 40 → activate shade/sprinkler
# - Data aggregation: kirim rata-rata per jam ke cloud
#
# CLOUD:
# - Analytics musiman (trend analysis)
# - Rekomendasi tanam berdasarkan historical data
# - Integrasi cuaca (weather API)
# - Dashboard petani via mobile app
#
# MANFAAT:
# - Respons irigasi < 1 detik (edge rules)
# - Tetap berfungsi saat internet mati (offline)
# - Hemat bandwidth (summary per jam)
# - Data historis untuk optimasi jangka panjang