3.3.7

libraries/BluetoothSerial/examples/DiscoverConnect/DiscoverConnect.ino

@@ -0,0 +1,110 @@
+/**
+ * Bluetooth Classic Example
+ * Scan for devices - asynchronously, print device as soon as found
+ * query devices for SPP - SDP profile
+ * connect to first device offering a SPP connection
+ *
+ * Example python server:
+ * source: https://gist.github.com/ukBaz/217875c83c2535d22a16ba38fc8f2a91
+ *
+ * Tested with Raspberry Pi onboard Wifi/BT, USB BT 4.0 dongles, USB BT 1.1 dongles,
+ * 202202: does NOT work with USB BT 2.0 dongles when esp32 arduino lib is compiled with SSP support!
+ *         see https://github.com/espressif/esp-idf/issues/8394
+ *
+ * use ESP_SPP_SEC_ENCRYPT|ESP_SPP_SEC_AUTHENTICATE in connect() if remote side requests 'RequireAuthentication': dbus.Boolean(True),
+ * use ESP_SPP_SEC_NONE or ESP_SPP_SEC_ENCRYPT|ESP_SPP_SEC_AUTHENTICATE in connect() if remote side has Authentication: False
+ */
+
+#include <map>
+#include <BluetoothSerial.h>
+
+#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
+#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
+#endif
+
+#if !defined(CONFIG_BT_SPP_ENABLED)
+#error Serial Bluetooth not available or not enabled. It is only available for the ESP32 chip.
+#endif
+
+BluetoothSerial SerialBT;
+
+#define BT_DISCOVER_TIME 10000
+esp_spp_sec_t sec_mask = ESP_SPP_SEC_NONE;  // or ESP_SPP_SEC_ENCRYPT|ESP_SPP_SEC_AUTHENTICATE to request pincode confirmation
+esp_spp_role_t role = ESP_SPP_ROLE_SLAVE;   // or ESP_SPP_ROLE_MASTER
+
+// std::map<BTAddress, BTAdvertisedDeviceSet> btDeviceList;
+
+void setup() {
+  Serial.begin(115200);
+  if (!SerialBT.begin("ESP32test", true)) {
+    Serial.println("========== serialBT failed!");
+    abort();
+  }
+  // SerialBT.setPin("1234"); // doesn't seem to change anything
+  // SerialBT.enableSSP(); // doesn't seem to change anything
+
+  Serial.println("Starting discoverAsync...");
+  BTScanResults *btDeviceList = SerialBT.getScanResults();  // maybe accessing from different threads!
+  if (SerialBT.discoverAsync([](BTAdvertisedDevice *pDevice) {
+        // BTAdvertisedDeviceSet*set = reinterpret_cast<BTAdvertisedDeviceSet*>(pDevice);
+        // btDeviceList[pDevice->getAddress()] = * set;
+        Serial.printf(">>>>>>>>>>>Found a new device asynchronously: %s\n", pDevice->toString().c_str());
+      })) {
+    delay(BT_DISCOVER_TIME);
+    Serial.print("Stopping discoverAsync... ");
+    SerialBT.discoverAsyncStop();
+    Serial.println("discoverAsync stopped");
+    delay(5000);
+    if (btDeviceList->getCount() > 0) {
+      BTAddress addr;
+      int channel = 0;
+      Serial.println("Found devices:");
+      for (int i = 0; i < btDeviceList->getCount(); i++) {
+        BTAdvertisedDevice *device = btDeviceList->getDevice(i);
+        Serial.printf(" ----- %s  %s %d\n", device->getAddress().toString().c_str(), device->getName().c_str(), device->getRSSI());
+        std::map<int, std::string> channels = SerialBT.getChannels(device->getAddress());
+        Serial.printf("scanned for services, found %zu\n", channels.size());
+        for (auto const &entry : channels) {
+          Serial.printf("     channel %d (%s)\n", entry.first, entry.second.c_str());
+        }
+        if (channels.size() > 0) {
+          addr = device->getAddress();
+          channel = channels.begin()->first;
+        }
+      }
+      if (addr) {
+        Serial.printf("connecting to %s - %d\n", addr.toString().c_str(), channel);
+        SerialBT.connect(addr, channel, sec_mask, role);
+      }
+    } else {
+      Serial.println("Didn't find any devices");
+    }
+  } else {
+    Serial.println("Error on discoverAsync f.e. not working after a \"connect\"");
+  }
+}
+
+String sendData = "Hi from esp32!\n";
+
+void loop() {
+  if (!SerialBT.isClosed() && SerialBT.connected()) {
+    if (SerialBT.write((const uint8_t *)sendData.c_str(), sendData.length()) != sendData.length()) {
+      Serial.println("tx: error");
+    } else {
+      Serial.printf("tx: %s", sendData.c_str());
+    }
+    if (SerialBT.available()) {
+      Serial.print("rx: ");
+      while (SerialBT.available()) {
+        int c = SerialBT.read();
+        if (c >= 0) {
+          Serial.print((char)c);
+        }
+      }
+      Serial.println();
+    }
+  } else {
+    Serial.println("not connected");
+  }
+  delay(1000);
+}

