SimpleBLE

https://simpleble.readthedocs.io/en/latest/
Admin
SimpleBLE is a cross-platform library and bindings for Bluetooth Low Energy (BLE), designed for...
Tokens:37,614
Snippets:319
Trust Score:8.3
Update:10 months ago
Show doc for...
Tokens:
Raw
### Install SimpleDBus using CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpledbus/usage.rst

Instructions for installing the SimpleDBus library after it has been built. This includes the basic install command and an example of specifying a custom installation prefix. Note that sudo privileges may be required on Linux/macOS.

```bash
cmake --install build_simpledbus
```

```bash
cmake --install build_simpledbus --prefix /usr/local
```

```bash
sudo cmake --install build_simpledbus
```

--------------------------------

### Build SimpleBLE Examples with CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This command sequence shows how to configure and build the example projects for SimpleBLE using CMake. It specifies the path to SimpleBLE, sets the build directory, and enables local mode for the build.

```bash
cmake -S <path-to-simpleble>/examples/simpleble -B build_simpleble_examples -DSIMPLEBLE_LOCAL=ON
cmake --build build_simpleble_examples -j7
```

--------------------------------

### Include SimpleBLE Library

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/tutorial.rst

Includes the main SimpleBLE header file to access all library classes. This is the simplest way to get started if you need all functionalities.

```cpp
#include <simpleble/SimpleBLE.h>
```

--------------------------------

### Build SimpleDBus Examples with CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpledbus/usage.rst

This snippet shows how to build the SimpleDBus examples using CMake. It configures the build with local dependencies and specifies the number of parallel jobs for faster compilation.

```bash
cmake -S <path-to-simpledbus>/examples/simpledbus -B build_simpledbus_examples -DSIMPLEDBUS_LOCAL=ON
cmake --build build_simpledbus_examples -j7
```

--------------------------------

### Install SimpleBLE from PyPI

Source: https://simpleble.readthedocs.io/en/latest/_sources/simplepyble/usage.rst

Installs the SimpleBLE library using pip, the Python Package Installer. This is the quickest method for getting started with the library.

```shell
pip install simplepyble
```

--------------------------------

### Example Usage

Source: https://simpleble.readthedocs.io/en/latest/_sources/simplepyble/api.rst

Links to example scripts demonstrating various functionalities of the SimplePyBLE library.

```APIDOC
## Example Usage

Refer to the `examples`_ directory in the repository for practical usage of SimplePyBLE.

### Available Examples:

* `list_adapters`_: Lists all available Bluetooth adapters.
* `scan`_: Scans for nearby Bluetooth Low Energy devices.
* `connect`_: Connects to a BLE device, lists its services and characteristics.
* `read`_: Reads the value of a BLE characteristic.
* `write`_: Writes a value to a BLE characteristic.
* `notify`_: Enables notifications for changes on a BLE characteristic.

.. _examples: https://github.com/simpleble/simpleble/tree/main/examples/simplepyble
.. _list_adapters: https://github.com/simpleble/simpleble/tree/main/examples/simplepyble/list_adapters.py
.. _scan: https://github.com/simpleble/simpleble/tree/main/examples/simplepyble/scan.py
.. _connect: https://github.com/simpleble/simpleble/tree/main/examples/simplepyble/connect.py
.. _read: https://github.com/simpleble/simpleble/tree/main/examples/simplepyble/read.py
.. _write: https://github.com/simpleble/simpleble/tree/main/examples/simplepyble/write.py
.. _notify: https://github.com/simpleble/simpleble/tree/main/examples/simplepyble/notify.py

```

--------------------------------

### Vendorize SimpleDBus with CMake FetchContent

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpledbus/usage.rst

Example of using CMake's FetchContent module to download and integrate SimpleDBus directly from a Git repository. This approach is useful for managing dependencies within your project.

```cmake
include(FetchContent)
FetchContent_Declare(
    simpledbus
    GIT_REPOSITORY <simpledbus-git-repository>
    GIT_TAG <simpledbus-git-tag>
    GIT_SHALLOW YES
)

# Note that here we manually do what FetchContent_MakeAvailable() would do,
# except to ensure that the dependency can also get what it needs, we add
# custom logic between the FetchContent_Populate() and add_subdirectory()
# calls.
FetchContent_GetProperties(simpledbus)
if(NOT simpledbus_POPULATED)
    FetchContent_Populate(simpledbus)
    list(APPEND CMAKE_MODULE_PATH "${simpledbus_SOURCE_DIR}/cmake/find")
    add_subdirectory("${simpledbus_SOURCE_DIR}/simpledbus" "${simpledbus_BINARY_DIR}")
endif()

set(simpledbus_FOUND 1)
```

