ESP32 BLE: Menghubungkan ESP32 sebagai BLE Master (Server) dan BLE Client (Client) dengan LCD I2C

#include <BLEDevice.h>

#include <BLEServer.h>

#include <BLEUtils.h>

#include <BLE2902.h>

#include <DHT.h>

#define DHTPIN 2       // Pin DHT11 terhubung

#define DHTTYPE DHT11  // Tipe sensor DHT11

DHT dht(DHTPIN, DHTTYPE);

// Komentar baris berikut untuk suhu dalam Fahrenheit

#define temperatureCelsius

// Nama server BLE

#define bleServerName "DHT11_ESP32"

// Variabel untuk menyimpan nilai suhu dan kelembapan

float temp;

float tempF;

float hum;

// Timer

unsigned long lastTime = 0;

unsigned long timerDelay = 30000;

bool deviceConnected = false;

// UUID BLE

#define SERVICE_UUID "91bad492-b950-4226-aa2b-4ede9fa42f59"

// Karakteristik dan Deskriptor Suhu

#ifdef temperatureCelsius

  BLECharacteristic temperatureCelsiusCharacteristics("cba1d466-344c-4be3-ab3f-189f80dd7518", BLECharacteristic::PROPERTY_NOTIFY);

  BLEDescriptor temperatureCelsiusDescriptor(BLEUUID((uint16_t)0x2902));

#else

  BLECharacteristic temperatureFahrenheitCharacteristics("f78ebbff-c8b7-4107-93de-889a6a06d408", BLECharacteristic::PROPERTY_NOTIFY);

  BLEDescriptor temperatureFahrenheitDescriptor(BLEUUID((uint16_t)0x2902));

#endif

// Karakteristik dan Deskriptor Kelembapan

BLECharacteristic humidityCharacteristics("ca73b3ba-39f6-4ab3-91ae-186dc9577d99", BLECharacteristic::PROPERTY_NOTIFY);

BLEDescriptor humidityDescriptor(BLEUUID((uint16_t)0x2903));

// Callbacks untuk koneksi dan disconnection

class MyServerCallbacks: public BLEServerCallbacks {

  void onConnect(BLEServer* pServer) {

    deviceConnected = true;

  };

  void onDisconnect(BLEServer* pServer) {

    deviceConnected = false;

  }

};

void setup() {

  // Memulai komunikasi serial

  Serial.begin(115200);




  // Memulai sensor DHT

  dht.begin();

  // Membuat perangkat BLE

  BLEDevice::init(bleServerName);

  // Membuat server BLE

  BLEServer *pServer = BLEDevice::createServer();

  pServer->setCallbacks(new MyServerCallbacks());

  // Membuat layanan BLE

  BLEService *dhtService = pServer->createService(SERVICE_UUID);

  // Menambahkan karakteristik dan deskriptor BLE

  #ifdef temperatureCelsius

    dhtService->addCharacteristic(&temperatureCelsiusCharacteristics);

    temperatureCelsiusDescriptor.setValue("DHT11 temperature Celsius");

    temperatureCelsiusCharacteristics.addDescriptor(&temperatureCelsiusDescriptor);

  #else

    dhtService->addCharacteristic(&temperatureFahrenheitCharacteristics);

    temperatureFahrenheitDescriptor.setValue("DHT11 temperature Fahrenheit");

    temperatureFahrenheitCharacteristics.addDescriptor(&temperatureFahrenheitDescriptor);

  #endif  

  // Kelembapan

  dhtService->addCharacteristic(&humidityCharacteristics);

  humidityDescriptor.setValue("DHT11 humidity");

  humidityCharacteristics.addDescriptor(new BLE2902());




  // Memulai layanan

  dhtService->start();

  // Memulai periklanan

  BLEAdvertising *pAdvertising = BLEDevice::getAdvertising();

  pAdvertising->addServiceUUID(SERVICE_UUID);

  pServer->getAdvertising()->start();

  Serial.println("Waiting for client connection to notify...");

}

void loop() {

  if (deviceConnected) {

    if ((millis() - lastTime) > timerDelay) {

      // Membaca suhu dalam Celsius

      temp = dht.readTemperature();

      // Suhu dalam Fahrenheit

      tempF = dht.readTemperature(true);

      // Membaca kelembapan

      hum = dht.readHumidity();

      // Memastikan pembacaan berhasil

      if (isnan(temp) || isnan(hum)) {

        Serial.println("Failed to read from DHT sensor!");

        return;

      }




      // Memberi notifikasi suhu

      #ifdef temperatureCelsius

        static char temperatureCTemp[6];

        dtostrf(temp, 6, 2, temperatureCTemp);

        temperatureCelsiusCharacteristics.setValue(temperatureCTemp);

        temperatureCelsiusCharacteristics.notify();

        Serial.print("Temperature Celsius: ");

        Serial.print(temp);

        Serial.print(" ºC");

      #else

        static char temperatureFTemp[6];

        dtostrf(tempF, 6, 2, temperatureFTemp);

        temperatureFahrenheitCharacteristics.setValue(temperatureFTemp);

        temperatureFahrenheitCharacteristics.notify();

        Serial.print("Temperature Fahrenheit: ");

        Serial.print(tempF);

        Serial.print(" ºF");

      #endif

     

      // Memberi notifikasi kelembapan

      static char humidityTemp[6];

      dtostrf(hum, 6, 2, humidityTemp);

      humidityCharacteristics.setValue(humidityTemp);

      humidityCharacteristics.notify();  

      Serial.print(" - Humidity: ");

      Serial.print(hum);

      Serial.println(" %");

     

      lastTime = millis();

    }

  }

}