libraries/BluetoothSerial/examples/DiscoverConnect/ci.yml

@@ -0,0 +1,4 @@
+fqbn_append: PartitionScheme=huge_app
+
+requires:
+  - CONFIG_BT_SPP_ENABLED=y

libraries/BluetoothSerial/examples/GetLocalMAC/GetLocalMAC.ino

@@ -0,0 +1,49 @@
+// This example demonstrates usage of BluetoothSerial method to retrieve MAC address of local BT device in various formats.
+// By Tomas Pilny - 2023
+
+#include "BluetoothSerial.h"
+
+String device_name = "ESP32-example";
+
+#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
+#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
+#endif
+
+#if !defined(CONFIG_BT_SPP_ENABLED)
+#error Serial Bluetooth not available or not enabled. It is only available for the ESP32 chip.
+#endif
+
+BluetoothSerial SerialBT;
+
+void setup() {
+  Serial.begin(115200);
+  SerialBT.begin(device_name);  //Bluetooth device name
+
+  uint8_t mac_arr[6];  // Byte array to hold the MAC address from getBtAddress()
+  BTAddress mac_obj;   // Object holding instance of BTAddress with the MAC (for more details see libraries/BluetoothSerial/src/BTAddress.h)
+  String mac_str;      // String holding the text version of MAC in format AA:BB:CC:DD:EE:FF
+
+  SerialBT.getBtAddress(mac_arr);           // Fill in the array
+  mac_obj = SerialBT.getBtAddressObject();  // Instantiate the object
+  mac_str = SerialBT.getBtAddressString();  // Copy the string
+
+  Serial.print("This device is instantiated with name ");
+  Serial.println(device_name);
+
+  Serial.print("The mac address using byte array: ");
+  for (int i = 0; i < ESP_BD_ADDR_LEN - 1; i++) {
+    Serial.print(mac_arr[i], HEX);
+    Serial.print(":");
+  }
+  Serial.println(mac_arr[ESP_BD_ADDR_LEN - 1], HEX);
+
+  Serial.print("The mac address using BTAddress object using default method `toString()`: ");
+  Serial.println(mac_obj.toString().c_str());
+  Serial.print("The mac address using BTAddress object using method `toString(true)`\n\twhich prints the MAC with capital letters: ");
+  Serial.println(mac_obj.toString(true).c_str());  // This actually what is used inside the getBtAddressString()
+
+  Serial.print("The mac address using string: ");
+  Serial.println(mac_str.c_str());
+}
+
+void loop() {}

libraries/BluetoothSerial/examples/GetLocalMAC/ci.yml

@@ -0,0 +1,4 @@
+fqbn_append: PartitionScheme=huge_app
+
+requires:
+  - CONFIG_BT_SPP_ENABLED=y

libraries/BluetoothSerial/examples/SerialToSerialBT/SerialToSerialBT.ino

