simpleble 0.0.1

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

@@ -0,0 +1,141 @@
+#include <simplebluez/Bluez.h>
+#include <simplebluez/Exceptions.h>
+
+#include <atomic>
+#include <chrono>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <thread>
+
+SimpleBluez::Bluez bluez;
+
+std::atomic_bool async_thread_active = true;
+void async_thread_function() {
+    while (async_thread_active) {
+        bluez.run_async();
+        std::this_thread::sleep_for(std::chrono::microseconds(100));
+    }
+}
+
+void millisecond_delay(int ms) {
+    for (int i = 0; i < ms; i++) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+void print_byte_array(SimpleBluez::ByteArray& bytes) {
+    for (auto byte : bytes) {
+        std::cout << std::hex << std::setfill('0') << (uint32_t)((uint8_t)byte) << " ";
+        break;
+    }
+    std::cout << std::endl;
+}
+
+std::vector<std::shared_ptr<SimpleBluez::Device>> peripherals;
+
+int main(int argc, char* argv[]) {
+    int selection = -1;
+
+    bluez.init();
+    std::thread* async_thread = new std::thread(async_thread_function);
+
+    auto adapters = bluez.get_adapters();
+    std::cout << "Available adapters:" << std::endl;
+    for (int i = 0; i < adapters.size(); i++) {
+        std::cout << "[" << i << "] " << adapters[i]->identifier() << " [" << adapters[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select an adapter to scan: ";
+    std::cin >> selection;
+    if (selection < 0 || selection >= adapters.size()) {
+        std::cout << "Invalid selection" << std::endl;
+        return 1;
+    }
+
+    auto adapter = adapters[selection];
+    std::cout << "Scanning " << adapter->identifier() << " [" << adapter->address() << "]" << std::endl;
+
+    SimpleBluez::Adapter::DiscoveryFilter filter;
+    filter.Transport = SimpleBluez::Adapter::DiscoveryFilter::TransportType::LE;
+    adapter->discovery_filter(filter);
+
+    adapter->set_on_device_updated([](std::shared_ptr<SimpleBluez::Device> device) {
+        if (std::find(peripherals.begin(), peripherals.end(), device) == peripherals.end()) {
+            std::cout << "Found device: " << device->name() << " [" << device->address() << "]" << std::endl;
+            peripherals.push_back(device);
+        }
+    });
+
+    adapter->discovery_start();
+    millisecond_delay(3000);
+    adapter->discovery_stop();
+
+    std::cout << "The following devices were found:" << std::endl;
+    for (int i = 0; i < peripherals.size(); i++) {
+        std::cout << "[" << i << "] " << peripherals[i]->name() << " [" << peripherals[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select a device to connect to: ";
+    std::cin >> selection;
+
+    if (selection >= 0 && selection < peripherals.size()) {
+        auto peripheral = peripherals[selection];
+        std::cout << "Connecting to " << peripheral->name() << " [" << peripheral->address() << "]" << std::endl;
+
+        for (int attempt = 0; attempt < 3; attempt++) {
+            try {
+                peripheral->connect();
+            } catch (SimpleDBus::Exception::SendFailed& e) {
+                millisecond_delay(100);
+            }
+        }
+
+        if (!peripheral->connected() || !peripheral->services_resolved()) {
+            std::cout << "Failed to connect to " << peripheral->name() << " [" << peripheral->address() << "]"
+                      << std::endl;
+            return 1;
+        }
+
+        // Store all services and characteristics in a vector.
+        std::vector<std::pair<std::shared_ptr<SimpleBluez::Service>, std::shared_ptr<SimpleBluez::Characteristic>>>
+            char_list;
+        for (auto service : peripheral->services()) {
+            for (auto characteristic : service->characteristics()) {
+                char_list.push_back(std::make_pair(service, characteristic));
+            }
+        }
+
+        std::cout << "The following services and characteristics were found:" << std::endl;
+        for (int i = 0; i < char_list.size(); i++) {
+            std::cout << "[" << i << "] " << char_list[i].first->uuid() << " " << char_list[i].second->uuid()
+                      << std::endl;
+        }
+
+        std::cout << "Please select a characteristic to read: ";
+        std::cin >> selection;
+
+        if (selection >= 0 && selection < char_list.size()) {
+            SimpleBluez::ByteArray value = char_list[selection].second->read();
+            std::cout << "Characteristic contents were: ";
+            print_byte_array(value);
+        }
+
+        peripheral->disconnect();
+
+        // Sleep for an additional second before returning.
+        // If there are any unexpected events, this example will help debug them.
+        millisecond_delay(1000);
+    }
+
+    async_thread_active = false;
+    while (!async_thread->joinable()) {
+        millisecond_delay(10);
+    }
+    async_thread->join();
+    delete async_thread;
+
+    return 0;
+}

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

@@ -0,0 +1,85 @@
+#include <simplebluez/Bluez.h>
+
+#include <atomic>
+#include <chrono>
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+#include <thread>
+
+SimpleBluez::Bluez bluez;
+
+std::atomic_bool async_thread_active = true;
+void async_thread_function() {
+    while (async_thread_active) {
+        bluez.run_async();
+        std::this_thread::sleep_for(std::chrono::microseconds(100));
+    }
+}
+
+void millisecond_delay(int ms) {
+    for (int i = 0; i < ms; i++) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+}
+
+int main(int argc, char* argv[]) {
+    int selection = -1;
+
+    bluez.init();
+    std::thread* async_thread = new std::thread(async_thread_function);
+
+    auto adapters = bluez.get_adapters();
+    std::cout << "The following adapters were found:" << std::endl;
+    for (int i = 0; i < adapters.size(); i++) {
+        std::cout << "[" << i << "] " << adapters[i]->identifier() << " [" << adapters[i]->address() << "]"
+                  << std::endl;
+    }
+
+    std::cout << "Please select an adapter to scan: ";
+    std::cin >> selection;
+    if (selection < 0 || selection >= adapters.size()) {
+        std::cout << "Invalid selection" << std::endl;
+        return 1;
+    }
+
+    auto adapter = adapters[selection];
+    std::cout << "Scanning " << adapter->identifier() << " [" << adapter->address() << "]" << std::endl;
+
+    SimpleBluez::Adapter::DiscoveryFilter filter;
+    filter.Transport = SimpleBluez::Adapter::DiscoveryFilter::TransportType::LE;
+    adapter->discovery_filter(filter);
+
+    adapter->set_on_device_updated([](std::shared_ptr<SimpleBluez::Device> device) {
+        std::cout << "Update received for " << device->address() << std::endl;
+        std::cout << "\tName " << device->name() << std::endl;
+        std::cout << "\tAddress Type " << device->address_type() << std::endl;
+        std::cout << "\tRSSI " << std::dec << device->rssi() << std::endl;
+        std::cout << "\tTxPower " << std::dec << device->tx_power() << std::endl;
+        auto manufacturer_data = device->manufacturer_data();
+        for (auto& [manufacturer_id, value_array] : manufacturer_data) {
+            std::cout << "\tManuf ID 0x" << std::setfill('0') << std::setw(4) << std::hex << (int)manufacturer_id;
+            std::cout << ": ";
+            for (int i = 0; i < value_array.size(); i++) {
+                std::cout << std::setfill('0') << std::setw(2) << std::hex << ((int)value_array[i]) << " ";
+            }
+            std::cout << std::endl;
+        }
+    });
+
+    adapter->discovery_start();
+    millisecond_delay(3000);
+    adapter->discovery_stop();
+
+    // Sleep for a bit to allow the adapter to stop discovering.
+    millisecond_delay(3000);
+
+    async_thread_active = false;
+    while (!async_thread->joinable()) {
+        millisecond_delay(10);
+    }
+    async_thread->join();
+    delete async_thread;
+
+    return 0;
+}

data/vendor/simpleble/examples/simplecble/c/connect.c

@@ -0,0 +1,163 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "simpleble_c/simpleble.h"
+
+#define PERIPHERAL_LIST_SIZE (size_t)10
+
+static void clean_on_exit(void);
+
+static void adapter_on_scan_start(simpleble_adapter_t adapter, void* userdata);
+static void adapter_on_scan_stop(simpleble_adapter_t adapter, void* userdata);
+static void adapter_on_scan_found(simpleble_adapter_t adapter, simpleble_peripheral_t peripheral, void* userdata);
+
+static simpleble_peripheral_t peripheral_list[PERIPHERAL_LIST_SIZE] = {0};
+static size_t peripheral_list_len = 0;
+static simpleble_adapter_t adapter = NULL;
+
+int main() {
+    simpleble_err_t err_code = SIMPLEBLE_SUCCESS;
+    atexit(clean_on_exit);
+
+    // NOTE: It's necessary to call this function before any other to allow the
+    // underlying driver to run its initialization routine.
+    size_t adapter_count = simpleble_adapter_get_count();
+    if (adapter_count == 0) {
+        printf("No adapter was found.\n");
+        return 1;
+    }
+
+    // TODO: Allow the user to pick an adapter.
+    adapter = simpleble_adapter_get_handle(0);
+    if (adapter == NULL) {
+        printf("No adapter was found.\n");
+        return 1;
+    }
+
+    simpleble_adapter_set_callback_on_scan_start(adapter, adapter_on_scan_start, NULL);
+    simpleble_adapter_set_callback_on_scan_stop(adapter, adapter_on_scan_stop, NULL);
+    simpleble_adapter_set_callback_on_scan_found(adapter, adapter_on_scan_found, NULL);
+
+    simpleble_adapter_scan_for(adapter, 5000);
+
+    printf("The following devices were found:\n");
+    for (size_t i = 0; i < peripheral_list_len; i++) {
+        simpleble_peripheral_t peripheral = peripheral_list[i];
+        char* peripheral_identifier = simpleble_peripheral_identifier(peripheral);
+        char* peripheral_address = simpleble_peripheral_address(peripheral);
+        printf("[%zu] %s [%s]\n", i, peripheral_identifier, peripheral_address);
+        simpleble_free(peripheral_identifier);
+        simpleble_free(peripheral_address);
+    }
+
+    int selection = -1;
+    printf("Please select a device to connect to: ");
+    scanf("%d", &selection);
+
+    if (selection < 0 || selection >= (int)peripheral_list_len) {
+        printf("Invalid selection.\n");
+        return 1;
+    }
+
+    simpleble_peripheral_t peripheral = peripheral_list[selection];
+
+    char* peripheral_identifier = simpleble_peripheral_identifier(peripheral);
+    char* peripheral_address = simpleble_peripheral_address(peripheral);
+    printf("Connecting to %s [%s]\n", peripheral_identifier, peripheral_address);
+    simpleble_free(peripheral_identifier);
+    simpleble_free(peripheral_address);
+
+    err_code = simpleble_peripheral_connect(peripheral);
+    if (err_code != SIMPLEBLE_SUCCESS) {
+        printf("Failed to connect.\n");
+        return 1;
+    }
+
+    size_t services_count = simpleble_peripheral_services_count(peripheral);
+    printf("Successfully connected, listing %zu services.\n", services_count);
+
+    for (size_t i = 0; i < services_count; i++) {
+        simpleble_service_t service;
+        err_code = simpleble_peripheral_services_get(peripheral, i, &service);
+
+        if (err_code != SIMPLEBLE_SUCCESS) {
+            printf("Failed to get service.\n");
+            return 1;
+        }
+
+        printf("Service: %s - (%zu characteristics)\n", service.uuid.value, service.characteristic_count);
+        for (size_t j = 0; j < service.characteristic_count; j++) {
+            printf("  Characteristic: %s - (%zu descriptors)\n", service.characteristics[j].uuid.value,
+                   service.characteristics[j].descriptor_count);
+            for (size_t k = 0; k < service.characteristics[j].descriptor_count; k++) {
+                printf("    Descriptor: %s\n", service.characteristics[j].descriptors[k].uuid.value);
+            }
+        }
+    }
+
+    simpleble_peripheral_disconnect(peripheral);
+
+    return 0;
+}
+
+static void clean_on_exit(void) {
+    printf("Releasing allocated resources.\n");
+
+    // Release all saved peripherals
+    for (size_t i = 0; i < peripheral_list_len; i++) {
+        simpleble_peripheral_release_handle(peripheral_list[i]);
+    }
+
+    // Let's not forget to release the associated handle.
+    simpleble_adapter_release_handle(adapter);
+}
+
+static void adapter_on_scan_start(simpleble_adapter_t adapter, void* userdata) {
+    char* identifier = simpleble_adapter_identifier(adapter);
+
+    if (identifier == NULL) {
+        return;
+    }
+
+    printf("Adapter %s started scanning.\n", identifier);
+
+    // Let's not forget to clear the allocated memory.
+    simpleble_free(identifier);
+}
+
+static void adapter_on_scan_stop(simpleble_adapter_t adapter, void* userdata) {
+    char* identifier = simpleble_adapter_identifier(adapter);
+
+    if (identifier == NULL) {
+        return;
+    }
+
+    printf("Adapter %s stopped scanning.\n", identifier);
+
+    // Let's not forget to clear the allocated memory.
+    simpleble_free(identifier);
+}
+
+static void adapter_on_scan_found(simpleble_adapter_t adapter, simpleble_peripheral_t peripheral, void* userdata) {
+    char* adapter_identifier = simpleble_adapter_identifier(adapter);
+    char* peripheral_identifier = simpleble_peripheral_identifier(peripheral);
+    char* peripheral_address = simpleble_peripheral_address(peripheral);
+
+    if (adapter_identifier == NULL || peripheral_identifier == NULL || peripheral_address == NULL) {
+        return;
+    }
+
+    printf("Adapter %s found device: %s [%s]\n", adapter_identifier, peripheral_identifier, peripheral_address);
+
+    if (peripheral_list_len < PERIPHERAL_LIST_SIZE) {
+        // Save the peripheral
+        peripheral_list[peripheral_list_len++] = peripheral;
+    } else {
+        // As there was no space left for this peripheral, release the associated handle.
+        simpleble_peripheral_release_handle(peripheral);
+    }
+
+    // Let's not forget to release all allocated memory.
+    simpleble_free(peripheral_identifier);
+    simpleble_free(peripheral_address);
+}

data/vendor/simpleble/examples/simplecble/c/notify.c

@@ -0,0 +1,217 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+#endif
+
+void msleep(int ms) {
+#ifdef _WIN32
+    Sleep(ms);
+#else
+    usleep(ms * 1000);
+#endif
+}
+
+#include "simpleble_c/simpleble.h"
+
+#define PERIPHERAL_LIST_SIZE (size_t)10
+#define SERVICES_LIST_SIZE (size_t)32
+
+typedef struct {
+    simpleble_uuid_t service;
+    simpleble_uuid_t characteristic;
+} service_characteristic_t;
+
+static void clean_on_exit(void);
+
+static void adapter_on_scan_start(simpleble_adapter_t adapter, void* userdata);
+static void adapter_on_scan_stop(simpleble_adapter_t adapter, void* userdata);
+static void adapter_on_scan_found(simpleble_adapter_t adapter, simpleble_peripheral_t peripheral, void* userdata);
+static void peripheral_on_notify(simpleble_peripheral_t handle, simpleble_uuid_t service,
+                                 simpleble_uuid_t characteristic, const uint8_t* data, size_t data_length,
+                                 void* userdata);
+
+static service_characteristic_t characteristic_list[SERVICES_LIST_SIZE] = {0};
+static simpleble_peripheral_t peripheral_list[PERIPHERAL_LIST_SIZE] = {0};
+static size_t peripheral_list_len = 0;
+static simpleble_adapter_t adapter = NULL;
+
+int main() {
+    simpleble_err_t err_code = SIMPLEBLE_SUCCESS;
+    atexit(clean_on_exit);
+
+    // NOTE: It's necessary to call this function before any other to allow the
+    // underlying driver to run its initialization routine.
+    size_t adapter_count = simpleble_adapter_get_count();
+    if (adapter_count == 0) {
+        printf("No adapter was found.\n");
+        return 1;
+    }
+
+    // TODO: Allow the user to pick an adapter.
+    adapter = simpleble_adapter_get_handle(0);
+    if (adapter == NULL) {
+        printf("No adapter was found.\n");
+        return 1;
+    }
+
+    simpleble_adapter_set_callback_on_scan_start(adapter, adapter_on_scan_start, NULL);
+    simpleble_adapter_set_callback_on_scan_stop(adapter, adapter_on_scan_stop, NULL);
+    simpleble_adapter_set_callback_on_scan_found(adapter, adapter_on_scan_found, NULL);
+
+    simpleble_adapter_scan_for(adapter, 5000);
+
+    printf("The following devices were found:\n");
+    for (size_t i = 0; i < peripheral_list_len; i++) {
+        simpleble_peripheral_t peripheral = peripheral_list[i];
+        char* peripheral_identifier = simpleble_peripheral_identifier(peripheral);
+        char* peripheral_address = simpleble_peripheral_address(peripheral);
+        printf("[%zu] %s [%s]\n", i, peripheral_identifier, peripheral_address);
+        simpleble_free(peripheral_identifier);
+        simpleble_free(peripheral_address);
+    }
+
+    int selection = -1;
+    printf("Please select a device to connect to: ");
+    scanf("%d", &selection);
+
+    if (selection < 0 || selection >= (int)peripheral_list_len) {
+        printf("Invalid selection.\n");
+        return 1;
+    }
+
+    simpleble_peripheral_t peripheral = peripheral_list[selection];
+
+    char* peripheral_identifier = simpleble_peripheral_identifier(peripheral);
+    char* peripheral_address = simpleble_peripheral_address(peripheral);
+    printf("Connecting to %s [%s]\n", peripheral_identifier, peripheral_address);
+    simpleble_free(peripheral_identifier);
+    simpleble_free(peripheral_address);
+
+    err_code = simpleble_peripheral_connect(peripheral);
+    if (err_code != SIMPLEBLE_SUCCESS) {
+        printf("Failed to connect.\n");
+        return 1;
+    }
+
+    printf("Successfully connected, listing services and characteristics.\n");
+
+    size_t characteristic_count = 0;
+    for (size_t i = 0; i < simpleble_peripheral_services_count(peripheral); i++) {
+        simpleble_service_t service;
+        err_code = simpleble_peripheral_services_get(peripheral, i, &service);
+
+        if (err_code != SIMPLEBLE_SUCCESS) {
+            printf("Failed to get service.\n");
+            return 1;
+        }
+
+        for (size_t j = 0; j < service.characteristic_count; j++) {
+            if (characteristic_count >= SERVICES_LIST_SIZE) {
+                break;
+            }
+
+            printf("[%zu] %s %s\n", characteristic_count, service.uuid.value, service.characteristics[j].uuid.value);
+            characteristic_list[characteristic_count].service = service.uuid;
+            characteristic_list[characteristic_count].characteristic = service.characteristics[j].uuid;
+            characteristic_count++;
+        }
+    }
+
+    selection = -1;
+    printf("Please select a characteristic to read from: ");
+    scanf("%d", &selection);
+
+    if (selection < 0 || selection >= (int)characteristic_count) {
+        printf("Invalid selection.\n");
+        return 1;
+    }
+
+    simpleble_peripheral_notify(peripheral, characteristic_list[selection].service,
+                                characteristic_list[selection].characteristic, peripheral_on_notify, NULL);
+
+    // Sleep for 5 seconds
+    msleep(5000);
+
+    simpleble_peripheral_unsubscribe(peripheral, characteristic_list[selection].service,
+                                     characteristic_list[selection].characteristic);
+
+    simpleble_peripheral_disconnect(peripheral);
+
+    return 0;
+}
+
+static void clean_on_exit(void) {
+    printf("Releasing allocated resources.\n");
+
+    // Release all saved peripherals
+    for (size_t i = 0; i < peripheral_list_len; i++) {
+        simpleble_peripheral_release_handle(peripheral_list[i]);
+    }
+
+    // Let's not forget to release the associated handle.
+    simpleble_adapter_release_handle(adapter);
+}
+
+static void adapter_on_scan_start(simpleble_adapter_t adapter, void* userdata) {
+    char* identifier = simpleble_adapter_identifier(adapter);
+
+    if (identifier == NULL) {
+        return;
+    }
+
+    printf("Adapter %s started scanning.\n", identifier);
+
+    // Let's not forget to clear the allocated memory.
+    simpleble_free(identifier);
+}
+
+static void adapter_on_scan_stop(simpleble_adapter_t adapter, void* userdata) {
+    char* identifier = simpleble_adapter_identifier(adapter);
+
+    if (identifier == NULL) {
+        return;
+    }
+
+    printf("Adapter %s stopped scanning.\n", identifier);
+
+    // Let's not forget to clear the allocated memory.
+    simpleble_free(identifier);
+}
+
+static void adapter_on_scan_found(simpleble_adapter_t adapter, simpleble_peripheral_t peripheral, void* userdata) {
+    char* adapter_identifier = simpleble_adapter_identifier(adapter);
+    char* peripheral_identifier = simpleble_peripheral_identifier(peripheral);
+    char* peripheral_address = simpleble_peripheral_address(peripheral);
+
+    if (adapter_identifier == NULL || peripheral_identifier == NULL || peripheral_address == NULL) {
+        return;
+    }
+
+    printf("Adapter %s found device: %s [%s]\n", adapter_identifier, peripheral_identifier, peripheral_address);
+
+    if (peripheral_list_len < PERIPHERAL_LIST_SIZE) {
+        // Save the peripheral
+        peripheral_list[peripheral_list_len++] = peripheral;
+    } else {
+        // As there was no space left for this peripheral, release the associated handle.
+        simpleble_peripheral_release_handle(peripheral);
+    }
+
+    // Let's not forget to release all allocated memory.
+    simpleble_free(peripheral_identifier);
+    simpleble_free(peripheral_address);
+}
+
+static void peripheral_on_notify(simpleble_peripheral_t handle, simpleble_uuid_t service,
+                                 simpleble_uuid_t characteristic, const uint8_t* data, size_t data_length,
+                                 void* userdata) {
+    printf("Received: ");
+    for (size_t i = 0; i < data_length; i++) {
+        printf("%02X ", data[i]);
+    }
+    printf("\n");
+}