☁️ IoT Cloud Platform: Panduan Lengkap

#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>

// AWS IoT Configuration
const char* AWS_IOT_ENDPOINT = "xxxxxxxxxxxx-ats.iot.ap-southeast-1.amazonaws.com";
const char* THING_NAME = "sensor_gedung1_001";

// WiFi
const char* SSID = "WiFi-Rumah";
const char* PASSWORD = "password123";

// Topics
const char* PUBLISH_TOPIC = "gedung1/sensor/001/data";
const char* SUBSCRIBE_TOPIC = "gedung1/sensor/001/cmd";
const char* SHADOW_UPDATE = "$aws/thing/sensor_gedung1_001/shadow/update";
const char* SHADOW_GET = "$aws/thing/sensor_gedung1_001/shadow/get";

// TLS Certificates (downloaded from AWS IoT console)
// Simpan di SPIFFS atau PROGMEM
const char AMAZON_ROOT_CA1[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
... your AmazonRootCA1.pem ...
-----END CERTIFICATE-----
)EOF";

const char CERTIFICATE[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
... your device-certificate.pem.crt ...
-----END CERTIFICATE-----
)EOF";

const char PRIVATE_KEY[] PROGMEM = R"EOF(
-----BEGIN RSA PRIVATE KEY-----
... your private.pem.key ...
-----END RSA PRIVATE KEY-----
)EOF";

WiFiClientSecure net;
PubSubClient client(net);

void connectWiFi() {
    WiFi.mode(WIFI_STA);
    WiFi.begin(SSID, PASSWORD);
    Serial.print("Connecting to WiFi");
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    Serial.println(" Connected!");
}

void connectAWS() {
    net.setCACert(AMAZON_ROOT_CA1);
    net.setCertificate(CERTIFICATE);
    net.setPrivateKey(PRIVATE_KEY);

    client.setServer(AWS_IOT_ENDPOINT, 8883);
    client.setCallback(messageHandler);

    Serial.print("Connecting to AWS IoT Core");
    while (!client.connected()) {
        if (client.connect(THING_NAME)) {
            Serial.println(" Connected!");
            client.subscribe(SUBSCRIBE_TOPIC);
            client.subscribe(SHADOW_GET_ACCEPTED);
        } else {
            Serial.printf(" Failed (rc=%d), retrying...\n", client.state());
            delay(3000);
        }
    }
}

void messageHandler(char* topic, byte* payload, unsigned int length) {
    StaticJsonDocument<512> doc;
    deserializeJson(doc, payload, length);

    // Handle shadow response
    if (String(topic).endsWith("/shadow/get/accepted")) {
        JsonObject state = doc["state"]["desired"];
        int interval = state["interval"] | 5;
        Serial.printf("Shadow interval: %d detik\n", interval);
    }

    // Handle command
    if (String(topic) == SUBSCRIBE_TOPIC) {
        const char* action = doc["action"];
        Serial.printf("Command: %s\n", action);
    }
}

void publishSensorData(float suhu, float lembab) {
    StaticJsonDocument<256> doc;
    doc["device_id"] = THING_NAME;
    doc["timestamp"] = millis();
    doc["suhu"] = suhu;
    doc["kelembaban"] = lembab;

    char jsonBuffer[256];
    serializeJson(doc, jsonBuffer);
    client.publish(PUBLISH_TOPIC, jsonBuffer);
}

void updateShadow(float suhu) {
    StaticJsonDocument<512> doc;
    doc["state"]["reported"]["suhu"] = suhu;
    doc["state"]["reported"]["status"] = "online";
    doc["state"]["reported"]["firmware"] = "2.1.0";

    char jsonBuffer[512];
    serializeJson(doc, jsonBuffer);
    client.publish(SHADOW_UPDATE, jsonBuffer);
}

void setup() {
    Serial.begin(115200);
    connectWiFi();
    connectAWS();
}

void loop() {
    if (!client.connected()) connectAWS();
    client.loop();

    float suhu = 25.5;  // Baca sensor
    publishSensorData(suhu, 65.0);
    updateShadow(suhu);
    delay(5000);
}

from azure.iot.device import IoTHubDeviceClient, Message
import json, time, random

# Connection string dari Azure Portal
CONNECTION_STRING = "HostName=myhub.azure-devices.net;DeviceId=sensor001;SharedAccessKey=..."

# Buat client
client = IoTHubDeviceClient.create_from_connection_string(CONNECTION_STRING)
client.connect()

def send_telemetry():
    data = {
        "suhu": round(random.uniform(20, 35), 2),
        "kelembaban": round(random.uniform(40, 80), 2),
        "tekanan": round(random.uniform(1010, 1020), 2)
    }
    msg = Message(json.dumps(data))
    msg.content_encoding = "utf-8"
    msg.content_type = "application/json"
    msg.custom_properties["sensor_type"] = "BME280"

    client.send_message(msg)
    print(f"Sent: {data}")