@@ -0,0 +1,39 @@
+// This example code is in the Public Domain (or CC0 licensed, at your option.)
+// By Evandro Copercini - 2018
+//
+// This example creates a bridge between Serial and Classical Bluetooth (SPP)
+// and also demonstrate that SerialBT have the same functionalities of a normal Serial
+// Note: Pairing is authenticated automatically by this device
+
+#include "BluetoothSerial.h"
+
+String device_name = "ESP32-BT-Slave";
+
+// Check if Bluetooth is available
+#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
+#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
+#endif
+
+// Check Serial Port Profile
+#if !defined(CONFIG_BT_SPP_ENABLED)
+#error Serial Port Profile for Bluetooth is not available or not enabled. It is only available for the ESP32 chip.
+#endif
+
+BluetoothSerial SerialBT;
+
+void setup() {
+  Serial.begin(115200);
+  SerialBT.begin(device_name);  //Bluetooth device name
+  //SerialBT.deleteAllBondedDevices(); // Uncomment this to delete paired devices; Must be called after begin
+  Serial.printf("The device with name \"%s\" is started.\nNow you can pair it with Bluetooth!\n", device_name.c_str());
+}
+
+void loop() {
+  if (Serial.available()) {
+    SerialBT.write(Serial.read());
+  }
+  if (SerialBT.available()) {
+    Serial.write(SerialBT.read());
+  }
+  delay(20);
+}

libraries/BluetoothSerial/examples/SerialToSerialBT/ci.yml

@@ -0,0 +1,4 @@
+fqbn_append: PartitionScheme=huge_app
+
+requires:
+  - CONFIG_BT_SPP_ENABLED=y

libraries/BluetoothSerial/examples/SerialToSerialBTM/SerialToSerialBTM.ino

@@ -0,0 +1,97 @@
+// This example code is in the Public Domain (or CC0 licensed, at your option.)
+// By Victor Tchistiak - 2019
+//
+// This example demonstrates master mode Bluetooth connection to a slave BT device
+// defined either by String "slaveName" by default "ESP32-BT-Slave" or by MAC address
+//
+// This example creates a bridge between Serial and Classical Bluetooth (SPP)
+// This is an extension of the SerialToSerialBT example by Evandro Copercini - 2018
+//
+// DO NOT try to connect to phone or laptop - they are master
+// devices, same as the ESP using this code - you will be able
+// to pair, but the serial communication will NOT work!
+//
+// You can try to flash a second ESP32 with the example SerialToSerialBT - it should
+// automatically pair with ESP32 running this code
+// Note: Pairing is authenticated automatically by this device
+
+#include "BluetoothSerial.h"
+
+#define USE_NAME  // Comment this to use MAC address instead of a slaveName
+
+// Check if Bluetooth is available
+#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
+#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
+#endif
+
+// Check Serial Port Profile
+#if !defined(CONFIG_BT_SPP_ENABLED)
+#error Serial Port Profile for Bluetooth is not available or not enabled. It is only available for the ESP32 chip.
+#endif
+BluetoothSerial SerialBT;
+
+#ifdef USE_NAME
+String slaveName = "ESP32-BT-Slave";  // Change this to reflect the real name of your slave BT device
+#else
+String MACadd = "AA:BB:CC:11:22:33";                        // This only for printing
+uint8_t address[6] = {0xAA, 0xBB, 0xCC, 0x11, 0x22, 0x33};  // Change this to reflect real MAC address of your slave BT device
+#endif
+
+String myName = "ESP32-BT-Master";
+
+void setup() {
+  bool connected;
+  Serial.begin(115200);
+
+  SerialBT.begin(myName, true);
+  //SerialBT.deleteAllBondedDevices(); // Uncomment this to delete paired devices; Must be called after begin
+  Serial.printf("The device \"%s\" started in master mode, make sure slave BT device is on!\n", myName.c_str());
+
+#ifndef USE_NAME
+  SerialBT.setPin(pin);
+  Serial.println("Using PIN");
+#endif
+
+// connect(address) is fast (up to 10 secs max), connect(slaveName) is slow (up to 30 secs max) as it needs
+// to resolve slaveName to address first, but it allows to connect to different devices with the same name.
+// Set CoreDebugLevel to Info to view devices Bluetooth address and device names
+#ifdef USE_NAME
+  connected = SerialBT.connect(slaveName);
+  Serial.printf("Connecting to slave BT device named \"%s\"\n", slaveName.c_str());
+#else
+  connected = SerialBT.connect(address);
+  Serial.print("Connecting to slave BT device with MAC ");
+  Serial.println(MACadd);
+#endif
+
+  if (connected) {
+    Serial.println("Connected Successfully!");
+  } else {
+    while (!SerialBT.connected(10000)) {
+      Serial.println("Failed to connect. Make sure remote device is available and in range, then restart app.");
+    }
+  }
+  // Disconnect() may take up to 10 secs max
+  if (SerialBT.disconnect()) {
+    Serial.println("Disconnected Successfully!");
+  }
+  // This would reconnect to the slaveName(will use address, if resolved) or address used with connect(slaveName/address).
+  SerialBT.connect();
+  if (connected) {
+    Serial.println("Reconnected Successfully!");
+  } else {
+    while (!SerialBT.connected(10000)) {
+      Serial.println("Failed to reconnect. Make sure remote device is available and in range, then restart app.");
+    }
+  }
+}
+
+void loop() {
+  if (Serial.available()) {
+    SerialBT.write(Serial.read());
+  }
+  if (SerialBT.available()) {
+    Serial.write(SerialBT.read());
+  }
+  delay(20);
+}