```cmake
find_package(simpledbus REQUIRED)
target_link_libraries(<your-target> simpledbus::simpledbus)
```

--------------------------------

### Install Testing Dependencies

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This command installs the necessary system packages (libgtest-dev, libgmock-dev, python3-dev) and Python dependencies for running SimpleBLE tests. These packages are essential for compiling and executing the unit and integration tests.

```bash
sudo apt install libgtest-dev libgmock-dev python3-dev
pip3 install -r <path-to-simpleble>/test/requirements.txt
```

--------------------------------

### Install SimpleBluez with CMake

Source: https://simpleble.readthedocs.io/en/latest/simplebluez/usage

Commands to install the SimpleBluez library after building it. You can specify an installation prefix and may need sudo privileges on Linux/macOS.

```bash
cmake --install build_simplebluez
```

```bash
cmake --install build_simplebluez --prefix /usr/local
```

```bash
sudo cmake --install build_simplebluez
```

--------------------------------

### Install CMake Project with Custom Prefix

Source: https://simpleble.readthedocs.io/en/latest/_sources/cmake_primer.rst

This command installs a CMake project to a user-defined location specified by the --prefix argument. This allows for flexible installation paths, useful for testing or non-standard deployments. The installation directory is explicitly provided.

```bash
cmake --install <your-build-directory> --prefix <your-installation-directory>
```

--------------------------------

### Install SimpleBLE using CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

Installs the SimpleBLE library after it has been built. This command can also be used to specify a custom installation prefix. On Linux and macOS, administrator privileges are required.

```bash
# Install to default location
cmake --install build_simpleble

# Install to a specific prefix
cmake --install build_simpleble --prefix /usr/local

# Install with sudo (Linux/macOS)
sudo cmake --install build_simpleble
```

--------------------------------

### Configure SimpleBluez Build Options with CMake

Source: https://simpleble.readthedocs.io/en/latest/simplebluez/usage

Examples of setting CMake variables to customize the SimpleBluez build. This includes enabling shared libraries, setting log levels, and using the DBus session bus.

```bash
cmake -S <path-to-simplebluez> -B build_simplebluez -DBUILD_SHARED_LIBS=TRUE
```

```bash
cmake -S <path-to-simplebluez> -B build_simplebluez -DSIMPLEBLUEZ_LOG_LEVEL=DEBUG
```

```bash
cmake -S <path-to-simplebluez> -B build_simplebluez -DSIMPLEBLUEZ_USE_SESSION_DBUS=TRUE
```

--------------------------------

### Install Dependencies with pip

Source: https://simpleble.readthedocs.io/en/latest/_sources/extras.rst

Installs project dependencies required for building documentation. It assumes Python 3 and pip are available. The command reads package requirements from a specified file.

```shell
pip3 install -r docs/requirements.txt
```

--------------------------------

### Build HTML Documentation with Make

Source: https://simpleble.readthedocs.io/en/latest/_sources/extras.rst

Builds HTML documentation for the project after dependencies are installed. This command navigates to the docs directory and executes the make html command, requiring Make to be installed.

```shell
cd <path-to-repository>/docs
make html
```

--------------------------------

### Install with sudo on Linux/MacOS

Source: https://simpleble.readthedocs.io/en/latest/_sources/cmake_primer.rst

This command demonstrates how to install CMake-built projects to system directories on Linux or MacOS, which typically requires administrator privileges.

```bash
sudo cmake --install <your-build-directory>
```

--------------------------------

### Install BlueZ Dependencies on Fedora/CentOS

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

Installs the necessary development files for the DBus library on RPM-based Linux distributions like Fedora and CentOS. This is required for building SimpleBLE on these systems.

```bash
# On Fedora
sudo dnf install dbus-devel

# On CentOS
sudo yum install dbus-devel
```

--------------------------------