#include <BLEDevice.h>

#include <Wire.h>

#include <LiquidCrystal_PCF8574.h>

// Definisikan ukuran LCD dan alamat I2C

LiquidCrystal_PCF8574 lcd(0x27); // Ganti alamat jika berbeda

// Default Temperature is in Celsius

#define temperatureCelsius

// BLE Server name (the other ESP32 name running the server sketch)

#define bleServerName "DHT11_ESP32"

/* UUIDs for the service and characteristic we want to read */

static BLEUUID bmeServiceUUID("91bad492-b950-4226-aa2b-4ede9fa42f59");

#ifdef temperatureCelsius

  static BLEUUID temperatureCharacteristicUUID("cba1d466-344c-4be3-ab3f-189f80dd7518");

#else

  static BLEUUID temperatureCharacteristicUUID("f78ebbff-c8b7-4107-93de-889a6a06d408");

#endif

static BLEUUID humidityCharacteristicUUID("ca73b3ba-39f6-4ab3-91ae-186dc9577d99");

static boolean doConnect = false;

static boolean connected = false;

static BLEAddress *pServerAddress;

static BLERemoteCharacteristic* temperatureCharacteristic;

static BLERemoteCharacteristic* humidityCharacteristic;

const uint8_t notificationOn[] = {0x1, 0x0};

char temperatureChar[6];

char humidityChar[6];

boolean newTemperature = false;

boolean newHumidity = false;

// Connect to BLE Server

bool connectToServer(BLEAddress pAddress) {

   BLEClient* pClient = BLEDevice::createClient();

   pClient->connect(pAddress);

   Serial.println(" - Connected to server");

   

   BLERemoteService* pRemoteService = pClient->getService(bmeServiceUUID);

   if (pRemoteService == nullptr) {

      Serial.print("Failed to find service UUID: ");

      Serial.println(bmeServiceUUID.toString().c_str());

      return false;

   }

   temperatureCharacteristic = pRemoteService->getCharacteristic(temperatureCharacteristicUUID);

   humidityCharacteristic = pRemoteService->getCharacteristic(humidityCharacteristicUUID);

   

   if (temperatureCharacteristic == nullptr || humidityCharacteristic == nullptr) {

      Serial.println("Failed to find characteristic UUID");

      return false;

   }

   

   temperatureCharacteristic->registerForNotify(temperatureNotifyCallback);

   humidityCharacteristic->registerForNotify(humidityNotifyCallback);

   return true;

}

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks {

  void onResult(BLEAdvertisedDevice advertisedDevice) {

    if (advertisedDevice.getName() == bleServerName) {

      advertisedDevice.getScan()->stop();

      pServerAddress = new BLEAddress(advertisedDevice.getAddress());

      doConnect = true;

      Serial.println("Device found. Connecting!");

    }

  }

};

// Temperature Notify Callback

static void temperatureNotifyCallback(BLERemoteCharacteristic* pBLERemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify) {

  strncpy(temperatureChar, (char*)pData, sizeof(temperatureChar) - 1);

  temperatureChar[sizeof(temperatureChar) - 1] = '\0'; // Pastikan null-terminated

  newTemperature = true;

}

// Humidity Notify Callback

static void humidityNotifyCallback(BLERemoteCharacteristic* pBLERemoteCharacteristic, uint8_t* pData, size_t length, bool isNotify) {

  strncpy(humidityChar, (char*)pData, sizeof(humidityChar) - 1);

  humidityChar[sizeof(humidityChar) - 1] = '\0'; // Pastikan null-terminated

  newHumidity = true;

}

// Print readings to the LCD

void printReadings() {

  lcd.clear();

  lcd.setCursor(0, 0);

  lcd.print("Temp: ");

  lcd.print(temperatureChar);




  #ifdef temperatureCelsius

    lcd.write(223);  // Karakter derajat

    lcd.print("C");

  #else

    lcd.write(223);  // Karakter derajat

    lcd.print("F");

  #endif




  lcd.setCursor(0, 1);

  lcd.print("Hum: ");

  lcd.print(humidityChar);

  lcd.print("%");




  Serial.print("Temperature: ");

  Serial.print(temperatureChar);

  Serial.print(" Humidity: ");

  Serial.print(humidityChar);

  Serial.println("%");

}

void setup() {

  // Start serial communication

  Serial.begin(115200);

  Serial.println("Starting BLE Client...");

  // Initialize LCD

  lcd.begin(16, 2);

  lcd.setBacklight(255);

  lcd.home();

  lcd.print("BLE Client");




  BLEDevice::init("");

  BLEScan* pBLEScan = BLEDevice::getScan();

  pBLEScan->setAdvertisedDeviceCallbacks(new MyAdvertisedDeviceCallbacks());

  pBLEScan->setActiveScan(true);

  pBLEScan->start(30);

}

void loop() {

  if (doConnect == true) {

    if (connectToServer(*pServerAddress)) {

      Serial.println("Connected to BLE Server.");

      temperatureCharacteristic->getDescriptor(BLEUUID((uint16_t)0x2902))->writeValue((uint8_t*)notificationOn, 2, true);

      humidityCharacteristic->getDescriptor(BLEUUID((uint16_t)0x2902))->writeValue((uint8_t*)notificationOn, 2, true);

      connected = true;

    } else {

      Serial.println("Failed to connect to server; restart device to rescan.");

    }

    doConnect = false;

  }




  if (newTemperature && newHumidity) {

    newTemperature = false;

    newHumidity = false;

    printReadings();

  }




  delay(1000);

}