libraries/BluetoothSerial/examples/SerialToSerialBTM/ci.yml

@@ -0,0 +1,4 @@
+fqbn_append: PartitionScheme=huge_app
+
+requires:
+  - CONFIG_BT_SPP_ENABLED=y

libraries/BluetoothSerial/examples/SerialToSerialBT_Legacy/SerialToSerialBT_Legacy.ino

@@ -0,0 +1,58 @@
+// This example code is in the Public Domain (or CC0 licensed, at your option.)
+//
+// This example creates a bridge between Serial and Classical Bluetooth (SPP with authentication)
+// and also demonstrate that SerialBT have the same functionalities of a normal Serial
+// Legacy pairing TODO
+// Must be run as idf component ... todo
+
+#include "BluetoothSerial.h"
+
+// Check if Bluetooth is available
+#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
+#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
+#endif
+
+// Check Serial Port Profile
+#if !defined(CONFIG_BT_SPP_ENABLED)
+#error Serial Port Profile for Bluetooth is not available or not enabled. It is only available for the ESP32 chip.
+#endif
+
+const char *deviceName = "ESP32_Legacy_example";
+
+BluetoothSerial SerialBT;
+bool confirmRequestDone = false;
+
+void BTAuthCompleteCallback(boolean success) {
+  if (success) {
+    confirmRequestDone = true;
+    Serial.println("Pairing success!!");
+  } else {
+    Serial.println("Pairing failed, rejected by user!!");
+  }
+}
+
+void serial_response() {
+  if (Serial.available()) {
+    SerialBT.write(Serial.read());
+  }
+  if (SerialBT.available()) {
+    Serial.write(SerialBT.read());
+  }
+  delay(20);
+}
+
+void setup() {
+  Serial.begin(115200);
+  SerialBT.onAuthComplete(BTAuthCompleteCallback);
+  SerialBT.begin(deviceName);  // Initiate Bluetooth device with name in parameter
+  SerialBT.setPin("1234", 4);
+  Serial.printf("The device started with name \"%s\", now you can pair it with Bluetooth!\n", deviceName);
+}
+
+void loop() {
+  if (confirmRequestDone) {
+    serial_response();
+  } else {
+    delay(1);  // Feed the watchdog
+  }
+}

libraries/BluetoothSerial/examples/SerialToSerialBT_Legacy/ci.yml

@@ -0,0 +1,4 @@
+fqbn_append: PartitionScheme=huge_app
+
+requires:
+  - CONFIG_BT_SPP_ENABLED=y

libraries/BluetoothSerial/examples/SerialToSerialBT_SSP/SerialToSerialBT_SSP.ino

