OTA Update ESP32: Update Firmware Tanpa Kabel

#include <esp_ota_ops.h>

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

  // Cek apakah ini boot pertama setelah OTA
  const esp_partition_t* running =
    esp_ota_get_running_partition();
  esp_ota_img_states_t state;

  if (esp_ota_get_state_partition(running, &state) == ESP_OK) {
    if (state == ESP_OTA_IMG_PENDING_VERIFY) {
      // Firmware baru berjalan pertama kali
      // Lakukan self-test di sini:
      bool selfTestOK = runSelfTest();

      if (selfTestOK) {
        // Konfirmasi firmware valid
        esp_ota_mark_app_valid_cancel_rollback();
        Serial.println("Firmware baru dikonfirmasi!");
      } else {
        // Firmware bermasalah, rollback ke versi lama
        Serial.println("Self-test gagal! Rollback...");
        esp_ota_mark_app_invalid_and_rollback();
        ESP.restart();
      }
    }
  }
}

bool runSelfTest() {
  // Test koneksi WiFi
  // Test koneksi server
  // Test sensor aktif
  // Return true jika semua OK
  return true;
}

// ============================================
// Proyek: Remote Update Sensor Node
// ESP32 + DHT11 + MQTT + HTTP OTA
// BeebaneLabs - https://beebanelabs.pages.dev
// ============================================

#include <WiFi.h>
#include <PubSubClient.h>
#include <HTTPClient.h>
#include <HTTPUpdate.h>
#include <DHT.h>
#include <esp_ota_ops.h>

// ====== KONFIGURASI ======
#define FIRMWARE_VERSION    "1.2.0"
#define LED_STATUS_PIN      2
#define DHT_PIN             4
#define DHT_TYPE            DHT11
#define OTA_CHECK_INTERVAL  300000  // 5 menit

const char* ssid          = "WIFI_KAMU";
const char* password      = "PASSWORD_WIFI";
const char* mqtt_server   = "192.168.1.100";
const int   mqtt_port     = 1883;
const char* mqtt_topic    = "iot/sensornode/data";
const char* mqtt_cmd_topic= "iot/sensornode/cmd";
const char* ota_version_url =
  "http://yourserver.com/ota/version.txt";
const char* ota_firmware_url =
  "http://yourserver.com/ota/firmware.bin";

// ====== OBJEK GLOBAL ======
WiFiClient espClient;
PubSubClient mqtt(espClient);
DHT dht(DHT_PIN, DHT_TYPE);

unsigned long lastOTA = 0;
unsigned long lastRead = 0;

// ====== LED STATUS ======
void setLedStatus(const char* mode) {
  // Dipanggil dengan "ok", "ota", "error"
  // Implementasi LED blink pattern bisa ditambah
  Serial.printf("Status: %s\n", mode);
}

// ====== WIFI ======
void setupWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Menghubungkan WiFi");

  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 30) {
    delay(500);
    Serial.print(".");
    attempts++;
  }

  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nWiFi OK! IP: " + WiFi.localIP().toString());
  } else {
    Serial.println("\nWiFi gagal! Restart...");
    ESP.restart();
  }
}

// ====== MQTT ======
void mqttCallback(char* topic, byte* payload, unsigned int length) {
  String msg;
  for (int i = 0; i < length; i++) {
    msg += (char)payload[i];
  }
  Serial.printf("MQTT [%s]: %s\n", topic, msg.c_str());

  if (msg == "check_update") {
    checkForOTAUpdate();
  } else if (msg == "restart") {
    ESP.restart();
  } else if (msg == "status") {
    publishStatus();
  }
}

void connectMQTT() {
  while (!mqtt.connected()) {
    Serial.print("MQTT connecting...");
    if (mqtt.connect("esp32-sensor-node")) {
      Serial.println("connected!");
      mqtt.subscribe(mqtt_cmd_topic);
    } else {
      Serial.printf("failed (%d). Retry...\n", mqtt.state());
      delay(3000);
    }
  }
}

void publishStatus() {
  String status = "{";
  status += "\"version\":\"" + String(FIRMWARE_VERSION) + "\",";
  status += "\"ip\":\"" + WiFi.localIP().toString() + "\",";
  status += "\"rssi\":" + String(WiFi.RSSI()) + ",";
  status += "\"uptime\":" + String(millis() / 1000);
  status += "}";
  mqtt.publish(mqtt_topic, status.c_str());
}

// ====== OTA UPDATE ======
void checkForOTAUpdate() {
  if (WiFi.status() != WL_CONNECTED) return;

  Serial.println("Mengecek update OTA...");
  setLedStatus("ota");

  HTTPClient http;
  http.begin(ota_version_url);
  int code = http.GET();

  if (code == 200) {
    String serverVersion = http.getString();
    serverVersion.trim();

    if (serverVersion != String(FIRMWARE_VERSION)) {
      Serial.println("Update tersedia: " + serverVersion);
      performOTAUpdate();
    } else {
      Serial.println("Sudah versi terbaru.");
      setLedStatus("ok");
    }
  } else {
    Serial.println("Gagal cek versi: " + String(code));
    setLedStatus("error");
  }
  http.end();
}

void performOTAUpdate() {
  WiFiClient client;
  t_httpUpdate_return ret =
    httpUpdate.update(client, ota_firmware_url);

  switch (ret) {
    case HTTP_UPDATE_OK:
      Serial.println("OTA berhasil! Restart...");
      break;
    case HTTP_UPDATE_FAILED:
      Serial.printf("OTA gagal: %s\n",
        httpUpdate.getLastErrorString().c_str());
      setLedStatus("error");
      break;
    default:
      break;
  }
}

// ====== SETUP ======
void setup() {
  Serial.begin(115200);
  pinMode(LED_STATUS_PIN, OUTPUT);

  dht.begin();
  setupWiFi();

  mqtt.setServer(mqtt_server, mqtt_port);
  mqtt.setCallback(mqttCallback);
  connectMQTT();

  Serial.println("Sensor Node siap! v" + String(FIRMWARE_VERSION));
  setLedStatus("ok");
}

// ====== LOOP ======
void loop() {
  // Maintain connections
  if (WiFi.status() != WL_CONNECTED) setupWiFi();
  if (!mqtt.connected()) connectMQTT();
  mqtt.loop();

  // Baca sensor setiap 15 detik
  if (millis() - lastRead > 15000) {
    float suhu = dht.readTemperature();
    float hum = dht.readHumidity();

    if (!isnan(suhu) && !isnan(hum)) {
      String payload = "{";
      payload += "\"suhu\":" + String(suhu, 1) + ",";
      payload += "\"kelembaban\":" + String(hum, 1) + ",";
      payload += "\"versi\":\"" + String(FIRMWARE_VERSION) + "\"";
      payload += "}";
      mqtt.publish(mqtt_topic, payload.c_str());
      Serial.printf("Suhu: %.1f°C, Humidity: %.1f%%\n",
                    suhu, hum);
    }
    lastRead = millis();
  }

  // Cek OTA setiap interval
  if (millis() - lastOTA > OTA_CHECK_INTERVAL) {
    checkForOTAUpdate();
    lastOTA = millis();
  }
}