simpleble 0.0.1

data/vendor/simpleble/examples/simpleble/src/multiconnect.cpp

@@ -0,0 +1,60 @@
+#include <chrono>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+#include "utils.hpp"
+
+#include "simpleble/SimpleBLE.h"
+
+using namespace std::chrono_literals;
+
+int main() {
+    auto adapter_optional = Utils::getAdapter();
+
+    if (!adapter_optional.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto adapter = adapter_optional.value();
+
+    std::vector<SimpleBLE::Peripheral> peripherals;
+
+    adapter.set_callback_on_scan_found([&](SimpleBLE::Peripheral peripheral) { peripherals.push_back(peripheral); });
+
+    // Scan for 5 seconds and return.
+    adapter.scan_for(5000);
+
+    std::cout << "The following devices were found:" << std::endl;
+    for (size_t i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i].identifier() << " [" << peripherals[i].address() << "]"
+                  << std::endl;
+    }
+
+    auto selection = Utils::getUserInputInt("Please select a device to connect to", peripherals.size() - 1);
+    if (!selection.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto peripheral = peripherals[selection.value()];
+    peripheral.set_callback_on_connected([]() { std::cout << "Connected callback triggered" << std::endl; });
+    peripheral.set_callback_on_disconnected([]() { std::cout << "Disconnected callback triggered" << std::endl; });
+
+    std::cout << "Connecting to " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+
+    for (size_t i = 0; i < 5; i++) {
+        try {
+            peripheral.connect();
+            std::cout << "Successfully connected." << std::endl;
+            std::this_thread::sleep_for(2s);
+
+            peripheral.disconnect();
+            std::cout << "Successfully disconnected." << std::endl;
+        } catch (const std::exception& ex) {
+            std::cout << "Failed at " << i << " with: " << ex.what() << std::endl;
+            throw;
+        }
+    }
+
+    return EXIT_SUCCESS;
+}

data/vendor/simpleble/examples/simpleble/src/notify.cpp

@@ -0,0 +1,85 @@
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+#include "utils.hpp"
+
+#include "simpleble/SimpleBLE.h"
+
+using namespace std::chrono_literals;
+
+int main() {
+    auto adapter_optional = Utils::getAdapter();
+
+    if (!adapter_optional.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto adapter = adapter_optional.value();
+
+    std::vector<SimpleBLE::Peripheral> peripherals;
+
+    adapter.set_callback_on_scan_found([&](SimpleBLE::Peripheral peripheral) {
+        std::cout << "Found device: " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+        if (peripheral.is_connectable()) {
+            peripherals.push_back(peripheral);
+        }
+    });
+
+    adapter.set_callback_on_scan_start([]() { std::cout << "Scan started." << std::endl; });
+    adapter.set_callback_on_scan_stop([]() { std::cout << "Scan stopped." << std::endl; });
+    // Scan for 5 seconds and return.
+    adapter.scan_for(5000);
+
+    std::cout << "The following devices were found:" << std::endl;
+    for (size_t i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i].identifier() << " [" << peripherals[i].address() << "]"
+                  << std::endl;
+    }
+
+    auto selection = Utils::getUserInputInt("Please select a device to connect to", peripherals.size() - 1);
+    if (!selection.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto peripheral = peripherals[selection.value()];
+    std::cout << "Connecting to " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+    peripheral.connect();
+
+    std::cout << "Successfully connected, printing services and characteristics.." << std::endl;
+
+    // Store all service and characteristic uuids in a vector.
+    std::vector<std::pair<SimpleBLE::BluetoothUUID, SimpleBLE::BluetoothUUID>> uuids;
+    for (auto service : peripheral.services()) {
+        for (auto characteristic : service.characteristics()) {
+            if (characteristic.can_notify()) {
+                uuids.push_back(std::make_pair(service.uuid(), characteristic.uuid()));
+            }
+        }
+    }
+
+    std::cout << "The following services and characteristics were found:" << std::endl;
+    for (size_t i = 0; i < uuids.size(); i++) {
+        std::cout << "[" << i << "] " << uuids[i].first << " " << uuids[i].second << std::endl;
+    }
+
+    selection = Utils::getUserInputInt("Please select a characteristic to notify", uuids.size() - 1);
+
+    if (!selection.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    // Subscribe to the characteristic.
+    peripheral.notify(uuids[selection.value()].first, uuids[selection.value()].second,
+                      [&](SimpleBLE::ByteArray bytes) { std::cout << "Received: " << bytes << std::endl; });
+
+    std::this_thread::sleep_for(5s);
+
+    peripheral.unsubscribe(uuids[selection.value()].first, uuids[selection.value()].second);
+
+    peripheral.disconnect();
+
+    return EXIT_SUCCESS;
+}

data/vendor/simpleble/examples/simpleble/src/notify_multi.cpp

@@ -0,0 +1,101 @@
+#include <atomic>
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+#include "utils.hpp"
+
+#include "simpleble/SimpleBLE.h"
+
+using namespace std::chrono_literals;
+
+int main() {
+    std::vector<SimpleBLE::Peripheral> aux_p;  // Helper vector to hold scan results.
+
+    // Fetch the adapter object that will be used for this test.
+    auto adapter_optional = Utils::getAdapter();
+    if (!adapter_optional.has_value()) {
+        return EXIT_FAILURE;
+    }
+    auto adapter = adapter_optional.value();
+
+    // Configure adapter callbacks.
+    adapter.set_callback_on_scan_found([&](SimpleBLE::Peripheral peripheral) {
+        std::cout << "Found device: " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+        aux_p.push_back(peripheral);
+    });
+    adapter.set_callback_on_scan_start([]() { std::cout << "Scan started." << std::endl; });
+    adapter.set_callback_on_scan_stop([]() { std::cout << "Scan stopped." << std::endl; });
+
+    // Create two uninitialized peripherals that will hold our connections for this example.
+    SimpleBLE::Peripheral peripherals[2];
+
+    // Variable that enables printing per peripheral.
+    std::atomic_bool print_allowed{false};
+
+    for (size_t iter = 0; iter < 2; iter++) {
+        aux_p.clear();
+
+        adapter.scan_for(5000);
+
+        std::cout << "The following devices were found:" << std::endl;
+        for (size_t i = 0; i < aux_p.size(); i++) {
+            std::cout << "[" << i << "] " << aux_p[i].identifier() << " [" << aux_p[i].address() << "]" << std::endl;
+        }
+
+        auto selection = Utils::getUserInputInt("Please select a device to connect to", aux_p.size() - 1);
+        if (!selection.has_value()) {
+            return EXIT_FAILURE;
+        }
+
+        peripherals[iter] = aux_p[selection.value()];
+
+        std::cout << "Connecting to " << peripherals[iter].identifier() << " [" << peripherals[iter].address() << "]"
+                  << std::endl;
+        peripherals[iter].connect();
+
+        std::cout << "Successfully connected, printing services and characteristics.." << std::endl;
+
+        // Store all service and characteristic uuids in a vector.
+        std::vector<std::pair<SimpleBLE::BluetoothUUID, SimpleBLE::BluetoothUUID>> uuids;
+        for (auto service : peripherals[iter].services()) {
+            for (auto characteristic : service.characteristics()) {
+                uuids.push_back(std::make_pair(service.uuid(), characteristic.uuid()));
+            }
+        }
+
+        std::cout << "The following services and characteristics were found:" << std::endl;
+        for (size_t i = 0; i < uuids.size(); i++) {
+            std::cout << "[" << i << "] " << uuids[i].first << " " << uuids[i].second << std::endl;
+        }
+
+        selection = Utils::getUserInputInt("Please select a characteristic to read", uuids.size() - 1);
+
+        if (!selection.has_value()) {
+            return EXIT_FAILURE;
+        }
+
+        // Subscribe to the characteristic.
+        peripherals[iter].notify(uuids[selection.value()].first, uuids[selection.value()].second,
+                                 [&, iter](SimpleBLE::ByteArray bytes) {
+                                     if (print_allowed) {
+                                         std::cout << "Peripheral " << iter << " received: " << bytes << std::endl;
+                                     }
+                                 });
+    }
+
+    // Once both devices are connected and streaming, enable printing for 5 seconds, then disconnect from both.
+    print_allowed = true;
+
+    std::this_thread::sleep_for(5s);
+
+    peripherals[1].disconnect();
+
+    std::this_thread::sleep_for(3s);
+
+    peripherals[0].disconnect();
+
+    return EXIT_SUCCESS;
+}

data/vendor/simpleble/examples/simpleble/src/power_cycle.cpp

@@ -0,0 +1,43 @@
+#include <iostream>
+#include <thread>
+
+#include "simpleble/Adapter.h"
+#include "simpleble/Utils.h"
+
+int main() {
+    std::cout << "Using SimpleBLE version: " << SimpleBLE::get_simpleble_version() << std::endl;
+    std::cout << "Bluetooth enabled: " << SimpleBLE::Adapter::bluetooth_enabled() << std::endl;
+
+    auto adapter_list = SimpleBLE::Adapter::get_adapters();
+
+    if (adapter_list.empty()) {
+        std::cout << "No adapter found" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    for (auto& adapter : adapter_list) {
+        std::cout << "Adapter: " << adapter.identifier() << " [" << adapter.address() << "]" << std::endl;
+
+        adapter.set_callback_on_power_on([&]() {
+            std::cout << "Adapter powered on" << std::endl;
+        });
+
+        adapter.set_callback_on_power_off([&]() {
+            std::cout << "Adapter powered off" << std::endl;
+        });
+
+        std::cout << "Adapter powered: " << adapter.is_powered() << std::endl;
+
+        std::cout << "Powering off adapter" << std::endl;
+        adapter.power_off();
+        std::cout << "Adapter powered: " << adapter.is_powered() << std::endl;
+
+        std::this_thread::sleep_for(std::chrono::seconds(5));
+
+        std::cout << "Powering on adapter" << std::endl;
+        adapter.power_on();
+        std::cout << "Adapter powered: " << adapter.is_powered() << std::endl;
+    }
+
+    return EXIT_SUCCESS;
+}

data/vendor/simpleble/examples/simpleble/src/read.cpp

@@ -0,0 +1,82 @@
+#include <chrono>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+#include "utils.hpp"
+
+#include "simpleble/SimpleBLE.h"
+
+using namespace std::chrono_literals;
+
+int main() {
+    auto adapter_optional = Utils::getAdapter();
+
+    if (!adapter_optional.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto adapter = adapter_optional.value();
+
+    std::vector<SimpleBLE::Peripheral> peripherals;
+
+    adapter.set_callback_on_scan_found([&](SimpleBLE::Peripheral peripheral) {
+        std::cout << "Found device: " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+        if (peripheral.is_connectable()) {
+            peripherals.push_back(peripheral);
+        }
+    });
+
+    adapter.set_callback_on_scan_start([]() { std::cout << "Scan started." << std::endl; });
+    adapter.set_callback_on_scan_stop([]() { std::cout << "Scan stopped." << std::endl; });
+    // Scan for 5 seconds and return.
+    adapter.scan_for(5000);
+
+    std::cout << "The following devices were found:" << std::endl;
+    for (size_t i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i].identifier() << " [" << peripherals[i].address() << "]"
+                  << std::endl;
+    }
+
+    auto selection = Utils::getUserInputInt("Please select a device to connect to", peripherals.size() - 1);
+
+    if (!selection.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto peripheral = peripherals[selection.value()];
+    std::cout << "Connecting to " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+    peripheral.connect();
+
+    std::cout << "Successfully connected, printing services and characteristics.." << std::endl;
+
+    // Store all service and characteristic uuids in a vector.
+    std::vector<std::pair<SimpleBLE::BluetoothUUID, SimpleBLE::BluetoothUUID>> uuids;
+    for (auto service : peripheral.services()) {
+        for (auto characteristic : service.characteristics()) {
+            uuids.push_back(std::make_pair(service.uuid(), characteristic.uuid()));
+        }
+    }
+
+    std::cout << "The following services and characteristics were found:" << std::endl;
+    for (size_t i = 0; i < uuids.size(); i++) {
+        std::cout << "[" << i << "] " << uuids[i].first << " " << uuids[i].second << std::endl;
+    }
+
+    selection = Utils::getUserInputInt("Select a characteristic to read", uuids.size() - 1);
+
+    if (!selection.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    // Attempt to read the characteristic 5 times in 5 seconds.
+    for (size_t i = 0; i < 5; i++) {
+        SimpleBLE::ByteArray rx_data = peripheral.read(uuids[selection.value()].first, uuids[selection.value()].second);
+        std::cout << "Characteristic content is: " << rx_data << std::endl;
+        std::this_thread::sleep_for(1s);
+    }
+
+    peripheral.disconnect();
+
+    return EXIT_SUCCESS;
+}

data/vendor/simpleble/examples/simpleble/src/scan.cpp

@@ -0,0 +1,62 @@
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
+#include "utils.hpp"
+
+#include "simpleble/Adapter.h"
+
+int main() {
+    auto adapter_optional = Utils::getAdapter();
+
+    if (!adapter_optional.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto adapter = adapter_optional.value();
+
+    adapter.set_callback_on_scan_found([](SimpleBLE::Peripheral peripheral) {
+        std::cout << "Found device: " << peripheral.identifier() << " [" << peripheral.address() << "] "
+                  << peripheral.rssi() << " dBm" << std::endl;
+    });
+
+    adapter.set_callback_on_scan_updated([](SimpleBLE::Peripheral peripheral) {
+        std::cout << "Updated device: " << peripheral.identifier() << " [" << peripheral.address() << "] "
+                  << peripheral.rssi() << " dBm" << std::endl;
+    });
+
+    adapter.set_callback_on_scan_start([]() { std::cout << "Scan started." << std::endl; });
+
+    adapter.set_callback_on_scan_stop([]() { std::cout << "Scan stopped." << std::endl; });
+
+    // Scan for 5 seconds.
+    adapter.scan_for(5000);
+
+    std::cout << "Scan complete." << std::endl;
+
+    std::vector<SimpleBLE::Peripheral> peripherals = adapter.scan_get_results();
+    std::cout << "The following devices were found:" << std::endl;
+    for (size_t i = 0; i < peripherals.size(); i++) {
+        std::string connectable_string = peripherals[i].is_connectable() ? "Connectable" : "Non-Connectable";
+        std::string peripheral_string = peripherals[i].identifier() + " [" + peripherals[i].address() + "] " +
+                                        std::to_string(peripherals[i].rssi()) + " dBm";
+
+        std::cout << "[" << i << "] " << peripheral_string << " " << connectable_string << std::endl;
+
+        std::cout << "    Tx Power: " << std::dec << peripherals[i].tx_power() << " dBm" << std::endl;
+        std::cout << "    Address Type: " << peripherals[i].address_type() << std::endl;
+
+        std::vector<SimpleBLE::Service> services = peripherals[i].services();
+        for (auto& service : services) {
+            std::cout << "    Service UUID: " << service.uuid() << std::endl;
+            std::cout << "    Service data: " << service.data() << std::endl;
+        }
+
+        std::map<uint16_t, SimpleBLE::ByteArray> manufacturer_data = peripherals[i].manufacturer_data();
+        for (auto& [manufacturer_id, data] : manufacturer_data) {
+            std::cout << "    Manufacturer ID: " << manufacturer_id << std::endl;
+            std::cout << "    Manufacturer data: " << data << std::endl;
+        }
+    }
+    return EXIT_SUCCESS;
+}

data/vendor/simpleble/examples/simpleble/src/utils.cpp

@@ -0,0 +1,59 @@
+#include "utils.hpp"
+
+#include <iomanip>
+#include <iostream>
+
+std::optional<std::size_t> Utils::getUserInputInt(const std::string& line, std::size_t max) {
+    std::size_t ret;
+
+    while (!std::cin.eof()) {
+        std::cout << line << " (0-" << max << "): ";
+        std::cin >> ret;
+
+        if (!std::cin) {
+            return {};
+        }
+
+        if (ret <= max) {
+            return ret;
+        }
+    }
+    return {};
+}
+
+std::optional<SimpleBLE::Adapter> Utils::getAdapter() {
+    if (!SimpleBLE::Adapter::bluetooth_enabled()) {
+        std::cout << "Bluetooth is not enabled!" << std::endl;
+        return {};
+    }
+
+    auto adapter_list = SimpleBLE::Adapter::get_adapters();
+
+    // no adapter found
+    if (adapter_list.empty()) {
+        std::cerr << "No adapter was found." << std::endl;
+        return {};
+    }
+
+    // only one found, returning directly
+    if (adapter_list.size() == 1) {
+        auto adapter = adapter_list.at(0);
+        std::cout << "Using adapter: " << adapter.identifier() << " [" << adapter.address() << "]" << std::endl;
+        return adapter;
+    }
+
+    // multiple adapters found, ask user to select one
+    std::cout << "Available adapters:" << std::endl;
+    int i = 0;
+    for (auto& adapter : adapter_list) {
+        std::cout << "[" << i++ << "] " << adapter.identifier() << " [" << adapter.address() << "]" << std::endl;
+    }
+
+    auto adapter_selection = Utils::getUserInputInt("Select an adapter", adapter_list.size() - 1);
+
+    if (!adapter_selection.has_value()) {
+        return {};
+    }
+
+    return adapter_list[adapter_selection.value()];
+}

data/vendor/simpleble/examples/simpleble/src/utils.hpp

@@ -0,0 +1,27 @@
+#ifndef UTILS_HPP
+#define UTILS_HPP
+
+#include <optional>
+#include "simpleble/SimpleBLE.h"
+
+namespace Utils {
+/**
+ * @brief Function to retrieve the adapter easily
+ *
+ * @return the adapter or an empty optional
+ */
+std::optional<SimpleBLE::Adapter> getAdapter();
+
+/**
+ * @brief Function to get a user input as size_t, it's used in all examples to select an index
+ *
+ * @param line the text asking for something to the user
+ * @param max the maximum value that can be written
+ *
+ * @return the value or empty optional
+ */
+std::optional<std::size_t> getUserInputInt(const std::string& line, std::size_t max);
+
+}  // namespace Utils
+
+#endif

data/vendor/simpleble/examples/simpleble/src/write.cpp

@@ -0,0 +1,81 @@
+#include <iomanip>
+#include <iostream>
+#include <vector>
+
+#include "utils.hpp"
+
+#include "simpleble/SimpleBLE.h"
+
+int main() {
+    auto adapter_optional = Utils::getAdapter();
+
+    if (!adapter_optional.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    auto adapter = adapter_optional.value();
+
+    std::vector<SimpleBLE::Peripheral> peripherals;
+
+    adapter.set_callback_on_scan_found([&](SimpleBLE::Peripheral peripheral) {
+        std::cout << "Found device: " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+        if (peripheral.is_connectable()) {
+            peripherals.push_back(peripheral);
+        }
+    });
+
+    adapter.set_callback_on_scan_start([]() { std::cout << "Scan started." << std::endl; });
+    adapter.set_callback_on_scan_stop([]() { std::cout << "Scan stopped." << std::endl; });
+    // Scan for 5 seconds and return.
+    adapter.scan_for(5000);
+
+    std::cout << "The following devices were found:" << std::endl;
+    for (size_t i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i].identifier() << " [" << peripherals[i].address() << "]"
+                  << std::endl;
+    }
+
+    auto selection = Utils::getUserInputInt("Please select a device to connect to: ", peripherals.size() - 1);
+
+    if (!selection.has_value()) {
+        return EXIT_FAILURE;
+    }
+    auto peripheral = peripherals[selection.value()];
+    std::cout << "Connecting to " << peripheral.identifier() << " [" << peripheral.address() << "]" << std::endl;
+    peripheral.connect();
+
+    std::cout << "Successfully connected, printing services and characteristics.." << std::endl;
+
+    // Store all service and characteristic uuids in a vector.
+    std::vector<std::pair<SimpleBLE::BluetoothUUID, SimpleBLE::BluetoothUUID>> uuids;
+    for (auto service : peripheral.services()) {
+        for (auto characteristic : service.characteristics()) {
+            uuids.push_back(std::make_pair(service.uuid(), characteristic.uuid()));
+        }
+    }
+
+    std::cout << "The following services and characteristics were found:" << std::endl;
+    for (size_t i = 0; i < uuids.size(); i++) {
+        std::cout << "[" << i << "] " << uuids[i].first << " " << uuids[i].second << std::endl;
+    }
+
+    selection = Utils::getUserInputInt("Please select a characteristic to write into: ", uuids.size() - 1);
+
+    std::string contents;
+    std::cout << "Please write the contents to be sent: ";
+    std::cin >> contents;
+
+    if (!selection.has_value()) {
+        return EXIT_FAILURE;
+    }
+
+    SimpleBLE::ByteArray bytes = SimpleBLE::ByteArray::fromHex(contents);
+
+    // NOTE: Alternatively, `write_command` can be used to write to a characteristic too.
+    // `write_request` is for unacknowledged writes.
+    // `write_command` is for acknowledged writes.
+    peripheral.write_request(uuids[selection.value()].first, uuids[selection.value()].second, bytes);
+
+    peripheral.disconnect();
+    return EXIT_SUCCESS;
+}