ESP32 Bluetooth BLE: Komunikasi Nirkabel Energi Rendah

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

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

  // Inisialisasi BLE dengan nama device
  BLEDevice::init("ESP32-BLE-Server");

  // Buat BLE Server
  BLEServer *pServer = BLEDevice::createServer();

  Serial.println("BLE Device initialized!");
  Serial.print("MAC Address: ");
  Serial.println(BLEDevice::getAddress().toString().c_str());
}

// BLE Server - ESP32 dengan Sensor DHT22
// BeebaneLabs - https://beebanelabs.pages.dev

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
#include <DHT.h>

// UUID untuk service dan characteristic
#define SERVICE_UUID        "12345678-1234-1234-1234-123456789abc"
#define TEMP_CHAR_UUID      "12345678-1234-1234-1234-123456789ab1"
#define HUMID_CHAR_UUID     "12345678-1234-1234-1234-123456789ab2"

// Pin dan tipe sensor
#define DHT_PIN 4
#define DHT_TYPE DHT22

DHT dht(DHT_PIN, DHT_TYPE);

BLEServer* pServer = NULL;
BLECharacteristic* pTempChar = NULL;
BLECharacteristic* pHumidChar = NULL;
bool deviceConnected = false;
bool oldDeviceConnected = false;

// Callback saat client terhubung/putus
class MyServerCallbacks: public BLEServerCallbacks {
  void onConnect(BLEServer* pServer) {
    deviceConnected = true;
    Serial.println("Client terhubung!");
  }

  void onDisconnect(BLEServer* pServer) {
    deviceConnected = false;
    Serial.println("Client terputus!");
  }
};

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

  // Inisialisasi BLE
  BLEDevice::init("ESP32-WeatherStation");

  // Buat BLE Server
  pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());

  // Buat BLE Service
  BLEService* pService = pServer->createService(SERVICE_UUID);

  // Buat Characteristic untuk Suhu
  pTempChar = pService->createCharacteristic(
    TEMP_CHAR_UUID,
    BLECharacteristic::PROPERTY_READ |
    BLECharacteristic::PROPERTY_NOTIFY
  );
  pTempChar->addDescriptor(new BLE2902());

  // Buat Characteristic untuk Kelembaban
  pHumidChar = pService->createCharacteristic(
    HUMID_CHAR_UUID,
    BLECharacteristic::PROPERTY_READ |
    BLECharacteristic::PROPERTY_NOTIFY
  );
  pHumidChar->addDescriptor(new BLE2902());

  // Mulai service
  pService->start();

  // Mulai advertising
  BLEAdvertising* pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->addServiceUUID(SERVICE_UUID);
  pAdvertising->setScanResponse(true);
  pAdvertising->setMinPreferred(0x06);
  BLEDevice::startAdvertising();

  Serial.println("BLE Server aktif! Menunggu koneksi...");
}

void loop() {
  if (deviceConnected) {
    // Baca sensor DHT22
    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();

    if (!isnan(temperature) && !isnan(humidity)) {
      // Kirim data suhu
      char tempStr[8];
      dtostrf(temperature, 4, 1, tempStr);
      pTempChar->setValue(tempStr);
      pTempChar->notify();
      Serial.print("Suhu: ");
      Serial.print(tempStr);
      Serial.println(" °C");

      // Kirim data kelembaban
      char humidStr[8];
      dtostrf(humidity, 4, 1, humidStr);
      pHumidChar->setValue(humidStr);
      pHumidChar->notify();
      Serial.print("Kelembaban: ");
      Serial.print(humidStr);
      Serial.println(" %");
    }
  }

  // Handle reconnection
  if (!deviceConnected && oldDeviceConnected) {
    delay(500);
    pServer->startAdvertising();
    Serial.println("Mulai advertising lagi...");
    oldDeviceConnected = deviceConnected;
  }
  if (deviceConnected && !oldDeviceConnected) {
    oldDeviceConnected = deviceConnected;
  }

  delay(2000); // Kirim data setiap 2 detik
}

// BLE Client - Membaca data dari BLE Server
// BeebaneLabs - https://beebanelabs.pages.dev

#include "BLEDevice.h"

// UUID yang sama dengan server
#define SERVICE_UUID        "12345678-1234-1234-1234-123456789abc"
#define TEMP_CHAR_UUID      "12345678-1234-1234-1234-123456789ab1"

static BLEAddress* pServerAddress;
static boolean doConnect = false;
static boolean connected = false;
static BLERemoteCharacteristic* pTempCharacteristic;

// Callback saat menemukan device
class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {
  void onResult(BLEAdvertisedDevice advertisedDevice) {
    if (advertisedDevice.haveServiceUUID() &&
        advertisedDevice.isAdvertisingService(BLEUUID(SERVICE_UUID))) {
      BLEDevice::getScan().stop();
      pServerAddress = new BLEAddress(advertisedDevice.getAddress());
      doConnect = true;
      Serial.print("Server ditemukan: ");
      Serial.println(advertisedDevice.toString().c_str());
    }
  }
};