@@ -0,0 +1,131 @@
+// This example code is in the Public Domain (or CC0 licensed, at your option.)
+// By Richard Li - 2020
+//
+// This example creates a bridge between Serial and Classical Bluetooth (SPP with authentication)
+// and also demonstrate that SerialBT have the same functionalities of a normal Serial
+// SSP - Simple Secure Pairing - The device (ESP32) will display random number and the user is responsible of comparing it to the number
+// displayed on the other device (for example phone).
+// If the numbers match the user authenticates the pairing on both devices - on phone simply press "Pair" and in terminal for the sketch send 'Y' or 'y' to confirm.
+// Alternatively uncomment AUTO_PAIR to skip the terminal confirmation.
+
+#include "BluetoothSerial.h"
+
+//#define AUTO_PAIR // Uncomment to automatically authenticate ESP32 side
+
+// Check if Bluetooth is available
+#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
+#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
+#endif
+
+// Check Serial Port Profile
+#if !defined(CONFIG_BT_SPP_ENABLED)
+#error Serial Port Profile for Bluetooth is not available or not enabled. It is only available for the ESP32 chip.
+#endif
+
+const char *deviceName = "ESP32_SSP_example";
+
+// The following lines defines the method of pairing
+// When both Input and Output are false only the other device authenticates pairing without any pin.
+// When Output is true and Input is false only the other device authenticates pairing without any pin.
+// When both Input and Output are true both devices display randomly generated code and if they match authenticate pairing on both devices
+//   - This must be implemented by registering callback via onConfirmRequest() and in this callback request user input and call confirmReply(true); if the authenticated
+//      otherwise call `confirmReply(false)` to reject the pairing.
+// When Input is true and Output is false User will be required to input the passkey to the ESP32 device to authenticate.
+//   - This must be implemented by registering callback via onKeyRequest() and in this callback the entered passkey will be responded via respondPasskey(passkey);
+const bool INPUT_CAPABILITY = false;  // Defines if ESP32 device has input method (Serial terminal, keyboard or similar)
+const bool OUTPUT_CAPABILITY = true;  // Defines if ESP32 device has output method (Serial terminal, display or similar)
+
+BluetoothSerial SerialBT;
+bool confirmRequestDone = false;
+
+void BTConfirmRequestCallback(uint32_t numVal) {
+  confirmRequestDone = false;
+#ifndef AUTO_PAIR
+  Serial.printf(
+    "The PIN is: %06lu. If it matches number displayed on the other device write \'Y\' or \'y\':\n", numVal
+  );  // Note the formatting "%06lu" - PIN can start with zero(s) which would be ignored with simple "%lu"
+  while (!Serial.available()) {
+    delay(1);  // Feed the watchdog
+    // Wait until data is available on the Serial port.
+  }
+  Serial.printf("Oh you sent %d Bytes, lets see...", Serial.available());
+  int dat = Serial.read();
+  if (dat == 'Y' || dat == 'y') {
+    SerialBT.confirmReply(true);
+  } else {
+    SerialBT.confirmReply(false);
+  }
+#else
+  SerialBT.confirmReply(true);
+#endif
+}
+
+void BTKeyRequestCallback() {
+  Serial.println("BTKeyRequestCallback");  // debug
+  char buffer[7] = {0};                    // 6 bytes for number, one for termination '0'
+  while (1) {
+    Serial.print("Enter the passkey displayed on the other device: ");
+    while (!Serial.available()) {
+      delay(1);  // Feed the watchdog
+      // Wait until data is available on the Serial port.
+    }
+    size_t len = Serial.readBytesUntil('\n', buffer, sizeof(buffer) - 1);
+    buffer[len] = '\0';  // Null-terminate the string.
+    try {
+      uint32_t passkey = std::stoi(buffer);
+      Serial.printf("Entered PIN: %lu\n", passkey);
+      SerialBT.respondPasskey(passkey);
+      return;
+    } catch (...) {
+      Serial.print("Wrong PIN! Try again.");
+    }  // try
+  }  // while(1)
+}
+
+void BTAuthCompleteCallback(boolean success) {
+  if (success) {
+    confirmRequestDone = true;
+    Serial.println("Pairing success!!");
+  } else {
+    Serial.println("Pairing failed, rejected by user!!");
+  }
+}
+
+void serial_response() {
+  if (Serial.available()) {
+    SerialBT.write(Serial.read());
+  }
+  if (SerialBT.available()) {
+    Serial.write(SerialBT.read());
+  }
+  delay(20);
+}
+
+void setup() {
+  Serial.begin(115200);
+  SerialBT.enableSSP(INPUT_CAPABILITY, OUTPUT_CAPABILITY);  // Must be called before begin
+  SerialBT.onConfirmRequest(BTConfirmRequestCallback);
+  SerialBT.onKeyRequest(BTKeyRequestCallback);
+  SerialBT.onAuthComplete(BTAuthCompleteCallback);
+  SerialBT.begin(deviceName);  // Initiate Bluetooth device with name in parameter
+  //SerialBT.deleteAllBondedDevices(); // Uncomment this to delete paired devices; Must be called after begin
+  Serial.printf("The device started with name \"%s\", now you can pair it with Bluetooth!\n", deviceName);
+  if (INPUT_CAPABILITY and OUTPUT_CAPABILITY) {
+    Serial.println("Both devices will display randomly generated code and if they match authenticate pairing on both devices");
+  } else if (not INPUT_CAPABILITY and not OUTPUT_CAPABILITY) {
+    Serial.println("Authenticate pairing on the other device. No PIN is used");
+  } else if (not INPUT_CAPABILITY and OUTPUT_CAPABILITY) {
+    Serial.println("Authenticate pairing on the other device. No PIN is used");
+  } else if (INPUT_CAPABILITY and not OUTPUT_CAPABILITY) {
+    Serial.println("After pairing is initiated you will be required to enter the passkey to the ESP32 device to authenticate\n > The Passkey will displayed on "
+                   "the other device");
+  }
+}
+
+void loop() {
+  if (confirmRequestDone) {
+    serial_response();
+  } else {
+    delay(1);  // Feed the watchdog
+  }
+}