### Configure SimpleBLE Build with CMake Options

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

Demonstrates how to customize the SimpleBLE build using CMake variables. Options include building shared libraries, enabling a 'plain' flavor, setting the log level, and forcing the use of the DBus session bus on Linux.

```bash
# Build shared library
cmake -S <path-to-simpleble> -B build_simpleble -DBUILD_SHARED_LIBS=TRUE

# Build plain flavor
cmake -S <path-to-simpleble> -B build_simpleble -DSIMPLEBLE_PLAIN=TRUE

# Set log level
cmake -S <path-to-simpleble> -B build_simpleble -DSIMPLEBLE_LOG_LEVEL=DEBUG

# Force session DBus (Linux only)
cmake -S <path-to-simplebluez> -B build_simplebluez -DSIMPLEBLE_USE_SESSION_DBUS=TRUE
```

--------------------------------

### Set Scan Start Callback in C++

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/tutorial.rst

Demonstrates how to set a callback function that will be executed when a Bluetooth scan starts using SimpleBLE. This allows for asynchronous handling of scan events.

```cpp
// Set the callback to be called when the scan starts
   adapter.set_callback_on_scan_start([]() {
      std::cout << "Scan started" << std::endl;
   });
```

--------------------------------

### Install CMake Project

Source: https://simpleble.readthedocs.io/en/latest/_sources/cmake_primer.rst

This command installs the built artifacts of a CMake project to a designated location on the system. By default, it uses standard system locations. This step makes the software accessible system-wide or for other projects.

```bash
cmake --install <your-build-directory>
```

--------------------------------

### Install SimpleBLE

Source: https://simpleble.readthedocs.io/en/latest/simpleble/usage

Installs the SimpleBLE library after it has been built. This command copies the necessary library files and headers to the appropriate system locations, making it available for other projects.

```shell
cmake --install build_simpleble

```

--------------------------------

### Install Testing Dependencies

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpledbus/usage.rst

Installs the required system and Python packages for running SimpleDBus unit and integration tests. This includes Google Test, Google Mock, and Python development headers.

```bash
sudo apt install libgtest-dev libgmock-dev python3-dev
pip3 install -r <path-to-simpledbus>/test/requirements.txt
```

--------------------------------

### Install SimpleBluez with sudo

Source: https://simpleble.readthedocs.io/en/latest/_sources/simplebluez/usage.rst

Command to install SimpleBluez using sudo, necessary for installing to system-wide directories on Linux and macOS.

```bash
sudo cmake --install build_simplebluez
```

--------------------------------

### Configure CMake Project with Install Prefix

Source: https://simpleble.readthedocs.io/en/latest/_sources/cmake_primer.rst

This command configures a CMake project while also setting a custom installation prefix using the -D CMAKE_INSTALL_PREFIX argument. This predefines the installation location for subsequent build and install steps. It requires specifying source and build directories.

```bash
cmake -S <path-to-source> -B <your-build-directory> -DCMAKE_INSTALL_PREFIX=<your-installation-directory>
```

--------------------------------

### Vendorize SimpleBLE using FetchContent in CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This CMake code uses FetchContent to download and build SimpleBLE from a Git repository. It includes custom logic to ensure dependencies are met before adding the SimpleBLE subdirectory. This approach allows for controlled updates and integration of SimpleBLE.

```cmake
include(FetchContent)
FetchContent_Declare(
    simpleble
    GIT_REPOSITORY <simpleble-git-repository>
    GIT_TAG <simpleble-git-tag>
    GIT_SHALLOW YES
)

FetchContent_GetProperties(simpleble)
if(NOT simpleble_POPULATED)
    FetchContent_Populate(simpleble)
    list(APPEND CMAKE_MODULE_PATH "${simpleble_SOURCE_DIR}/cmake/find")
    add_subdirectory("${simpleble_SOURCE_DIR}/simpleble" "${simpleble_BINARY_DIR}")
endif()

set(simpleble_FOUND 1)
```

--------------------------------

### Install SimpleBLE Locally

Source: https://simpleble.readthedocs.io/en/latest/_sources/simplepyble/usage.rst

Installs SimpleBLE from a local source, typically after cloning the repository. This method is useful for development or accessing the latest unreleased features. It requires navigating to the library's directory and then running pip.