def handle_method(request):
    print(f"Method: {request.name}, Payload: {request.payload}")
    if request.name == "reboot":
        # Handle reboot command
        client.send_method_response(
            MethodResponse(request.request_id, 200, {"status": "rebooting"})
        )

client.on_method_request_received = handle_method

try:
    while True:
        send_telemetry()
        time.sleep(5)
except KeyboardInterrupt:
    client.disconnect()

from google.cloud import pubsub_v1
import json, time, random

# Setup Pub/Sub publisher
PROJECT_ID = "my-gcp-project"
TOPIC_ID = "iot-sensor-data"

publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(PROJECT_ID, TOPIC_ID)

def publish_sensor_data(device_id, suhu, lembab):
    data = {
        "device_id": device_id,
        "suhu": suhu,
        "kelembaban": lembab,
        "timestamp": int(time.time())
    }
    # Pub/Sub menerima data bytes
    future = publisher.publish(
        topic_path,
        json.dumps(data).encode("utf-8"),
        device_id=device_id,  # Attribute untuk filtering
        sensor_type="BME280"
    )
    print(f"Published: {future.result()}")

# Kirim data setiap 5 detik
for i in range(100):
    publish_sensor_data(
        "sensor_gedung1_001",
        round(random.uniform(20, 35), 2),
        round(random.uniform(40, 80), 2)
    )
    time.sleep(5)

# /etc/mosquitto/conf.d/aws-bridge.conf

# Bridge connection ke AWS IoT Core
connection aws-iot-bridge
address xxxxxxxxxx-ats.iot.ap-southeast-1.amazonaws.com:8883

# Topics: publish local data ke AWS
topic sensor/+/data out 1 $aws/things/+/shadow/update
topic sensor/+/status out 0

# Topics: subscribe dari AWS (commands)
topic cmd/+ in 1

# TLS/SSL Configuration
bridge_cafile /etc/mosquitto/certs/AmazonRootCA1.pem
bridge_certfile /etc/mosquitto/certs/device-certificate.pem.crt
bridge_keyfile /etc/mosquitto/certs/private.pem.key

# Connection settings
bridge_protocol_version mqttv311
cleansession true
notifications true
restart_timeout 30
keepalive_interval 60

# Local broker tetap berjalan
listener 1883
allow_anonymous false
password_file /etc/mosquitto/passwd

# EMQX mendukung bridging ke multiple cloud secara native
# Konfigurasi via EMQX Dashboard atau emqx.conf

# Bridge ke AWS IoT Core
bridges {
  aws_iot {
    enable = true
    server = "xxxxx-ats.iot.ap-southeast-1.amazonaws.com:8883"
    clientid = "emqx-bridge"
    ssl {
      enable = true
      cacertfile = "etc/certs/AmazonRootCA1.pem"
      certfile = "etc/certs/device.pem.crt"
      keyfile = "etc/certs/device.pem.key"
    }
    ingress {
      remote_topic = "cmd/#"
      local_topic = "cloud/${topic}"
    }
    egress {
      local_topic = "sensor/#"
      remote_topic = "devices/${topic}"
    }
  }

  # Bridge ke Azure IoT Hub
  azure_iot_hub {
    enable = true
    server = "myhub.azure-devices.net:8883"
    clientid = "sensor001"
    username = "myhub.azure-devices.net/sensor001/api-version=2021-04-12"
    password = "SAS_TOKEN_HERE"
    ssl { enable = true }
  }

  # Bridge ke GCP Pub/Sub via webhook
  gcp_pubsub {
    enable = true
    type = "http"
    url = "https://pubsub.googleapis.com/v1/projects/my-project/topics/iot-data:publish"
    method = "post"
    headers = { "Authorization" = "Bearer TOKEN" }
  }
}

#include <WiFiClientSecure.h>
#include <MQTTClient.h>
#include <ArduinoJson.h>
#include <Update.h>

// AWS IoT Jobs - OTA Update Handler
WiFiClientSecure net;
MQTTClient client(512);

String currentFirmware = "2.1.0";

void handleJobExecution(String& payload) {
    StaticJsonDocument<512> doc;
    deserializeJson(doc, payload);

    JsonObject job = doc["execution"]["jobDocument"];
    String url = job["url"];
    String version = job["version"];

    Serial.printf("OTA Update: v%s → v%s\n",
                  currentFirmware.c_str(), version.c_str());

    // Download dan flash firmware
    HTTPClient http;
    http.begin(url);
    int httpCode = http.GET();

    if (httpCode == 200) {
        int contentLength = http.getSize();
        if (Update.begin(contentLength)) {
            Update.writeStream(*http.getStreamPtr());
            if (Update.end()) {
                Serial.println("Update berhasil! Rebooting...");
                ESP.restart();
            }
        }
    }

    // Report result ke AWS IoT
    String statusTopic = "$aws/things/" + String(THING_NAME) +
                        "/jobs/" + String(doc["execution"]["jobId"]) +
                        "/update";
    String status = "{\"status\":\"SUCCEEDED\",\"version\":\"" +
                    version + "\"}";
    client.publish(statusTopic.c_str(), status.c_str());
}