libraries/BluetoothSerial/examples/SerialToSerialBT_SSP/ci.yml

@@ -0,0 +1,4 @@
+fqbn_append: PartitionScheme=huge_app
+
+requires:
+  - CONFIG_BT_SPP_ENABLED=y

libraries/BluetoothSerial/examples/bt_classic_device_discovery/bt_classic_device_discovery.ino

@@ -0,0 +1,53 @@
+#include <BluetoothSerial.h>
+
+#if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
+#error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
+#endif
+
+#if !defined(CONFIG_BT_SPP_ENABLED)
+#error Serial Bluetooth not available or not enabled. It is only available for the ESP32 chip.
+#endif
+
+BluetoothSerial SerialBT;
+
+#define BT_DISCOVER_TIME 10000
+
+static bool btScanAsync = true;
+static bool btScanSync = true;
+
+void btAdvertisedDeviceFound(BTAdvertisedDevice *pDevice) {
+  Serial.printf("Found a device asynchronously: %s\n", pDevice->toString().c_str());
+}
+
+void setup() {
+  Serial.begin(115200);
+  SerialBT.begin("ESP32test");  //Bluetooth device name
+  Serial.println("The device started, now you can pair it with bluetooth!");
+
+  if (btScanAsync) {
+    Serial.print("Starting asynchronous discovery... ");
+    if (SerialBT.discoverAsync(btAdvertisedDeviceFound)) {
+      Serial.println("Findings will be reported in \"btAdvertisedDeviceFound\"");
+      delay(10000);
+      Serial.print("Stopping discoverAsync... ");
+      SerialBT.discoverAsyncStop();
+      Serial.println("stopped");
+    } else {
+      Serial.println("Error on discoverAsync f.e. not working after a \"connect\"");
+    }
+  }
+
+  if (btScanSync) {
+    Serial.println("Starting synchronous discovery... ");
+    BTScanResults *pResults = SerialBT.discover(BT_DISCOVER_TIME);
+    if (pResults) {
+      pResults->dump(&Serial);
+    } else {
+      Serial.println("Error on BT Scan, no result!");
+    }
+  }
+}
+
+void loop() {
+  delay(100);
+}

libraries/BluetoothSerial/examples/bt_classic_device_discovery/ci.yml