bool connectToServer() {
  Serial.print("Menghubungkan ke ");
  Serial.println(pServerAddress->toString().c_str());

  BLEClient* pClient = BLEDevice::createClient();
  pClient->connect(*pServerAddress);

  BLERemoteService* pRemoteService =
    pClient->getService(BLEUUID(SERVICE_UUID));

  if (pRemoteService == nullptr) {
    Serial.println("Service tidak ditemukan!");
    pClient->disconnect();
    return false;
  }

  pTempCharacteristic =
    pRemoteService->getCharacteristic(BLEUUID(TEMP_CHAR_UUID));

  if (pTempCharacteristic == nullptr) {
    Serial.println("Characteristic tidak ditemukan!");
    pClient->disconnect();
    return false;
  }

  // Register callback untuk notifikasi
  pTempCharacteristic->registerForNotify([](
    BLERemoteCharacteristic* pChar,
    uint8_t* pData, size_t length, bool isNotify
  ) {
    String value = String((char*)pData);
    Serial.print("Suhu dari server: ");
    Serial.print(value);
    Serial.println(" °C");
  });

  connected = true;
  return true;
}

void setup() {
  Serial.begin(115200);
  Serial.println("BLE Client - Scanning...");

  BLEDevice::init("");
  BLEScan* pBLEScan = BLEDevice::getScan();
  pBLEScan->setAdvertisedDeviceCallbacks(
    new MyAdvertisedDeviceCallbacks()
  );
  pBLEScan->setActiveScan(true);
  pBLEScan->start(30); // Scan selama 30 detik
}

void loop() {
  if (doConnect) {
    if (connectToServer()) {
      Serial.println("Terhubung ke BLE Server!");
    } else {
      Serial.println("Gagal terhubung.");
    }
    doConnect = false;
  }
  delay(1000);
}

// Fungsi untuk mengirim data panjang via BLE
// Memecah data menjadi paket-paket kecil
void sendDataChunked(BLECharacteristic* pChar, String data) {
  int chunkSize = 20; // MTU default
  int dataLen = data.length();
  int offset = 0;

  while (offset < dataLen) {
    int len = min(chunkSize, dataLen - offset);
    String chunk = data.substring(offset, offset + len);

    pChar->setValue((uint8_t*)chunk.c_str(), len);
    pChar->notify();

    offset += len;
    delay(50); // Delay antar paket
  }

  // Kirim terminator
  pChar->setValue((uint8_t*)"\0", 1);
  pChar->notify();
}

// Mengirim struct sensor data
struct SensorData {
  float temperature;
  float humidity;
  float pressure;
  uint16_t battery;
};

void sendSensorStruct(BLECharacteristic* pChar, SensorData data) {
  pChar->setValue((uint8_t*)&data, sizeof(SensorData));
  pChar->notify();
}

// iBeacon dengan ESP32
// BeebaneLabs - https://beebanelabs.pages.dev

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLEBeacon.h>

#define BEACON_UUID "12345678-1234-1234-1234-123456789abc"

void setup() {
  Serial.begin(115200);
  Serial.println("ESP32 iBeacon Starting...");

  BLEDevice::init("BeebaneLabs-Beacon");

  // Buat iBeacon
  BLEBeacon oBeacon = BLEBeacon();
  oBeacon.setManufacturerId(0x4C00); // Apple manufacturer ID
  oBeacon.setProximityUUID(BLEUUID(BEACON_UUID));
  oBeacon.setMajor(1);  // Major number
  oBeacon.setMinor(10); // Minor number
  oBeacon.setSignalPower(-59); // RSSI pada 1 meter

  BLEAdvertisementData oAdvertisementData = BLEAdvertisementData();
  BLEAdvertisementData oScanResponseData = BLEAdvertisementData();

  oAdvertisementData.setFlags(0x04); // BR/EDR Not Supported

  std::string strServiceData = "";
  strServiceData += (char)26;     // Panjang
  strServiceData += (char)0xFF;   // Type: Manufacturer Specific
  strServiceData += oBeacon.getData();
  oAdvertisementData.addData(strServiceData);

  BLEAdvertising* pAdvertising = BLEDevice::getAdvertising();
  pAdvertising->setAdvertisementData(oAdvertisementData);
  pAdvertising->setScanResponseData(oScanResponseData);
  pAdvertising->setMinPreferred(0x06);
  pAdvertising->setMinPreferred(0x12);

  BLEDevice::startAdvertising();
  Serial.println("iBeacon aktif dan broadcasting!");
}

void loop() {
  delay(1000);
}

// Konfigurasi keamanan BLE
// BeebaneLabs - https://beebanelabs.pages.dev

void setupSecurity() {
  // Set security
  BLESecurity* pSecurity = new BLESecurity();

  // Set authentication mode
  pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_BOND);

  // Set encryption key size
  pSecurity->setCapability(ESP_IO_CAP_NONE);

  // Set static PIN (untuk pairing dengan passkey)
  // pSecurity->setCapability(ESP_IO_CAP_OUT);
  // pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK |
  //                                  ESP_BLE_ID_KEY_MASK);

  // Set key size
  BLEDevice::setEncryptionLevel(ESP_BLE_SEC_ENCRYPT);

  // Set passkey (6 digit)
  // BLEDevice::setSecurityAuth(true, true, true);
  // pSecurity->setStaticPIN(123456);

  Serial.println("BLE Security diaktifkan!");
}

// Protect characteristic dengan keamanan
void setupSecureCharacteristic(BLEService* pService) {
  BLECharacteristic* pSecureChar =
    pService->createCharacteristic(
      SECURE_CHAR_UUID,
      BLECharacteristic::PROPERTY_READ |
      BLECharacteristic::PROPERTY_WRITE
    );

  // Set characteristic hanya bisa diakses setelah pairing
  pSecureChar->setAccessPermissions(
    ESP_GATT_PERM_READ_ENCRYPTED |
    ESP_GATT_PERM_WRITE_ENCRYPTED
  );

  pSecureChar->setValue("Secret Data");
}