```shell
cd <path-to-simpleble>/simplepyble
pip install .
```

--------------------------------

### Set Installation Prefix with CMAKE_INSTALL_PREFIX

Source: https://simpleble.readthedocs.io/en/latest/cmake_primer

Customize the installation directory for the project using the CMAKE_INSTALL_PREFIX variable. This allows for non-standard installations or testing without affecting system directories. The prefix is set either during installation or configuration.

```bash
cmake --install <your-build-directory> --prefix <your-installation-directory>
```

```bash
cmake -S <path-to-source> -B <your-build-directory> -DCMAKE_INSTALL_PREFIX=<your-installation-directory>
cmake --build <your-build-directory> -j4
cmake --install <your-build-directory>
```

```bash
sudo cmake --install <your-build-directory>
```

--------------------------------

### Build and Run SimpleBLE Unit Tests with CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This set of CMake commands configures, builds, and runs the unit tests for SimpleBLE. It specifies the source directory, build directory, and enables testing. The final command executes the compiled test binary.

```bash
cmake -S <path-to-simpleble> -B build_simpleble_test -DSIMPLEBLE_TEST=ON
cmake --build build_simpleble_test -j7
./build_simpleble_test/bin/simpleble_test
```

--------------------------------

### Install SimpleBluez Library

Source: https://simpleble.readthedocs.io/en/latest/_sources/simplebluez/usage.rst

Command to install the SimpleBluez library after it has been built. This typically requires administrative privileges on Linux and macOS.

```bash
cmake --install build_simplebluez
```

--------------------------------

### Install SimpleBluez to Specific Prefix

Source: https://simpleble.readthedocs.io/en/latest/_sources/simplebluez/usage.rst

Command to install the SimpleBluez library to a custom installation path by specifying the CMAKE_INSTALL_PREFIX variable.

```bash
cmake --install build_simplebluez --prefix /usr/local
```

--------------------------------

### Asynchronous Peripheral Scanning with Callbacks (C++)

Source: https://simpleble.readthedocs.io/en/latest/simpleble/tutorial

Demonstrates asynchronous scanning for BLE peripherals using SimpleBLE with callback functions. It allows setting callbacks for scan start, stop, peripheral found, and peripheral updated events. The scan is started, run for a duration, and then stopped. Dependencies include SimpleBLE, chrono, and thread.

```cpp
// Set the callback to be called when the scan starts
adapter.set_callback_on_scan_start([]() {
   std::cout << "Scan started" << std::endl;
});

// Set the callback to be called when the scan stops
adapter.set_callback_on_scan_stop([]() {
   std::cout << "Scan stopped" << std::endl;
});

// Set the callback to be called when the scan finds a new peripheral
adapter.set_callback_on_scan_found([](SimpleBLE::Peripheral peripheral) {
   std::cout << "Peripheral found: " << peripheral.identifier() << std::endl;
});

// Set the callback to be called when a peripheral property has changed
adapter.set_callback_on_scan_updated([](SimpleBLE::Peripheral peripheral) {
   std::cout << "Peripheral updated: " << peripheral.identifier() << std::endl;
});

// Start scanning for peripherals
adapter.scan_start();

// Wait for 5 seconds
std::this_thread::sleep_for(std::chrono::seconds(5));

// Stop scanning for peripherals
adapter.scan_stop();

```

--------------------------------

### Install Linux Dependencies for SimpleBLE

Source: https://simpleble.readthedocs.io/en/latest/_sources/simplepyble/usage.rst

Installs the necessary development libraries for D-Bus on Debian-based Linux systems, which are required for SimpleBLE to function correctly. This command should be run with superuser privileges.

```shell
sudo apt-get install libdbus-1-dev
```

--------------------------------

### Install SimpleBLE with Sudo Privileges

Source: https://simpleble.readthedocs.io/en/latest/simpleble/usage

Installs the SimpleBLE library using CMake with sudo privileges. This is typically required on Linux and macOS when installing to system-wide directories that need elevated permissions.

```shell
sudo cmake --install build_simpleble

```

--------------------------------

### Install libdbus-1-dev on APT-based Distros

Source: https://simpleble.readthedocs.io/en/latest/_sources/simplebluez/usage.rst