@@ -0,0 +1,4 @@
+fqbn_append: PartitionScheme=huge_app
+
+requires:
+  - CONFIG_BT_SPP_ENABLED=y

libraries/BluetoothSerial/examples/bt_remove_paired_devices/bt_remove_paired_devices.ino

@@ -0,0 +1,73 @@
+// This example code is in the Public Domain (or CC0 licensed, at your option.)
+// Originally by Victor Tchistiak - 2019
+// Rewritten with new API by Tomas Pilny - 2023
+//
+// This example demonstrates reading and removing paired devices stored on the ESP32 flash memory
+// Sometimes you may find your ESP32 device could not connect to the remote device despite
+// many successful connections earlier. This is most likely a result of client replacing your paired
+// device info with new one from other device. The BT clients store connection info for paired devices,
+// but it is limited to a few devices only. When new device pairs and number of stored devices is exceeded,
+// one of the previously paired devices would be replaced with new one.
+// The only remedy is to delete this saved bound device from your device flash memory
+// and pair with the other device again.
+
+#include "BluetoothSerial.h"
+//#include "esp_bt_device.h"
+
+#if !defined(CONFIG_BT_SPP_ENABLED)
+#error Serial Bluetooth not available or not enabled. It is only available for the ESP32 chip.
+#endif
+
+#define REMOVE_BONDED_DEVICES true  // <- Set to `false` to view all bonded devices addresses, set to `true` to remove
+#define PAIR_MAX_DEVICES      20
+BluetoothSerial SerialBT;
+
+char *bda2str(const uint8_t *bda, char *str, size_t size) {
+  if (bda == NULL || str == NULL || size < 18) {
+    return NULL;
+  }
+  sprintf(str, "%02x:%02x:%02x:%02x:%02x:%02x", bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
+  return str;
+}
+
+void setup() {
+  char bda_str[18];
+  uint8_t pairedDeviceBtAddr[PAIR_MAX_DEVICES][6];
+  Serial.begin(115200);
+
+  SerialBT.begin();
+  Serial.printf("ESP32 bluetooth address: %s\n", SerialBT.getBtAddressString().c_str());
+  // SerialBT.deleteAllBondedDevices(); // If you want just delete all, this is the way
+  // Get the numbers of bonded/paired devices in the BT module
+  int count = SerialBT.getNumberOfBondedDevices();
+  if (!count) {
+    Serial.println("No bonded devices found.");
+  } else {
+    Serial.printf("Bonded device count: %d\n", count);
+    if (PAIR_MAX_DEVICES < count) {
+      count = PAIR_MAX_DEVICES;
+      Serial.printf("Reset %d bonded devices\n", count);
+    }
+    count = SerialBT.getBondedDevices(count, pairedDeviceBtAddr);
+    char rmt_name[ESP_BT_GAP_MAX_BDNAME_LEN + 1];
+    if (count > 0) {
+      for (int i = 0; i < count; i++) {
+        SerialBT.requestRemoteName(pairedDeviceBtAddr[i]);
+        while (!SerialBT.readRemoteName(rmt_name)) {
+          delay(1);  // Wait for response with the device name
+        }
+        Serial.printf("Found bonded device #%d BDA:%s; Name:\"%s\"\n", i, bda2str(pairedDeviceBtAddr[i], bda_str, 18), rmt_name);
+        SerialBT.invalidateRemoteName();  // Allows waiting for next reading
+        if (REMOVE_BONDED_DEVICES) {
+          if (SerialBT.deleteBondedDevice(pairedDeviceBtAddr[i])) {
+            Serial.printf("Removed bonded device # %d\n", i);
+          } else {
+            Serial.printf("Failed to remove bonded device # %d", i);
+          }  // if(ESP_OK == tError)
+        }  // if(REMOVE_BONDED_DEVICES)
+      }  // for(int i = 0; i < count; i++)
+    }  // if(ESP_OK == tError)
+  }  // if(!count)
+}
+
+void loop() {}

libraries/BluetoothSerial/examples/bt_remove_paired_devices/ci.yml

@@ -0,0 +1,4 @@
+fqbn_append: PartitionScheme=huge_app
+
+requires:
+  - CONFIG_BT_SPP_ENABLED=y