ESP-NOW: Komunikasi Nirkabel Antar ESP32

// ==================================================
// Proyek WSN: Node Sensor dengan ESP-NOW
// Kirim data suhu & kelembaban ke gateway
// BeebaneLabs - https://beebanelabs.pages.dev
// ==================================================

#include "esp_now.h"
#include "WiFi.h"
#include "DHT.h"

// === KONFIGURASI NODE ===
#define NODE_ID        1         // Ubah: 1, 2, atau 3
#define NODE_NAME      "Ruang Tamu"  // Nama lokasi sensor
#define DHT_PIN        4         // GPIO sensor DHT
#define DHT_TYPE       DHT11
#define LED_PIN        2         // LED indikator
#define INTERVAL_KIRIM 15000     // Kirim setiap 15 detik

// MAC Address Gateway (GANTI DENGAN YANG BENAR!)
uint8_t gatewayMAC[] = {0xA4, 0xCF, 0x12, 0xE8, 0x45, 0xA0};

// === Struct Data ===
typedef struct struct_wsn_data {
  uint8_t node_id;
  char node_name[16];
  float suhu;
  float kelembaban;
  float heat_index;
  int8_t wifi_rssi;
  uint32_t uptime;
  uint32_t packet_num;
} struct_wsn_data;

struct_wsn_data dataSensor;
DHT dht(DHT_PIN, DHT_TYPE);

// Statistik
uint32_t totalKirim = 0;
uint32_t totalBerhasil = 0;
unsigned long waktuTerakhir = 0;

void kedipLED(int kali, int delayMs) {
  for (int i = 0; i < kali; i++) {
    digitalWrite(LED_PIN, HIGH);
    delay(delayMs);
    digitalWrite(LED_PIN, LOW);
    delay(delayMs);
  }
}

void onSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  if (status == ESP_NOW_SEND_SUCCESS) {
    totalBerhasil++;
    kedipLED(1, 100);
  }
  float pdr = totalKirim > 0 ?
    (float)totalBerhasil / totalKirim * 100.0 : 0;
  Serial.printf("[SEND #%lu] %s | PDR: %.1f%%\n",
    totalKirim,
    status == ESP_NOW_SEND_SUCCESS ? "OK" : "GAGAL",
    pdr);
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  dht.begin();

  WiFi.mode(WIFI_STA);
  WiFi.disconnect();

  if (esp_now_init() != ESP_OK) {
    Serial.println("[FATAL] ESP-NOW init gagal!");
    while (true) { kedipLED(5, 100); delay(1000); }
  }

  esp_now_register_send_cb(onSent);

  esp_now_peer_info_t peerInfo = {};
  memcpy(peerInfo.peer_addr, gatewayMAC, 6);
  peerInfo.channel = 1;
  peerInfo.encrypt = false;

  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("[FATAL] Gagal daftar gateway!");
    while (true) { kedipLED(10, 50); delay(1000); }
  }

  strcpy(dataSensor.node_name, NODE_NAME);
  dataSensor.node_id = NODE_ID;

  Serial.println("╔═══════════════════════════════════════╗");
  Serial.printf( "║  WSN Node #%d: %-18s ║\n", NODE_ID, NODE_NAME);
  Serial.println("║  BeebaneLabs ESP-NOW Sensor Node     ║");
  Serial.println("╚═══════════════════════════════════════╝");
  kedipLED(3, 200);
}

void loop() {
  unsigned long sekarang = millis();

  if (sekarang - waktuTerakhir >= INTERVAL_KIRIM) {
    waktuTerakhir = sekarang;
    totalKirim++;

    // Baca sensor
    dataSensor.suhu = dht.readTemperature();
    dataSensor.kelembaban = dht.readHumidity();
    dataSensor.uptime = sekarang / 1000;
    dataSensor.packet_num = totalKirim;
    dataSensor.wifi_rssi = 0;  // Placeholder

    // Validasi
    if (isnan(dataSensor.suhu)) {
      dataSensor.suhu = -99.0;
      dataSensor.kelembaban = -99.0;
    }

    dataSensor.heat_index = dht.computeHeatIndex(
      dataSensor.suhu, dataSensor.kelembaban, false);

    // Kirim ke gateway
    esp_err_t result = esp_now_send(
      gatewayMAC,
      (uint8_t *) &dataSensor,
      sizeof(dataSensor)
    );

    Serial.printf("[%lu] %s | %.1f°C | %.1f%% | HI: %.1f°C\n",
      totalKirim, NODE_NAME, dataSensor.suhu,
      dataSensor.kelembaban, dataSensor.heat_index);
  }
}

// ==================================================
// Proyek WSN: Gateway ESP-NOW -> MQTT
// Terima data dari semua node, kirim ke MQTT
// BeebaneLabs - https://beebanelabs.pages.dev
// ==================================================

#include "esp_now.h"
#include "WiFi.h"
#include "PubSubClient.h"

// === WiFi Config ===
const char* WIFI_SSID = "NamaWiFiAnda";
const char* WIFI_PASS = "PasswordWiFi";