Command to install the libdbus-1-dev package on Debian-based Linux distributions using APT. This is a general requirement for building SimpleBluez.

```bash
sudo apt install libdbus-1-dev
```

--------------------------------

### Install dbus-devel on Fedora

Source: https://simpleble.readthedocs.io/en/latest/_sources/simplebluez/usage.rst

Command to install the dbus-devel package on Fedora Linux using DNF. This is a general requirement for building SimpleBluez.

```bash
sudo dnf install dbus-devel
```

--------------------------------

### Install Linux Dependencies for SimpleBLE

Source: https://simpleble.readthedocs.io/en/latest/simplepyble/usage

Installs the necessary libdbus-1-dev dependency required for SimpleBLE to function on Linux systems. This command uses apt-get, common on Debian-based distributions. It requires root privileges (sudo).

```shell
sudo apt-get install libdbus-1-dev

```

--------------------------------

### Run SimpleDBus Unit Tests with CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpledbus/usage.rst

Configures and builds the SimpleDBus project to run unit tests. It uses CMake to set the test flag and then compiles the test executable.

```bash
cmake -S <path-to-simpledbus> -B build_simpledbus_test -DSIMPLEDBUS_TEST=ON
cmake --build build_simpledbus_test -j7
./build_simpledbus_test/bin/simpledbus_test
```

--------------------------------

### Build SimpleDBus with CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpledbus/usage.rst

Commands to compile the SimpleDBus library using CMake. This includes basic build commands and options for customizing the build, such as enabling shared libraries or setting the log level.

```bash
cmake -S <path-to-simpledbus> -B build_simpledbus
cmake --build build_simpledbus -j7
```

```bash
cmake -S <path-to-simpledbus> -B build_simpledbus -DBUILD_SHARED_LIBS=TRUE
```

```bash
cmake -S <path-to-simpledbus> -B build_simpledbus -DSIMPLEDBUS_LOG_LEVEL=DEBUG
```

```bash
cmake -S <path-to-simpledbus> -B build_simpledbus -DSIMPLEDBUS_USE_SESSION_DBUS=TRUE
```

--------------------------------

### Connect to a Peripheral using C++

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/tutorial.rst

This code shows how to scan for BLE peripherals for a specified duration and then connect to the first peripheral found in the results. It requires a prior scan operation to obtain a list of peripherals.

```cpp
// Scan for peripherals for 5000 milliseconds
std::vector<SimpleBLE::Peripheral> peripherals = adapter.scan_for(5000);

// Connect to the first peripheral
SimpleBLE::Peripheral peripheral = peripherals[0];
peripheral.connect();

```

--------------------------------

### Link SimpleBLE Library with CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This snippet shows how to link the SimpleBLE library to your target using CMake. It assumes SimpleBLE is installed in the CMake module path.

```cmake
target_link_libraries(<your-target> simpleble::simpleble)
```

--------------------------------

### Find and Use SimpleBLE in CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

Shows how to integrate the installed SimpleBLE library into another CMake project. The `find_package` command makes the SimpleBLE targets available for linking.

```cmake
find_package(simpleble REQUIRED CONFIG)
```

--------------------------------

### Include Specific SimpleBLE Headers

Source: https://simpleble.readthedocs.io/en/latest/simpleble/tutorial

This snippet demonstrates how to include specific header files for individual SimpleBLE components like Adapter, Peripheral, Service, Characteristic, and Descriptor. This approach allows for more granular control over dependencies and can lead to smaller build sizes.

```cpp
#include <simpleble/Adapter.h>
#include <simpleble/Peripheral.h>
#include <simpleble/Service.h>
#include <simpleble/Characteristic.h>
#include <simpleble/Descriptor.h>

```

--------------------------------

### Add SimpleBLE as a Subdirectory in CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This CMake snippet demonstrates how to add SimpleBLE as a subdirectory to your project, allowing you to link against it. This is useful for local development or when SimpleBLE is part of your project's source tree.

```cmake
add_subdirectory(<path-to-simpleble> ${CMAKE_BINARY_DIR}/simpleble)
target_link_libraries(<your-target> simpleble::simpleble)
```

--------------------------------

### Build SimpleBLE using CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

Compiles the SimpleBLE library using CMake. This involves configuring the build by specifying the source and build directories, and then initiating the build process. The `-j7` flag enables parallel compilation.