-- Rule 1: Simpan semua data sensor ke DynamoDB
SELECT
  topic(2) as device_id,
  timestamp() as ts,
  suhu, kelembaban, tekanan
FROM 'sensor/+/data'

-- Rule 2: Kirim alarm jika suhu > 35°C
SELECT
  topic(2) as device_id,
  suhu as current_temp,
  35 as threshold,
  'HIGH_TEMPERATURE' as alarm_type
FROM 'sensor/+/data'
WHERE suhu > 35

-- Rule 3: Transform data untuk analytics
SELECT
  topic(2) as device_id,
  timestamp() as epoch,
  suhu * 9/5 + 32 as suhu_fahrenheit,
  ROUND(kelembaban, 0) as humidity_pct,
  CASE
    WHEN suhu > 35 THEN 'CRITICAL'
    WHEN suhu > 30 THEN 'WARNING'
    ELSE 'NORMAL'
  END as status
FROM 'sensor/+/data'

import json
import boto3
from datetime import datetime

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('IoT_SensorData')
sns = boto3.client('sns')

def lambda_handler(event, context):
    """Dipanggil oleh IoT Rules Engine setiap ada data sensor."""

    device_id = event['device_id']
    suhu = float(event['suhu'])
    kelembaban = float(event['kelembaban'])
    timestamp = event.get('ts', int(datetime.now().timestamp()))

    # 1. Simpan ke DynamoDB
    table.put_item(Item={
        'device_id': device_id,
        'timestamp': timestamp,
        'suhu': suhu,
        'kelembaban': kelembaban
    })

    # 2. Cek threshold dan kirim alarm
    if suhu > 35.0:
        sns.publish(
            TopicArn='arn:aws:sns:region:account:iot-alerts',
            Subject=f'⚠️ SUHU TINGGI - {device_id}',
            Message=f'Device {device_id}: Suhu {suhu}°C melebihi threshold 35°C!'
        )

    # 3. Hitung rata-rata per jam
    check_hourly_average(device_id)

    return {'statusCode': 200, 'body': 'OK'}

def check_hourly_average(device_id):
    """Cek rata-rata suhu per jam, trigger alert jika abnormal."""
    from boto3.dynamodb.conditions import Key
    import time

    one_hour_ago = int(time.time()) - 3600
    response = table.query(
        KeyConditionExpression=Key('device_id').eq(device_id) &
                               Key('timestamp').gte(one_hour_ago)
    )
    items = response['Items']
    if items:
        avg_temp = sum(i['suhu'] for i in items) / len(items)
        if avg_temp > 32:
            sns.publish(
                TopicArn='arn:aws:sns:region:account:iot-alerts',
                Subject=f'📊 Rata-rata suhu tinggi - {device_id}',
                Message=f'Rata-rata suhu 1 jam: {avg_temp:.1f}°C'
            )

# ARSITEKTUR SMART FARMING DENGAN IoT CLOUD
#
# LAYER 1: FIELD SENSORS
# ├── ESP32 #1: Suhu, Kelembaban tanah, Cahaya
# ├── ESP32 #2: pH tanah, Nutrisi (EC), Suhu air
# └── ESP32 #3: Kamera (pest detection), Curah hujan
#
# LAYER 2: GATEWAY
# └── Raspberry Pi 4
#     ├── MQTT Broker (Mosquitto) — lokal
#     ├── Data buffering (SQLite) — offline mode
#     ├── MQTT Bridge ke AWS IoT Core
#     └── Rule engine lokal (irrigasi otomatis)
#
# LAYER 3: CLOUD (AWS IoT Core)
# ├── Rules Engine → DynamoDB (data storage)
# ├── Rules Engine → Lambda → SNS (alert)
# ├── Rules Engine → S3 (data archive)
# └── Device Shadow (remote config)
#
# LAYER 4: DASHBOARD & ALERTING
# ├── Grafana Dashboard (monitoring real-time)
# ├── Mobile App (React Native)
# ├── Email/SMS Alerts (via SNS)
# └── Prediksi panen (SageMaker ML)
#
# DATA FLOW:
# Sensor → ESP32 → MQTT → Gateway → AWS IoT → DynamoDB
# Commands: Dashboard → AWS IoT → MQTT → Gateway → ESP32 → Relay