// === MQTT Config ===
const char* MQTT_SERVER = "test.mosquitto.org";
const int   MQTT_PORT   = 1883;
const char* MQTT_TOPIC  = "wsn/gateway/data";
const char* CLIENT_ID   = "wsn_gateway_01";

// === Struct (sama dengan node) ===
typedef struct struct_wsn_data {
  uint8_t node_id;
  char node_name[16];
  float suhu;
  float kelembaban;
  float heat_index;
  int8_t wifi_rssi;
  uint32_t uptime;
  uint32_t packet_num;
} struct_wsn_data;

WiFiClient espClient;
PubSubClient mqtt(espClient);

// Buffer untuk data dari multiple node
struct_wsn_data nodeData[10];  // Max 10 node
bool nodeOnline[10] = {false};

void setupWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  Serial.print("WiFi: Connecting");
  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if (++attempts > 40) {
      Serial.println(" GAGAL!");
      ESP.restart();
    }
  }
  Serial.printf(" OK! IP: %s\n", WiFi.localIP().toString().c_str());
}

void hubungkanMQTT() {
  while (!mqtt.connected()) {
    Serial.print("MQTT: Connecting...");
    if (mqtt.connect(CLIENT_ID)) {
      Serial.println(" OK!");
    } else {
      Serial.printf(" FAIL (rc=%d)\n", mqtt.state());
      delay(3000);
    }
  }
}

void onReceive(const uint8_t *mac_addr, const uint8_t *data, int len) {
  if (len != sizeof(struct_wsn_data)) {
    Serial.printf("[WARN] Ukuran data tidak sesuai: %d\n", len);
    return;
  }

  struct_wsn_data rxData;
  memcpy(&rxData, data, sizeof(rxData));

  // Simpan data
  if (rxData.node_id < 10) {
    nodeData[rxData.node_id] = rxData;
    nodeOnline[rxData.node_id] = true;
  }

  // Format MAC
  char macStr[18];
  snprintf(macStr, sizeof(macStr), "%02X:%02X:%02X:%02X:%02X:%02X",
    mac_addr[0], mac_addr[1], mac_addr[2],
    mac_addr[3], mac_addr[4], mac_addr[5]);

  Serial.printf("[RX] Node %d (%s) | %.1f°C | %.1f%% | #%lu\n",
    rxData.node_id, rxData.node_name, rxData.suhu,
    rxData.kelembaban, rxData.packet_num);

  // Kirim ke MQTT
  if (mqtt.connected()) {
    char payload[256];
    snprintf(payload, sizeof(payload),
      "{\"node_id\":%d,\"node_name\":\"%s\","
      "\"suhu\":%.1f,\"kelembaban\":%.1f,"
      "\"heat_index\":%.1f,\"uptime\":%lu,"
      "\"packet\":%lu,\"mac\":\"%s\"}",
      rxData.node_id, rxData.node_name,
      rxData.suhu, rxData.kelembaban,
      rxData.heat_index, rxData.uptime,
      rxData.packet_num, macStr);

    // Publish ke topik per-node
    char topic[64];
    snprintf(topic, sizeof(topic), "wsn/node/%d/data", rxData.node_id);

    if (mqtt.publish(topic, payload)) {
      Serial.printf("[MQTT] Published ke %s\n", topic);
    } else {
      Serial.println("[MQTT] Gagal publish!");
    }

    // Juga publish ke topik utama
    mqtt.publish(MQTT_TOPIC, payload);
  }
}

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

  Serial.println("╔═══════════════════════════════════════╗");
  Serial.println("║  WSN Gateway - ESP-NOW -> MQTT       ║");
  Serial.println("║  BeebaneLabs                          ║");
  Serial.println("╚═══════════════════════════════════════╝");

  setupWiFi();

  mqtt.setServer(MQTT_SERVER, MQTT_PORT);
  mqtt.setBufferSize(512);
  hubungkanMQTT();

  // Inisialisasi ESP-NOW (setelah WiFi)
  if (esp_now_init() != ESP_OK) {
    Serial.println("[FATAL] ESP-NOW init gagal!");
    ESP.restart();
  }

  esp_now_register_recv_cb(onReceive);

  Serial.println("[OK] Gateway siap menerima data dari node sensor!");
}

void loop() {
  if (!mqtt.connected()) {
    hubungkanMQTT();
  }
  mqtt.loop();

  // Status check setiap 30 detik
  static unsigned long lastStatus = 0;
  if (millis() - lastStatus > 30000) {
    lastStatus = millis();
    Serial.println("═══════════════════════════════════");
    Serial.println("       STATUS NODE AKTIF          ");
    for (int i = 0; i < 10; i++) {
      if (nodeOnline[i]) {
        Serial.printf("  Node %d: %-14s | %.1f°C | %.1f%%\n",
          nodeData[i].node_id, nodeData[i].node_name,
          nodeData[i].suhu, nodeData[i].kelembaban);
      }
    }
    Serial.printf("  Heap bebas: %lu bytes\n", ESP.getFreeHeap());
    Serial.println("═══════════════════════════════════");
  }
}