```bash
cmake -S <path-to-simpleble> -B build_simpleble
cmake --build build_simpleble -j7
```

--------------------------------

### Scan for Peripherals in C++

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/tutorial.rst

This code snippet shows how to scan for Bluetooth peripherals using a SimpleBLE adapter. It retrieves available adapters, selects the first one, initiates a scan for a specified duration, and then lists the identifiers and addresses of discovered peripherals.

```cpp
// Get a list of all available adapters
   std::vector<SimpleBLE::Adapter> adapters = SimpleBLE::Adapter::get_adapters();

   // Get the first adapter
   SimpleBLE::Adapter adapter = adapters[0];

   // Scan for peripherals for 5000 milliseconds
   adapter.scan_for(5000);

   // Get the list of peripherals found
   std::vector<SimpleBLE::Peripheral> peripherals = adapter.scan_get_results();

   // Print the identifier of each peripheral
   for (auto peripheral : peripherals) {
       std::cout << "Peripheral identifier: " << peripheral.identifier() << std::endl;
       std::cout << "Peripheral address: " << peripheral.address() << std::endl;
   }
```

--------------------------------

### Build and Run SimpleBLE Thread Sanitizer Tests with CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This command sequence configures, builds, and runs SimpleBLE tests with Thread Sanitizer enabled. Thread Sanitizer helps detect data races and other threading issues in the code.

```bash
cmake -S <path-to-simpleble> -B build_simpleble_test -DSIMPLEBLE_SANITIZE=Thread -DSIMPLEBLE_TEST=ON
cmake --build build_simpleble_test -j7
./build_simpleble_test/bin/simpleble_test
```

--------------------------------

### Perform Clean Build with CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/cmake_primer.rst

Demonstrates how to perform a clean build by removing the build directory and re-running the CMake configuration and build commands. This ensures a fresh build environment.

```bash
rm -rf <your-build-directory>
cmake -S <path-to-source> -B <your-build-directory>
```

--------------------------------

### Find and Link SimpleBLE in CMake after Vendorizing

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This CMake snippet shows how to find and link the SimpleBLE library after it has been vendorized using FetchContent. It's the standard way to consume SimpleBLE once it's available in your project's build environment.

```cmake
find_package(simpleble REQUIRED)
target_link_libraries(<your-target> simpleble::simpleble)
```

--------------------------------

### Check Bluetooth Status and Get Adapters in C++

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/tutorial.rst

Demonstrates how to check if Bluetooth is enabled and retrieve a list of available Bluetooth adapters using SimpleBLE. It handles cases where Bluetooth is not enabled or no adapters are found, and prints the identifier and address of the first found adapter.

```cpp
#include <simpleble/SimpleBLE.h>
#include <iostream>

int main(int argc, char** argv) {
   if (!SimpleBLE::Adapter::bluetooth_enabled()) {
      std::cout << "Bluetooth is not enabled" << std::endl;
      return 1;
   }

   auto adapters = SimpleBLE::Adapter::get_adapters();
   if (adapters.empty()) {
      std::cout << "No Bluetooth adapters found" << std::endl;
      return 1;
   }

   // Use the first adapter
   auto adapter = adapters[0];

   // Do something with the adapter
   std::cout << "Adapter identifier: " << adapter.identifier() << std::endl;
   std::cout << "Adapter address: " << adapter.address() << std::endl;

   return 0;
}
```

--------------------------------

### Include Specific SimpleBLE Headers

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/tutorial.rst

Includes specific header files for more granular control over which SimpleBLE components are used. Each header includes the ones below it in the list.

```cpp
#include <simpleble/Adapter.h>
#include <simpleble/Peripheral.h>
#include <simpleble/Service.h>
#include <simpleble/Characteristic.h>
#include <simpleble/Descriptor.h>
```

--------------------------------

### Build and Run SimpleBLE Address Sanitizer Tests with CMake

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This command sequence builds and runs SimpleBLE tests with Address Sanitizer enabled. It's crucial to set PYTHONMALLOC=malloc to prevent false positives from Python's memory allocator interfering with the sanitizer.

```bash
cmake -S <path-to-simpleble> -B build_simpleble_test -DSIMPLEBLE_SANITIZE=Address -DSIMPLEBLE_TEST=ON
cmake --build build_simpleble_test -j7
PYTHONMALLOC=malloc ./build_simpleble_test/bin/simpleble_test
```

--------------------------------

### Scan for Peripherals using C++

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/tutorial.rst

This snippet demonstrates how to set up callbacks for scan start, found, and update events, then initiate and stop a BLE scan. It utilizes `std::this_thread::sleep_for` for a timed scan duration.

```cpp
// Set the callback to be called when the scan stops
adapter.set_callback_on_scan_stop([]() {
   std::cout << "Scan stopped" << std::endl;
});

// Set the callback to be called when the scan finds a new peripheral
adapter.set_callback_on_scan_found([](SimpleBLE::Peripheral peripheral) {
   std::cout << "Peripheral found: " << peripheral.identifier() << std::endl;
});

// Set the callback to be called when a peripheral property has changed
adapter.set_callback_on_scan_updated([](SimpleBLE::Peripheral peripheral) {
   std::cout << "Peripheral updated: " << peripheral.identifier() << std::endl;
});

// Start scanning for peripherals
adapter.scan_start();

// Wait for 5 seconds
std::this_thread::sleep_for(std::chrono::seconds(5));

// Stop scanning for peripherals
adapter.scan_stop();

```

--------------------------------

### Include SimpleBLE Android Bridge in settings.gradle (Groovy)

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This Groovy snippet demonstrates how to include the SimpleBLE Android bridge module in your Android project's settings.gradle file. This is necessary for using SimpleBLE with native Android code, as it provides bridge classes required by the Android JVM.

```groovy
includeBuild("path/to/simpleble/src/backends/android/simpleble-bridge") {
    dependencySubstitution {
        substitute module("org.simpleble.android.bridge:simpleble-bridge") with project(":")
    }
}
```

--------------------------------

### Include SimpleBLE Android Bridge in settings.gradle (Kotlin)

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/usage.rst

This Kotlin snippet shows how to include the SimpleBLE Android bridge module in your Android project's settings.gradle file using Kotlin DSL. It serves the same purpose as the Groovy version, providing necessary bridge classes for native Android development with SimpleBLE.

```kotlin
includeBuild("path/to/simpleble/src/backends/android/simpleble-bridge") {
 dependencySubstitution {
 substitute(module("org.simpleble.android.bridge:simpleble-bridge")).using(project(":ጃ"))
 }
}
```

--------------------------------

### Build SimpleBLE with CMake

Source: https://simpleble.readthedocs.io/en/latest/simpleble/usage

Demonstrates the basic CMake commands to configure and build the SimpleBLE library. It initializes the build directory and then proceeds to build the project. The build process can be parallelized using the -j flag.

```shell
cmake -S <path-to-simpleble> -B build_simpleble
cmake --build build_simpleble -j7

```

--------------------------------

### Standard API - Adapter

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/api.rst

Documentation for the SimpleBLE::Adapter class in the standard API.

```APIDOC
## SimpleBLE::Adapter (Standard API)

### Description
Provides methods for interacting with Bluetooth adapters.

### Method
N/A (Class documentation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

```

--------------------------------

### Install SimpleBLE to Specific Prefix

Source: https://simpleble.readthedocs.io/en/latest/simpleble/usage

Installs the SimpleBLE library to a custom installation prefix using CMake. The CMAKE_INSTALL_PREFIX variable is set to '/usr/local', allowing for flexible deployment.

```shell
cmake --install build_simpleble --prefix /usr/local

```

--------------------------------

### C API - Adapter

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpleble/api.rst

Documentation for the C API related to adapter functionality.

```APIDOC
## C API - Adapter (`adapter.h`)

### Description
Provides C-style functions for managing Bluetooth adapters.

### Method
N/A (File documentation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

```

--------------------------------

### Integrate SimpleDBus in CMake (Installed)

Source: https://simpleble.readthedocs.io/en/latest/_sources/simpledbus/usage.rst

How to find and link the SimpleDBus library within a CMake project after it has been installed. This uses `find_package` to locate the library and `target_link_libraries` to link it to your target.

```cmake
find_package(simpledbus REQUIRED CONFIG)
target_link_libraries(<your-target> simpledbus::simpledbus)
```
Tokens:
Raw